_Créditos das imagens: ChatGPT
# Desafio LeetCode 19: Remove Nth Node From End of List
*Como simular listas ligadas em Harbour e TLPP*
No desafio [LeetCode 19](https://leetcode.com/problems/remove-nth-node-from-end-of-list/), a tarefa é remover o N-ésimo nó a partir do final de uma lista encadeada e retornar a cabeça da lista. Apesar de linguagens como Harbour e TLPP não oferecerem suporte nativo para _linked lists_, diversos desenvolvedores têm encontrado soluções criativas para simular essa estrutura. Nesta postagem, vamos explorar quatro implementações em Harbour e as versões equivalentes em TLPP, destacando as diferenças entre elas – com ênfase especial na **Implementação 4**.
---
## Implementações em Harbour
### Versão 1 – Manipulação de Arrays com Funções Internas
A **Versão 1** utiliza arrays para simular a lista. A ideia é:
- Clonar o array original.
- Calcular o índice do nó a ser removido com base no tamanho do array e no parâmetro `n`.
- Remover o elemento utilizando as funções `aDel` e `aSize`.
**Pontos Fortes:**
- Implementação direta e simples.
- Uso de funções internas para remoção e redimensionamento.
**Link:**
[Versão 1 no GitHub](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/hb/019/remove_nth_node_from_end_of_list.19.1.prg)
---
### Versão 2 – Validação e Remoção com Condições
A **Versão 2** também baseia sua lógica em arrays, mas refina a validação dos índices:
- Clona o array e calcula o tamanho.
- Verifica se `nTarget` é válido (maior que 0 e menor ou igual ao tamanho do array).
- Realiza a remoção com `aDel` e ajusta o tamanho com `aSize`.
**Diferencial:**
- Validação mais robusta para evitar erros em casos de borda.
**Link:**
[Versão 2 no GitHub](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/hb/019/remove_nth_node_from_end_of_list.19.2.prg)
---
### Versão 3 – Criação de Novo Array
Nesta versão, o desenvolvedor optou por evitar as funções de remoção internas:
- Cria um novo array com tamanho reduzido.
- Copia todos os elementos do array original, exceto o que deve ser removido.
**Pontos Fortes:**
- Abordagem funcional que evita modificar o array original diretamente.
- Controle total sobre a cópia dos dados.
**Link:**
[Versão 3 no GitHub](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/hb/019/remove_nth_node_from_end_of_list.19.3.prg)
---
### Versão 4 – Simulação de Lista Ligada com Classes (Destaque)
A **Implementação 4** é a mais avançada e merece destaque. Nesta abordagem, o desenvolvedor cria uma classe de nó personalizada (`TListNode`) para simular uma lista encadeada de forma orientada a objetos. Os principais pontos dessa versão são:
- **Conversão entre Array e Lista:**
São implementadas funções `arrayToList` e `listToArray` para facilitar a conversão, permitindo que os casos de teste definidos em arrays sejam processados como listas.
- **Dummy Node e Ponteiros:**
A técnica do nó _dummy_ é usada para simplificar a remoção do nó, especialmente quando a cabeça da lista precisa ser removida. Dois "ponteiros" (objetos) – `oFirst` e `oSecond` – são avançados de forma a identificar o nó anterior ao alvo para remoção.
- **Orientação a Objetos:**
Ao criar a classe `TListNode`, a implementação se aproxima mais da estrutura tradicional de listas encadeadas, facilitando a compreensão do algoritmo mesmo na ausência de suporte nativo.
**Vantagens da Versão 4:**
- **Estrutura Modular:** A abordagem orientada a objetos deixa o código mais organizado e fácil de manter.
- **Facilidade de Extensão:** A simulação de listas ligadas permite que futuras funcionalidades (como inserções e buscas mais complexas) sejam implementadas de forma mais natural.
- **Didática:** Por imitar a estrutura clássica de uma linked list, facilita o entendimento do algoritmo proposto no desafio.
**Link:**
[Versão 4 no GitHub](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/hb/019/remove_nth_node_from_end_of_list.19.4.prg)
---
## Implementações em TLPP (Totvs Language Plus Plus)
Embora TLPP também não tenha suporte nativo para listas encadeadas, os desenvolvedores adaptaram os mesmos conceitos vistos nas versões Harbour. Atualmente, existem três versões:
- **TLPP 19.1:** Versão inicial usando arrays com remoção via funções nativas.
[Link TLPP 19.1](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/tlpp/019/remove_nth_node_from_end_of_list.19.1.tlpp)
- **TLPP 19.2:** Adição de validações e ajustes para garantir a integridade dos dados.
[Link TLPP 19.2](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/tlpp/019/remove_nth_node_from_end_of_list.19.2.tlpp)
- **TLPP 19.3:** Implementação que replica a lógica da criação de um novo array, similar à versão 3 em Harbour.
[Link TLPP 19.3](https://github.com/naldodj/naldoj-xbase-leetcode-solutions/blob/main/src/tlpp/019/remove_nth_node_from_end_of_list.19.3.tlpp)
Em TLPP, o desafio é similar: a ausência de suporte a listas encadeadas é contornada com a manipulação de arrays e, eventualmente, a simulação via classes, caso o desenvolvedor opte por uma abordagem mais orientada a objetos.
---
## Considerações Finais
Cada implementação apresentada tem suas vantagens:
- **Versões 1 e 2:** São diretas e utilizam funções nativas para manipulação de arrays, sendo rápidas de implementar, porém menos flexíveis para simular estruturas de dados dinâmicas.
- **Versão 3:** Oferece maior controle criando um novo array sem modificar o original, o que pode ser vantajoso para garantir imutabilidade.
- **Versão 4 (Destaque):** Com o uso de classes e simulação de uma linked list, essa abordagem oferece uma implementação mais didática, modular e fácil de estender. Essa versão se destaca por aproximar a lógica do problema da forma como seria implementado em linguagens com suporte nativo para listas encadeadas, tornando-a ideal para aprendizado e manutenção.
Apesar dos desafios impostos pela ausência de suporte nativo, tanto Harbour quanto TLPP demonstram que, com criatividade, é possível implementar algoritmos clássicos de estruturas de dados.
---
## Links Úteis
- **Harbour:**
- [Versão 1](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/hb/019/remove_nth_node_from_end_of_list.19.1.prg)
- [Versão 2](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/hb/019/remove_nth_node_from_end_of_list.19.2.prg)
- [Versão 3](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/hb/019/remove_nth_node_from_end_of_list.19.3.prg)
- [Versão 4](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/hb/019/remove_nth_node_from_end_of_list.19.4.prg)
- **TLPP:**
- [Versão 19.1](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/tlpp/019/remove_nth_node_from_end_of_list.19.1.tlpp)
- [Versão 19.2](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/tlpp/019/remove_nth_node_from_end_of_list.19.2.tlpp)
- [Versão 19.3](https://github.com/naldodj/naldodj-xbase-leetcode-solutions/blob/main/src/tlpp/019/remove_nth_node_from_end_of_list.19.3.tlpp)
---
## Hashtags
- #LeetCode
- #XBase
- #Harbour
- #TLPP
- #LinkedList
- #DataStructures
- #Algoritmos
- #Desenvolvimento
- #Programming
- #TechBlog
---
Esta postagem mostrou como diferentes abordagens podem ser usadas para simular listas ligadas em ambientes que não oferecem suporte nativo a elas, destacando especialmente uma solução orientada a objetos que torna o código mais modular e didático. Qual abordagem você prefere? Compartilhe suas ideias nos comentários!
---
Comentários
Postar um comentário