b'\n_START_ARTICLE_\nLista ligada\n_START_SECTION_\nExemplo em C\n_START_PARAGRAPH_\nExemplo de c\xc3\xb3digo feito em linguagem de programa\xc3\xa7\xc3\xa3o C:\n_START_SECTION_\nEstrutura\n_START_PARAGRAPH_\ntypedef struct No_st{_NEWLINE_    int numero;_NEWLINE_    struct No_st *prox;}No;_NEWLINE_O tipo de dados seria definido apenas pela chamada ao m\xc3\xa9todo struct, mas a inclus\xc3\xa3o do typedef simplifica a sua utiliza\xc3\xa7\xc3\xa3o._NEWLINE_A partir deste momento, a vari\xc3\xa1vel do tipo No est\xc3\xa1 dispon\xc3\xadvel, sendo o seu acesso feito como a uma qualquer estrutura de dados. _NEWLINE_Exemplo de inicializa\xc3\xa7\xc3\xa3o e preenchimento no main:_NEWLINE_int main(void){_NEWLINE_    No exemplo; /*A vari\xc3\xa1vel exemplo \xc3\xa9 do tipo no*/_NEWLINE_    No *pexemplo; /*A vari\xc3\xa1vel pexemplo do tipo apontador para no*/_NEWLINE__NEWLINE_   exemplo.numero = 1;_NEWLINE_   pexemplo = &exemplo;_NEWLINE_   _NEWLINE_   printf("%d\\n", exemplo.numero);_NEWLINE_   printf("%d\\n", pexemplo->numero);_NEWLINE__NEWLINE_   return (1);}_NEWLINE_Neste exemplo, ambas as chamadas \xc3\xa0 fun\xc3\xa7\xc3\xa3o printf() iriam imprimir o n\xc3\xbamero 1.\n_START_SECTION_\nCria Lista\n_START_PARAGRAPH_\nPara come\xc3\xa7ar uma lista n\xc3\xa3o basta come\xc3\xa7ar a inserir novas c\xc3\xa9lulas, \xc3\xa9 preciso uma base, ou raiz, que ser\xc3\xa1 sempre a mesma para uma lista. Esta raiz pode ser simplesmente um apontador para uma lista ou um apontador para uma primeira c\xc3\xa9lula vazia._NEWLINE_Normalmente, para listas, \xc3\xa9 usada a c\xc3\xa9lula vazia, j\xc3\xa1 para as pilhas e filas \xc3\xa9 usado o apontador para os respectivos._NEWLINE_A fun\xc3\xa7\xc3\xa3o seguinte \xc3\xa9 usada no main ap\xc3\xb3s ser declarada a vari\xc3\xa1vel raiz que ser\xc3\xa1 do tipo apontador para lista( que nestes exemplos tem o nome No).Esta cria uma c\xc3\xa9lula vazia e mete a raiz a apontar para esta:_NEWLINE_No * cria_lista(){     // Fun\xc3\xa7\xc3\xa3o do tipo apontador para lista, i.e., o tipo de fun\xc3\xa7\xc3\xa3o tem de ser igual ao tipo que retorna_NEWLINE_    No * novo,*aux;_NEWLINE__NEWLINE_    novo = (No *) malloc( sizeof( No ));   /*Aloca mem\xc3\xb3ria do tamanho de uma c\xc3\xa9lula*/_NEWLINE__NEWLINE_    if(novo == NULL) exit(0);    /* Se n\xc3\xa3o alocar mem\xc3\xb3ria significa que n\xc3\xa3o h\xc3\xa1 memoria dispon\xc3\xadvel, logo deve sair*/_NEWLINE_    _NEWLINE_    _NEWLINE_    novo->prox = NULL;         /*Como esta deve ser a primeira fun\xc3\xa7\xc3\xa3o a ser executada, esta c\xc3\xa9lula vazia aponta para NULL*/_NEWLINE_    _NEWLINE_    aux= novo; /*Para retornar o aux com o endere\xc3\xa7o da c\xc3\xa9lula vazia, deve ser corrigido o valor do mesmo*/_NEWLINE__NEWLINE__NEWLINE_    return (aux); /*Retorna o aux*/}_NEWLINE_Um exemplo da sua utiliza\xc3\xa7\xc3\xa3o no main seria: _NEWLINE_int main(void){_NEWLINE_    No * raiz;_NEWLINE__NEWLINE_    /*raiz = (No *) malloc( sizeof(No) ); */_NEWLINE_    raiz = cria_lista();_NEWLINE_    /* Depois come\xc3\xa7a o seu uso: Inser\xc3\xa7\xc3\xa3o, Remo\xc3\xa7\xc3\xa3o, etc...*/_NEWLINE_    return EXIT_SUCCESS;}_NEWLINE_Como raiz est\xc3\xa1 sendo passada como par\xc3\xa2metro na fun\xc3\xa7\xc3\xa3o cria_lista() e em outras fun\xc3\xa7\xc3\xb5es, \xc3\xa9 preciso alocar mem\xc3\xb3ria para raiz de modo que seja poss\xc3\xadvel realizar as opera\xc3\xa7\xc3\xb5es no ponteiro que interage com raiz dentro das fun\xc3\xa7\xc3\xb5es.\n_START_SECTION_\nNo in\xc3\xadcio\n_START_PARAGRAPH_\nNo * inserirNoInicio(No * raiz, int numero){_NEWLINE_    No * novo, *aux;_NEWLINE_    aux = raiz;_NEWLINE_    novo = (No *) malloc(sizeof(No));_NEWLINE_    if(novo == NULL) exit(0);     _NEWLINE_    novo->numero = numero;_NEWLINE_    novo->prox = aux->prox;_NEWLINE_    aux->prox = novo;_NEWLINE_    return(aux);}\n_START_SECTION_\nNo fim\n_START_PARAGRAPH_\nvoid inserirNoFim(No **raiz, int numero){_NEWLINE_    No *novo;_NEWLINE_    novo = (No *) malloc(sizeof(No));_NEWLINE_    if(novo == NULL) exit(0);_NEWLINE_    novo->numero = numero;_NEWLINE_    novo->prox = NULL;_NEWLINE_    _NEWLINE_    if(*raiz == NULL){_NEWLINE_        *raiz = novo;_NEWLINE_    }else{_NEWLINE_        No *aux;_NEWLINE_        aux = *raiz;_NEWLINE_        while(aux->prox != NULL){_NEWLINE_            aux = aux->prox;_NEWLINE_        }_NEWLINE_        aux->prox = novo;_NEWLINE_        *raiz = aux;_NEWLINE_    }}\n_START_SECTION_\nNo in\xc3\xadcio\n_START_PARAGRAPH_\nvoid removerNoInicio(No *raiz){_NEWLINE_    No *aux;_NEWLINE_    if(raiz == NULL)_NEWLINE_        printf("\\nA lista ja esta vazia");_NEWLINE_    else{_NEWLINE_        aux = raiz->prox;_NEWLINE_        raiz->prox = aux->prox;_NEWLINE_        free(aux);_NEWLINE_    }}\n_START_SECTION_\nNo fim\n_START_PARAGRAPH_\nvoid removerNoFim(struct No **raiz){_NEWLINE_    if(*raiz == NULL)_NEWLINE_        printf("\\nA lista ja esta vazia");_NEWLINE_    else{_NEWLINE_        struct No *auxFrente, *auxTras=NULL;_NEWLINE_        auxFrente = *raiz;_NEWLINE_        while(auxFrente->prox != NULL){_NEWLINE_            auxTras = auxFrente;_NEWLINE_            auxFrente = auxFrente->prox;_NEWLINE_        }_NEWLINE__NEWLINE_        if(auxTras != NULL)_NEWLINE_            auxTras->prox = NULL;_NEWLINE__NEWLINE_        free(auxFrente);_NEWLINE_    }}_NEWLINE_Exemplo de um C\xc3\xb3digo feito para um dicion\xc3\xa1rio de palavras em linguagem de programa\xc3\xa7\xc3\xa3o C:_NEWLINE_ struct dic{_NEWLINE_     char *original;_NEWLINE_     char *complementar;_NEWLINE_     struct dic *prox;_NEWLINE_ };_NEWLINE_ _NEWLINE_ struct dic* ini=NULL;_NEWLINE_ struct dic* last=NULL;\'\'_NEWLINE_ _NEWLINE_ //adicionar um novo dic \xc3\xa0 nossa lista_NEWLINE_ void dic_add(char *original, char *complementar){_NEWLINE_         _NEWLINE_     //se last \xc3\xa9 igual a Null quer dizer que a lista est\xc3\xa1 vazia_NEWLINE_     if (last == NULL){_NEWLINE_         // o elemento ser\xc3\xa1 o primeiro_NEWLINE_         last = (struct dic*)malloc(sizeof(struct dic));_NEWLINE_         (*last).original = original;_NEWLINE_         (*last).complementar = complementar;_NEWLINE_         // Defini\xc3\xa7\xc3\xa3o da cabe\xc3\xa7a da fila_NEWLINE_         ini = last;_NEWLINE_     } else {_NEWLINE_         // o elemento ser\xc3\xa1 o \xc3\xbaltimo_NEWLINE_         (*last).prox = (struct dic*)malloc(sizeof(struct dic));_NEWLINE_         last = (*last).prox;_NEWLINE_         (*last).original = original;_NEWLINE_         (*last).complementar = complementar;_NEWLINE_     }        _NEWLINE_ }_NEWLINE_ _NEWLINE_ //Percorrer e Imprimir a lista ligada_NEWLINE_ void dic_print(){_NEWLINE_     int sair = 0;_NEWLINE_     struct dic* act = ini;_NEWLINE_    _NEWLINE_     do {_NEWLINE_         if (act == last)_NEWLINE_             sair = 1;_NEWLINE_         printf("----------------------------------------------\\n");_NEWLINE_         printf("original: %s\\n",(*act).original);_NEWLINE_         printf("complementar: %s\\n",(*act).complementar);_NEWLINE_         printf("prox: %d\\n", (*act).prox);_NEWLINE_         act = (*act).prox;_NEWLINE_     } while(sair == 0);_NEWLINE_     printf("----------------------------------------------");_NEWLINE_ }\n_START_SECTION_\nExemplo em C++\n_START_PARAGRAPH_\nPode-se utilizar tamb\xc3\xa9m uma sintaxe de classe, atribuindo esses m\xc3\xa9todos, da linguagem de programa\xc3\xa7\xc3\xa3o C++. Aqui, foram criadas duas classes: Node (n\xc3\xb3) e List (lista). Os m\xc3\xa9todos criados foram os seguintes: adicionar, excluir, buscar e imprimir._NEWLINE_#include <iostream>using namespace std;class Node {_NEWLINE_    public:_NEWLINE_        int value; // Pode ser implementado qualquer tipo de dados aqui._NEWLINE_        Node *next;_NEWLINE_        Node () {_NEWLINE_            next = NULL; // Construtor padr\xc3\xa3o_NEWLINE_        }_NEWLINE_        Node (int _value) { // Construtor para o caso de haver j\xc3\xa1 um valor a ser atribu\xc3\xaddo_NEWLINE_            value = _value;_NEWLINE_            next = NULL;_NEWLINE_        }};class List {_NEWLINE_    public:_NEWLINE_        Node *head; // A "cabe\xc3\xa7a" \xc3\xa9 um ponteiro para o primeiro elemento da lista._NEWLINE_        List () { // Construtor padr\xc3\xa3o; \xc3\xbanico_NEWLINE_            head = NULL;_NEWLINE_        }_NEWLINE__NEWLINE_        void push_back (int x) { // M\xc3\xa9todo para adicionar um elemento novo ao final da lista._NEWLINE_            Node *novo = new Node;_NEWLINE_            novo->value = x;_NEWLINE_            if (head == NULL)_NEWLINE_                head = novo;_NEWLINE_            else {_NEWLINE_                Node *onde = head;_NEWLINE_                while (onde->next)_NEWLINE_                    onde = onde->next;_NEWLINE_                onde->next = novo;_NEWLINE_            }_NEWLINE_        }_NEWLINE__NEWLINE_        void imprime(){ // M\xc3\xa9todo para imprimir, na sa\xc3\xadda padr\xc3\xa3o, todos os elementos na tela;_NEWLINE_            Node* temp = head;_NEWLINE_            while (temp) {_NEWLINE_                cout << temp->value << endl;_NEWLINE_                temp = temp->next;_NEWLINE_            }_NEWLINE_            return;_NEWLINE_        }_NEWLINE__NEWLINE_        bool find (int x) { // M\xc3\xa9todo de busca de um elemento na lista_NEWLINE_            Node *pointer = new Node;_NEWLINE_            if (!head)_NEWLINE_                return false;_NEWLINE_            pointer = head;_NEWLINE_            for (; pointer; pointer = pointer->next)_NEWLINE_                if (pointer->value == x)_NEWLINE_                    return true;_NEWLINE_            return false;_NEWLINE_        }_NEWLINE__NEWLINE_        bool deletar (int x) { // M\xc3\xa9todo de exclus\xc3\xa3o de um elemento da lista, nesse caso, eliminando todos os elementos equivalentes a "x"_NEWLINE_            Node *pointer = new Node;_NEWLINE_            if (!find(x))_NEWLINE_                return false;_NEWLINE_            while (head->value == x)_NEWLINE_                head = head->next;_NEWLINE_            if (!head)_NEWLINE_                return false;_NEWLINE_            pointer = head;_NEWLINE_            while (pointer) {_NEWLINE_                if (pointer->next)_NEWLINE_                    if (pointer->next->value == x)_NEWLINE_                        pointer->next = pointer->next->next;_NEWLINE_                pointer = pointer->next;_NEWLINE_            }_NEWLINE_            return true;_NEWLINE_        }};\n_START_SECTION_\nExemplo em Java\n_START_PARAGRAPH_\nExemplo de um C\xc3\xb3digo feito para um dicion\xc3\xa1rio de palavras em linguagem de programa\xc3\xa7\xc3\xa3o Java:_NEWLINE_class No{_NEWLINE_Object elemento;_NEWLINE_No prox;_NEWLINE__NEWLINE_No (Object elem){_NEWLINE_elemento = elem;_NEWLINE_prox = null;_NEWLINE_}}public class ListaLigada{_NEWLINE_private No primeiro, ultimo;_NEWLINE_private int nroNos;_NEWLINE__NEWLINE_ListaLigada ()_NEWLINE_{_NEWLINE_primeiro = null;_NEWLINE_ultimo = null;_NEWLINE_nroNos = 0;_NEWLINE_}_NEWLINE__NEWLINE_public boolean isVazia() {_NEWLINE_return (primeiro == null && ultimo == null);_NEWLINE_}_NEWLINE__NEWLINE_public void addInicio(Object o) {_NEWLINE_nroNos++;_NEWLINE_No novoNo = new No(o);_NEWLINE_if (isVazia())_NEWLINE_ultimo = novoNo;_NEWLINE_else_NEWLINE_novoNo.prox = primeiro;_NEWLINE_primeiro = novoNo;_NEWLINE_}_NEWLINE__NEWLINE_public void addFinal(Object o){_NEWLINE_nroNos++;_NEWLINE_No novoNo = new No(o);_NEWLINE_if (isVazia())_NEWLINE_primeiro = novoNo;_NEWLINE_else_NEWLINE_ultimo.prox = novoNo;_NEWLINE_ultimo = novoNo;_NEWLINE_}_NEWLINE__NEWLINE_public int getNroNos() {_NEWLINE_return nroNos;_NEWLINE_}_NEWLINE__NEWLINE_/* * @param posicao * posi\xc3\xa7\xc3\xa3o contada a partir do zero como primeiro elemento */_NEWLINE_public void addMeio(Object o, int posicao){_NEWLINE_nroNos++;_NEWLINE_No novoNo = new No(o);_NEWLINE_if(posicao <= 1) {_NEWLINE_addInicio(novoNo);_NEWLINE_return;_NEWLINE_}_NEWLINE_if (posicao > nroNos) { //Outra abordagem seria lan\xc3\xa7ar exce\xc3\xa7\xc3\xa3o para posi\xc3\xa7\xc3\xa3o inv\xc3\xa1lida (>nroNos+1)_NEWLINE_addFinal(novoNo);_NEWLINE_return;_NEWLINE_}_NEWLINE_No noTemp = primeiro.prox;_NEWLINE_for(int posAux=1;posAux<posicao;posAux++)_NEWLINE_noTemp = noTemp.prox;_NEWLINE_novoNo.prox = (noTemp.prox).prox;_NEWLINE_noTemp.prox = novoNo;_NEWLINE_}_NEWLINE__NEWLINE_public void Remover(Object elemento)_NEWLINE_{_NEWLINE_No noTemp = primeiro;_NEWLINE_No noAnt = null;_NEWLINE__NEWLINE_if (primeiro.elemento.equals(elemento)){_NEWLINE_primeiro = primeiro.prox;_NEWLINE_nroNos--;_NEWLINE_}_NEWLINE_else {_NEWLINE_while (noTemp !=null && !noTemp.elemento.equals(elemento)) {_NEWLINE_noAnt = noTemp;_NEWLINE_noTemp = noTemp.prox;_NEWLINE_}_NEWLINE_if(noTemp != null) {_NEWLINE_noAnt.prox = noTemp.prox;_NEWLINE_nroNos--;_NEWLINE_}_NEWLINE_if(noTemp == ultimo) {_NEWLINE_ultimo = noAnt;_NEWLINE_}_NEWLINE_}_NEWLINE_}_NEWLINE__NEWLINE_public Object BuscarElemento (Object elemento)_NEWLINE_{_NEWLINE_int i = 1;_NEWLINE_No noTemp = primeiro;_NEWLINE__NEWLINE_while (noTemp !=null) {_NEWLINE_if(noTemp.elemento.equals(elemento)) {_NEWLINE_return noTemp;_NEWLINE_}_NEWLINE_i = i +1;_NEWLINE_noTemp = noTemp.prox;_NEWLINE_}_NEWLINE_return null;_NEWLINE_}}\n_START_SECTION_\nExemplo em Pascal\n_START_PARAGRAPH_\nExemplo de um C\xc3\xb3digo feito para um dicion\xc3\xa1rio de palavras em linguagem de programa\xc3\xa7\xc3\xa3o Pascal:_NEWLINE_program Lista_ligada;uses crt;type_NEWLINE_  Tdado = char;_NEWLINE_  Tptr = ^Tnode;_NEWLINE_  Tnode = record_NEWLINE_            prox: Tptr;_NEWLINE_            info: Tdado;_NEWLINE_          end;procedure exibe(ptr:Tptr);var_NEWLINE_  aux:Tptr;begin_NEWLINE_  aux := ptr;_NEWLINE_  if (aux = NIL) then_NEWLINE_    writeln(\'A lista est\xc3\xa1 vazia.\') else_NEWLINE_  begin_NEWLINE_    while (aux^.prox <> NIL) do_NEWLINE_    begin_NEWLINE_      writeln(aux^.info);_NEWLINE_      aux := aux^.prox;_NEWLINE_    end;_NEWLINE_    writeln(aux^.info);_NEWLINE_  end;_NEWLINE_  readkey;end;procedure insereInicio(var ptr:Tptr; v:char);var_NEWLINE_  aux:Tptr;begin_NEWLINE_  if (ptr <> NIL) then_NEWLINE_  begin_NEWLINE_    new(aux);_NEWLINE_    aux^.info := v;_NEWLINE_    aux^.prox := ptr;_NEWLINE_    ptr := aux;_NEWLINE_  end else_NEWLINE_  begin_NEWLINE_    new(ptr);_NEWLINE_    ptr^.info := v;_NEWLINE_    ptr^.prox := NIL;_NEWLINE_  end;end;procedure insereFinal(var ptr:Tptr; v:char);var_NEWLINE_  aux: Tptr;_NEWLINE_  nova: Tptr;begin_NEWLINE_  aux := ptr;_NEWLINE_  if (aux = NIL) then_NEWLINE_    writeln(\'Lista est\xc3\xa1 vazia.\') else_NEWLINE_  begin_NEWLINE_    while (aux^.prox <> NIL) do_NEWLINE_      aux := aux^.prox;_NEWLINE_    new(nova);_NEWLINE_    nova^.info := v;_NEWLINE_    nova^.prox := NIL;_NEWLINE_    aux^.prox := nova;_NEWLINE_  end;end;procedure remove(var ptr:Tptr; v:char);var_NEWLINE_  aux:Tptr;_NEWLINE_  aux2:Tptr;begin_NEWLINE_  if (ptr = NIL) then_NEWLINE_    writeln(\'A lista est\xc3\xa1 vazia.\') else_NEWLINE_  begin_NEWLINE_    aux := ptr;_NEWLINE_    if (aux^.info = v) then_NEWLINE_    begin_NEWLINE_      ptr := ptr^.prox;_NEWLINE_      dispose(aux);_NEWLINE_    end;_NEWLINE_    while (aux^.prox <> NIL) do_NEWLINE_    begin_NEWLINE_      if (aux^.prox^.info = v) then_NEWLINE_      begin_NEWLINE_        aux2 := aux^.prox;_NEWLINE_        aux^.prox := aux2^.prox;_NEWLINE_        dispose(aux2);_NEWLINE_      end;_NEWLINE_      aux := aux^.prox;_NEWLINE_    end;_NEWLINE_  end;end;'