Imprimir lista vinculada em C ++

Quando se trata de armazenar dinamicamente itens de dados, as listas vinculadas são semelhantes a uma matriz. Uma matriz é uma estrutura de dados linear que armazena todos os itens de dados, permitindo transferir os elementos da matriz em uma operação contínua. Enquanto os elementos de dados na lista vinculada não são mantidos em locais contínuos de memória quando são armazenados. Há o ponto de partida na lista vinculada que é chamada de cabeça e o ponto final é chamado de cauda da lista vinculada na linguagem de programação C ++. Em uma lista vinculada, existem nós que armazenam objetos de dados nela. O nó tem duas partes: a peça contém o objeto de dados em si e a segunda parte contém o ponteiro em direção ao nó depois dele. O nó final da lista vinculada contém o ponteiro nulo.

Estamos usando uma lista vinculada quando temos uma matriz para armazenar os dados, porque nas matrizes temos que dizer a duração da matriz durante a declaração da matriz. Mas em listas vinculadas, o dimensionamento não é mais um problema. A duração da lista vinculada será expandida conforme o programa exige, mas a lista é restrita pela capacidade de memória que está disponível. A lista vinculada pode executar várias operações na linguagem C ++, que são: inserção, exclusão, travessia, operações de pesquisa e classificação. Para entender essas operações da lista de links, vamos implementar o exemplo e entender como uma lista vinculada funciona na linguagem de programação C ++. Também exploramos como essas operações funcionam na lista vinculada.

Exemplo:

Vamos agora começar a desenvolver o exemplo de lista vinculada da linguagem de programação C ++. Inicie o compilador e comece a escrever o código para colocar o exemplo em prática. Devemos incluir o arquivo de cabeçalho depois de executar o tradutor para torná-lo simples e fácil de acessar os métodos internos, classes e outros componentes que desejamos incluir no programa de linguagem de programação C ++.

#incluir
#incluir
usando namespace std;

O pacote "iostream" é o primeiro pacote fundamental no C ++ e é usado por todos os programas porque permite que os usuários forneçam entrada e visualize saída. O segundo cabeçalho da biblioteca padrão “stdlib.H ”fornece rotinas confiáveis ​​e eficazes para a alocação de memória dinamicamente para programadores C ++. O sinal "#" instrui o intérprete a buscar os pacotes, seguido pela palavra -chave "incluindo", dizendo para incorporar a biblioteca. Finalmente, o nome da biblioteca está escrito nos tokens "". A última frase, "Usando o namespace std", é necessária para fornecer contexto para o código.

Inicializando a estrutura

Em seguida, criaremos a estrutura do nome "nó" para que formássemos o nó da lista vinculada. Depois de criar o nó, declararemos as partes do nó na estrutura. A primeira parte do nó é onde armazenamos os elementos de dados. Então, declaramos uma variável do tipo inteiro "informações" para armazenar os elementos de dados. A próxima parte é uma variável de ponteiro "Follownode" que moverá o ponteiro em direção ao próximo folownode na lista vinculada. Os detalhes são os seguintes:

Nó da estrutura

int info;
Nó da estrutura* Follownode;
;

Inserindo elementos de dados na lista vinculada

Criamos várias funções para que possamos inserir os elementos de dados na lista vinculada que queremos criar na linguagem de programação C ++.

função beg_insert ():

Criamos uma função definida pelo usuário na linguagem de programação C ++, que é a função Beg_insert (). Como o nome sugere, usaremos esta função para inserir os dados no início da lista vinculada. A função Beg_insert () leva dois argumentos que são "head_info", que é o ponteiro para o ponteiro da cabeça da lista vinculada e o segundo argumento é "new_info", que é a data do novo Follownode que deve ser inserido. Em seguida, a função criou um "cur_node" do tipo "nó" usando a função MALLOC (). O "nó CUR" é então inicializado com o parâmetro "Novo Info" e seu ponteiro é definido na cabeça da lista conectada. Usando a referência "Informações da cabeça", a cabeça da lista vinculada está inicialmente listada no "nó cur" ".

void Beg_insert (Nó da estrutura ** Head_info, int new_info)

Nó da estrutura* CUR_NODE = (NODE STRUT*) MaiC (sizeof (nó da estrutura));
cur_node-> info = new_info;
CUR_NODE-> Follownode = (*head_info);
(*head_info) = cur_node;

função mid_insert ():

Agora, criamos outra função para inserir os elementos de dados no meio da lista gostado, que é a função MID_INSERT (). Na função MID (), temos que receber dois argumentos que são "pré -node", que é o ponteiro do tipo "nó", e "new_info", que é a variável que armazena os novos dados em si de tipo inteiro do tipo inteiro. Usamos a declaração "se" para verificar o "pré_node, se for nulo ou não no corpo da função, declaramos um" cur_node "e armazenamos o" new_info "nele. Em seguida, criamos um ponteiro "próximo" do "new_info", que aponta para o próximo nó do "pré_node".

void mid_insert (nó de estrutura* pre_node, int new_info)

if (pre_node == null)

cout << "The Previous Node Can't be NULL";
retornar;

Nó da estrutura* CUR_NODE = (NODE STRUT*) MaiC (sizeof (nó da estrutura));
cur_node-> info = new_info;
CUR_NODE-> Follownode = pre_node-> Follownode;
pre_node-> follownode = cur_node;

função end_insert ():

Criamos essa função para que possamos inserir os elementos de dados no final da lista vinculada. Declaramos os mesmos argumentos que declaramos na função Beg_insert (). Esta função verifica primeiro se a lista está vazia ou não. Coloque a "nova informação" no início da lista e devolva se a lista também for nula. Se não for nulo, o procedimento prosseguirá pela lista até atingir o nó do "último nó". A “nova informação” é então adicionada como o nó “Último nó” no final da lista.

void end_insert (nó de estrutura ** head_info, int new_info)

Nó da estrutura* CUR_NODE = (NODE STRUT*) MaiC (sizeof (nó da estrutura));
Nó da estrutura * last_node = * head_info;
cur_node-> info = new_info;
CUR_NODE-> Follownode = null;
if (*head_info == null)

*head_info = cur_node;
retornar;

while (last_node-> Follownode != Nulo)

last_node = last_node-> Follownode;
last_node-> Follownode = CUR_NODE;
retornar;

Tirando um nó de uma lista vinculada

Para remover os nós atuais da lista vinculada, agora construímos um novo método chamado Node Deliete (). Primeiro, ele determina se o próprio nó da cabeça tem o new_key que precisa ser apagado. Nesse caso, a referência da cabeça ao Follownode é atualizada. Usando um loop, ele localizará o nó que contém o new_key a ser destruído. Quando um nó é descoberto, o nó "pré" atualiza o ponteiro Follownode do nó que será destruído para que possa ser excluído sem ser visto. Finalmente, a função gratuita () é usada para liberar o armazenamento.

void delete_node (nó de estrutura ** head_info, int new_key)

Nó da estrutura *temp_var = *head_info, *pre;
if (temp_var != Null && temp_var-> info == new_key)

*head_info = temp_var-> follownode;
grátis (temp_var);
retornar;

while (temp_var != Null && temp_var-> informações != new_key)

pre = temp_var;
temp_var = temp_var-> follownode;

if (temp_var == null)

retornar;

pré-> follownode = temp_var-> follownode;
grátis (temp_var);

Pesquise o nó na lista vinculada

A função pesquisa () leva dois argumentos, que são o ponteiro para o "head_info" da lista vinculada e o "new_key", que deve ser pesquisado. A função atravessa a lista vinculada e verifica se os dados do nó atual correspondem ao "new_key". Se os dados do nó "atual" corresponderem ao "new_key", a função retorna true. Se os dados do nó "atual" não corresponderem ao "newKey", a função se move para o folownode. Se o nó "atual" se tornar nulo, a função retorna falsa.

Pesquisa bool (nó de estrutura ** head_info, int new_key)

Nó da estrutura * Current = * head_info;
while (atual != Nulo)

if (current-> info == new_key)

retornar true;

Current = Current-> Follownode;

retorna falso;

Classificando os componentes do nó na lista vinculada

Na programação C ++, o método Sort () é usado para organizar os membros na lista vinculada em ordem crescente. Primeiro, é determinado se a referência de "informação da cabeça" é nula. Se sim, voltamos. Depois disso, a lista é repetida várias vezes até o término do loop. Verificando se houver mais informações estiverem presentes no nó "atual", então no nó "índice" vem a seguir. Nesse caso, trocamos os dados entre os dois nós. O nó "índice" é então transferido para o seguinte. O procedimento é então repetido até a conclusão da lista.

Void Sort (Nó da estrutura ** Head_info)

Nó da estrutura *atual = *head_info, *index = null;
int temp_var;
if (head_info == null)

retornar;

outro

while (atual != Nulo)

ÍNDICE = CURRENT-> FOLLOWNODE;
while (índice != Nulo)

if (atual-> info> index-> ​​info)

temp_var = current-> info;
atual-> info = index-> ​​info;
índice-> info = temp_var;

Índice = Índice-> Follownode;

Current = Current-> Follownode;

Exibir o nó na lista vinculada

O Função Display () leva um ponteiro para a cabeça da lista vinculada como um parâmetro. Depois disso, passa pela lista e mostra as informações de todos os nó. Quando chega à conclusão da lista, ele para.

Void Display (Nó da estrutura* Nó)

while (nó != Nulo)
G
cout << node->informações << " ";
nó = nó-> folOwnODODE;

Chamando as funções na função Main ()

Escrevemos a função principal () para que possamos começar a escrever o código do driver do programa no corpo da função principal (). Primeiro, o ponteiro "head_val" é inicializado para nulo do tipo "nó". Em seguida, chamamos as funções de inserção que criamos globalmente e definimos cada função de inserção e passamos o valor nele. Para exibir a lista vinculada na janela do console do usuário, chamamos uma função Display () definida pelo usuário (). Ligue para o Sort () para que possamos organizar os dados na lista vinculada. Para excluir o nó da lista vinculada, chamamos a função delete_node () e passamos os elementos de dados que queremos excluir. Se queremos encontrar algum elemento do nó, chamamos a função de pesquisa () e passamos o elemento.

int main ()

Nó da estrutura* head_val = null;
Beg_insert (& head_val, 34);
Beg_insert (& head_val, 10);
end_insert (& head_val, 48);
mid_insert (Head_val-> Follownode, 72);
cout << "*---Implementation of Linked List in C++---*" << endl;
cout << "\nThe Input Linked list is: ";
display (head_val);
classificar (& head_val);
cout << "\n\nAfter Sorting the Input List: ";
display (head_val);
cout << "\nAfter deleting an element: ";
delete_node (& head_val, 48);
display (head_val);
Beg_insert (& head_val, 63);
Beg_insert (& head_val, 84);
end_insert (& head_val, 11);
mid_insert (head_val-> follownode, 100);
cout << "\n\nThe Updated Linked list is: ";
display (head_val);
classificar (& head_val);
cout << "\nAfter Sorting the Input List: ";
display (head_val);
int find_data;
cout << "\n\nEnter the element which you want to find? ";
CIN >> find_data;
if (search (& head_val, find_data))

cout << "The element " << find_data << " is found… ";

outro

cout << "The element " << find_data << " is not found… ";

Mostrado abaixo está o resultado da linguagem de programação C ++ do cenário da compilação acima.

Conclusão

A lista vinculada na linguagem de programação C ++ e a distinção entre uma matriz e uma lista vinculada foram abordadas neste artigo. Conversamos sobre as várias operações da lista vinculada. Primeiro, construímos um cenário de lista vinculada, depois construímos cada operação na ilustração com uma descrição abrangente de cada linha de código C ++.