Como excluir um nó em uma lista vinculada C ++

Uma lista vinculada é basicamente uma combinação de duas coisas: a parte da informação e a parte do endereço. A parte do endereço, também chamada de ponteiro ou próximo link do nó, armazena o endereço do próximo nó. A lista vinculada é basicamente uma estrutura de dados linear que armazena dados dinamicamente através de ponteiros que podem ser facilmente acessados ​​pelo ponteiro anterior do nó.

O nó da lista vinculada se parece com o seguinte:

Em comparação com a matriz, a lista vinculada não é uma estrutura de dados seqüencial, porque é uma estrutura de dados armazenada dinamicamente. Ele armazena todos os dados em diferentes locais da memória e podemos acessar esses dados através do ponteiro do nó que armazena o endereço dos dados.

Essa maneira de armazenar dados tem esses benefícios:

1. Não temos um tamanho de memória predefinido como uma matriz, o que leva a muito desperdício de memória.

2. Em uma matriz, se definirmos uma memória uma vez, não podemos diminuir ou aumentá -la de acordo com nossos requisitos. Mas em uma lista vinculada, podemos aumentar ou diminuir os nós de acordo com nossos requisitos.

A lista vinculada é assim:

Cada lista vinculada possui um nó de cabeçalho, que é o primeiro nó da lista vinculada; e um nó de cauda que está presente no final da lista vinculada. Do nó da cauda, ​​a lista vinculada apontando para o próximo nó acabou porque armazena o endereço nulo, o que não significa nada. Se alguma lista vinculada tiver apenas um nó, significa que o nó do cabeçalho e o nó da cauda são os mesmos.

Exclusão de uma lista vinculada:

Como dado abaixo, podemos excluir um nó de uma lista vinculada de três maneiras:

1. Exclua o primeiro nó da lista vinculada

2. Exclua o último nó da lista vinculada

3. Excluir um nó de posição específico

Explicação de todos esses conceitos:

Exclua o primeiro nó da lista vinculada (o nó do cabeçalho):-

Para excluir o primeiro nó da lista vinculada significa excluir o nó do cabeçalho (primeiro nó) da lista vinculada. Para fazer isso, temos que seguir o seguinte procedimento:

a. Temos que criar um ponteiro (temporário).

b. O endereço do nó do cabeçalho é copiado para o ponteiro (temporário).

c. Agora, armazenamos o endereço do nó do cabeçalho. Portanto, podemos declarar o próximo nó do cabeçalho como uma lista vinculada Primeiro nó.

Excluir o primeiro nó significa que o nó do cabeçalho é simples:

Código C ++ para excluir o primeiro nó da lista vinculada:

void DeLeTelinkedListfirstNode ()

nó *temporário = novo nó;
TemporaryNode = HeadNode;
HeadNode = HeadNode-> Next;
excluir temporário;

Excluindo o último nó (nó da cauda):

Excluir o nó do cabeçalho da lista vinculado foi simples. Mas quando queríamos excluir o último nó da lista vinculada ou nó da cauda, ​​temos que transferir o ponteiro nulo do nó da cauda para o nó anterior da cauda, ​​que tem o endereço do nó da cauda.

Para implementar isso, devemos usar dois nós temporários e percorrer a lista vinculada. Quando a lista vinculada de travessia terminar, o nó temporário apontará para o nó atual e outro nó temporário apontará para o nó anterior. Agora, ambos os nós necessários abordam os detalhes que temos e podemos excluir o nó da cauda enquanto muda o ponteiro nulo para o nó anterior.

Código C ++ para excluir o último nó da lista vinculada:

Void DeLeTelinkedListLastNode ()

nó *currentNode = new Node;
nó *anteriorNode = new Node;
currentNode = headNode;
while (CurrentNode-> Próximo!= Nulo)

anteriornode = currentNode;
Current = CurrentNode-> Next;

Tail = anteriorNode;
anteriornode-> a seguir = null;
Excluir CurrentNode;

Excluindo o nó na posição específica:

Para excluir um nó de qualquer lugar da lista vinculada, devemos inserir a posição específica do nó que queremos excluir. Para definir o nó de posição específico, usamos dois nós temporários, como fizemos enquanto excluímos o nó da cauda. Atravessamos toda a lista vinculada até que não obtenhamos o nó de posição específico que queremos excluir e, depois de obter esse nó, o outro nó temporário manterá o endereço do nó anterior do nó atual. Agora, como temos detalhes do nó, podemos mudar facilmente o endereço do nó de exclusão para o nó de endereço anterior, que agora apontará para o próximo nó, assim como no método excluído anterior do último nó.

Código C ++ para excluir o nó nono da lista vinculada:

void DeLeTenthPositionNode (int positionNumber)
nó *currentNode = new Node;
nó *anteriorNode = new Node;
currentNode = headNode;
para (int conting = 1; ianteriornode = currentNode;
CurrentNode = CurrentNode-> Next;

anteriorNode-> Next = CurrentNode-> Next;

Programa C ++ para excluir um nó nono da lista vinculada

#incluir
usando namespace std;
classe LinkedListNode
público:
int info;
LinkedListNode *ponteiro;
;
int LengthCalCulate (linkedListNode* node)
int conting = 0;
while (nó!= Null)
nó = nó-> ponteiro;
contagem ++;

contagem de retorno;

INSERT void (LinkedListNode ** HeadNode, int info)
LinkedListNode* newNode = new LinkedListNode ();
newNode-> info = info;
newNode-> ponteiro = *headNode;
*headNode = newNode;

void DeLeteNodemethod (int conting, LinkedListNode ** HeadNode)
LinkedListNode * TemporaryNode = * HeadNode;
LinkedListNode* anteriorNode;
int length = comprimentoCalculate (*HeadNode);
if (contagem < 1 || count > comprimento)
cout << "Deletion of linked list node is not valid" << endl;
retornar;

// Esta fucção excluirá o primeiro nó da lista vinculada
if (count == 1)
*HeadNode = (*HeadNode)-> ponteiro;
cout << temporaryNode->informações << " deleted the linked first node" << endl;
excluir (temporário);
retornar;

// isso enquanto o loop parará quando for alcançado no
// Fim da lista vinculada
while (--count)
anteriornode = temporário;
temporário = temporário-> ponteiro;

// Esta linha atualizará o ponteiro anterior do Node
// com o enésimo ponteiro de nó da lista vinculado
anteriorNode-> ponteiro = temporário-> ponteiro;
// Este código excluirá o nó do nó da lista vinculada
cout << temporaryNode->informações << " deleted" << endl;;
excluir (temporário);

Void DisplayLinkedList (LinkedListNode* Item)
cout << "\nDisplaying LinkedList => : ";
// Esta condição vai parar quando o LinkedList atingiu no final
while (item!= Null)
cout << item->informações << " ";
item = item-> ponteiro;

cout << endl;

int main ()
LinkedListNode* headNode = null;
inserir (& headnode, 29);
inserir (& headnode, 34);
inserir (& headnode, 23);
inserir (& headnode, 27);
inserir (& headnode, 31);
inserir (& headnode, 50);
DisplayLinkedList (HeadNode);
cout << "\n Deleting node number 3 = ";
deletenodemethod (3, & HeadNode);
cout << "\n After delete node number 3, linked list will be =";
DisplayLinkedList (HeadNode);
cout << "\n Deleting node number 5 = ";
deletenodemethod (5, & headNode);
cout << "\n After delete node number 5, linked list will be =";
DisplayLinkedList (HeadNode);
retornar 0;

Saída:

Exibindo LinkedList =>: 50 31 23 23 34 29
Excluindo o número 3 = 27 excluído
Após a exclusão do nó número 3, a lista vinculada será =
Exibindo LinkedList =>: 50 31 23 34 29
Excluindo o número 5 = 29 excluído
Após a exclusão do nó número 5, a lista vinculada será =
Exibindo LinkedList =>: 50 31 23 34

Conclusão:

Neste blog, estudamos maneiras diferentes de excluir os conceitos da lista vinculada e como podemos codificar em um programa C ++ também. Finalmente, estudamos os principais conceitos de excluir o nó de uma posição específica. Os conceitos de lista vinculados são sempre importantes porque é a maneira de brincar com a memória do sistema operacional e tem muitos benefícios em comparação com a matriz.