Conteúdo principal:
Basta enviar o código, é tão irrestrito ~~~
pacote pers.ty. $ 1101datastructure; importar java.util.hashtable;/*** @Author Administrator* Implemente as operações básicas de listas vinculadas únicas, adicionando nós de exclusão, classificação, impressão e link de links*/links links e links shelts/links* the links links/the link links/the link links/the links* the links shets/the links* the links* the links/the links shets/node Dados de inserção*/ public void addNode (int d) {node newNode = new Node (d); if (head == null) {head = newNode; retornar; } Nó tmp = head; while (tmp.next! = null) {tmp = tmp.next; } // Adicione o nó ao fim tmp.Next = newNode; }/*** @param Índice: Excluir Índice Nó* @return retorna true com sucesso e retorna false se falhado*/public boolean deletenode (int index) {if (index <1 || index> length ()) {return false; // excluir a posição elemento irracional} // // sheft o primeiro elemento na lista de links se (index; retornar true; } int i = 1; Nó prenode = head; Nó Curnode = prenode.next; while (Curnode! = null) {if (i == index) {prenode.Next = Curnode.Next; retornar true; } prenode = curnode; Curnode = Curnode.Next; i ++; } retornar true; } / ** * @return retorna o comprimento do comprimento da lista vinculado * / public int comprimento () {int length = 0; Nó tmp = cabeça; while (tmp! = null) {length ++; tmp = tmp.next; } comprimento de retorno; } / *** Classifique a lista vinculada* @return retorna o nó de cabeçalho classificado* / public node orderlist () {node nextNode = null; int temp = 0; Nó Curnode = Head; while (Curnode.Next! = null) {nextNode = Curnode.Next; while (nextNode! = null) {if (curnode.data> nextnode.data) {temp = Curnode.data; Curnode.data = nextNode.data; nextNode.data = temp; } nextNode = nextNode.Next; } Curnode = Curnode.Next; } retornar a cabeça; } / *** Imprima todos os dados na lista vinculada* / public void printList () {node tmp = head; while (tmp! = null) {System.out.print (tmp.data+""); tmp = tmp.next; } System.out.println (); } /*** A primeira maneira de excluir dados da lista vinculada* atravessar a lista vinculada e armazenar os dados percorridos em uma hashtable. Durante o processo de travessia, se existir o valor atualmente acessado no hashtable*, você poderá excluí -lo*vantagens: complexidade de baixa tempo: é necessário espaço de armazenamento adicional para salvar os dados acessados*/ public void DeLeTedUplecate1 () {Hashtable <Teger, tabela Integer> = novo hashtable <Teveger, inteiro, (Integerger, tabela) = novo Hashtable <Teveger> (Integer>; Nó tmp = cabeça; Nó pre = null; while (tmp! = null) {if (table.containsKey (tmp.data)) pre.next = tmp.next; else {table.put (tmp.data, 1); pre = tmp; } tmp = tmp.next; }} / *** A segunda maneira de excluir dados duplicados da lista vinculada* Travessal de loop duplo* As vantagens e desvantagens são óbvias* / public void DeLetEdUplecate2 () {Node p = Head; while (p! = null) {nó q = p; while (q.next! = null) {if (p.data == q.next.data) {q.next = q.next.next; } else {q = q.next; }} p = p.next; }} /*** @param k: encontre o k-és até o último nó na lista vinculada* @return este nó* Defina dois ponteiros P1 e P2 para tornar P2 K mais rápido que P1 e atravessar para trás ao mesmo tempo. Quando P2 está vazio, P1 é o K-és até o último nó*/ Public Node FindElem (cabeça do nó, int k) {if (k <1 || k> this.length ()) retornar nulo; Nó p1 = cabeça; Nó p2 = cabeça; for (int i = 0; i <k-1; i ++) p2 = p2.next; while (p2.next! = null) {p2 = p2.next; p1 = p1.next; } retornar P1; } / *** Implemente a reversão da lista vinculada* @param Head o nó da cabeça da lista vinculada* / public void reverseeritativamente (cabeça do nó) {node preversedhead = head; Nó pnode = head; Nó pPrev = null; while (pnode! = null) {node pnext = pnode.next; if (pnext == null) preversedhead = pnode; pnode.Next = pPrev; pPrev = pnode; pnode = pnext; } this.head = preverredhead; } / *** Saia uma única lista vinculada da cauda para a cabeça por recursivamente* @param head* / public void printListerSely (cabeça do nó) {if (head! = Null) {printListerSely (head.next); System.out.print (head.data+""); }} / *** Consulte o nó intermediário de uma única lista vinculada* Defina dois ponteiros, uma etapa de cada vez e as outras duas etapas de cada vez ...* @param head* @return q é o nó intermediário* / public node SearchMid (nó head) {node q = Head; Nó p = cabeça; while (p! = null && p.next! = null && p.next.Next! = null) {q = q.next; p = p.next.next; } retornar Q; } / *** Exclua o nó especificado sem conhecer o ponteiro da cabeça* O nó da cauda da lista vinculado não pode ser excluído porque o próximo ponteiro de seu nó antecessor não pode ser definido para ser esvaziado após a exclusão* outros nós podem trocar os valores desse nó e seu nó sucessor e, em seguida, excluir o sucessor nó* @param n* @ -Return* if (n == null || n.next == null) retorna false; int tmp = n.data; n.data = n.next.data; n.next.data = tmp; n.next = n.next.next; retornar true; } / *** Determine se duas listas vinculadas se cruzam* Se duas listas vinculadas se cruzam, deve haver o mesmo nó da cauda, atravessar as duas listas vinculadas, gravar os nós da cauda e ver se eles são o mesmo nó* @param H1, se eles interset* @param h2 node da lista de links 2* return, se h2) {if (h1 == null || h2 == null) return false; Node Tail1 = H1; while (cauda1.next! = null) {cauda1 = cauda1.next; } Nó cauda2 = h2; while (tail2.next! = null) {cauda2 = tail2.next; } retornar cauda1 == cauda2; } / ** * Encontre o primeiro nó que cruza * @param h1 * @param h2 * @return * / public node getfirstmeetnode (nó h1, nó h2) {if (h1 == null || h2 == null) return null; Node Tail1 = H1; int len1 = 1; while (cauda1.next! = null) {cauda1 = cauda1.next; Len1 ++; } Nó cauda2 = h2; int len2 = 1; while (tail2.next! = null) {cauda2 = tail2.next; Len2 ++; } if (cauda1! = cauda2) {return null; } Nó t1 = h1; Nó t2 = h2; // Descubra a lista mais longa e vá até if (len1> len2) {int d = len1-len2; while (d! = 0) {t1 = t1.next; D--; }} if (len1 <len2) {int d = len2-len1; while (d! = 0) {t2 = t2.next; D--; }} while (t1! = t2) {t1 = t1.next; T2 = T2.Next; } retornar t1; } public static void main (string [] args) {myLinkedList List = new MyLinkedList (); }}O exposto acima é todo o conteúdo deste artigo. Espero que o conteúdo deste artigo seja de ajuda para estudar ou trabalhar de todos. Eu também espero apoiar mais wulin.com!