Contenu principal:
Téléchargez juste le code, c'est tellement sans retenue ~~~
Package pers.ty. 1101 $DATASTRUCTURE; IMPORT Java.util.hashTable; / ** * @Author Administrator * Implémentez les opérations de base des listes liées uniques, en ajoutant des nœuds de suppression, du tri, de l'impression et du calcul de la longueur liée * / des Headers MyLinkedList {Node Head = Null; des données d'insertion * / public void addNode (int d) {node newNode = new nœud (d); if (head == null) {head = newNode; retour; } Nœud tmp = tête; while (tmp.next! = null) {tmp = tmp.next; } // Ajouter un nœud pour terminer tmp.next = newNode; } / ** * @param index: supprimer le nœud d'index * @return renvoie True avec succès, et renvoie false si l'échec * / public boolean Deletenode (int index) {if (index <1 || index> length ()) {return false; // supprimer la position de l'élément déraisonnable} // deletet; Retour Vrai; } int i = 1; Node Prenode = tête; Node CurNode = Prenode.Next; while (curnode! = null) {if (i == index) {prenode.next = curnode.next; Retour Vrai; } prenode = curnode; curnode = curnode.next; i ++; } return true; } / ** * @return Renvoie la longueur de la longueur liée à la liste * / public int length () {int length = 0; Nœud tmp = tête; while (tmp! = null) {longueur ++; tmp = tmp.next; } la longueur de retour; } / ** * Triez la liste liée * @return Renvoie le nœud d'en-tête trié * / Node public OrderList () {NODE NEXTNODE = NULL; int temp = 0; Node CurNode = tête; 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; } la tête de retour; } / ** * Imprimez toutes les données dans la liste liée * / public void printlist () {node tmp = head; while (tmp! = null) {System.out.print (tmp.data + ""); tmp = tmp.next; } System.out.println (); } / ** * La première façon de supprimer les données de la liste liée * Traversez la liste liée et stockez les données traversées dans un hashtable. Pendant le processus de traversée, si la valeur actuellement accessible existe dans le hashtable *, vous pouvez le supprimer * Avantages: Low Time Complexity: un espace de stockage supplémentaire est nécessaire pour enregistrer les données accessibles * / public Void DeleTuduplecate1 () {HashTable <Integer, Integer> Tableau = new HashTable <Integer, Integer> (); Nœud tmp = tête; Nœud 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; }} / ** * La deuxième façon de supprimer les données en double de la liste liée * Traversage à double boucle * Les avantages et les inconvénients sont évidents * / public void DeleteDupleCate2 () {Node p = tête; while (p! = null) {nœud 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: Trouvez le K -th jusqu'au dernier nœud de la liste liée * @return ce nœud * définissez deux pointeurs P1 et P2 pour rendre P2 K plus rapidement que P1 et traverser à l'arrière en même temps. Lorsque P2 est vide, P1 est le K-Th jusqu'au dernier nœud * / nœud public finselem (tête de nœud, int k) {if (k <1 || k> this.length ()) renvoie null; Node P1 = tête; Nœud p2 = tête; pour (int i = 0; i <k-1; i ++) p2 = p2.Next; while (p2.Next! = null) {p2 = p2.Next; p1 = p1.next; } retour p1; } / ** * Implémentez l'inversion de la liste liée * @param tête le nœud de tête de la liste liée * / public void inverseiterativement (nœud head) {node preversedhead = head; Nœud pnode = tête; Nœud pprev = null; while (pnode! = null) {node pnext = pnode.next; if (pnext == null) préversé = pnode; pnode.next = pprev; pprev = pnode; pnode = pNext; } this.head = préversé; } / ** * Sortie une seule liste liée de la queue à la tête par récursive * @param tête * / public void printListRevervely (nœud head) {if (head! = Null) {printListRevervely (head.next); System.out.print (head.data + ""); }} / ** * Requête le nœud intermédiaire d'une seule liste liée * définir deux pointeurs, une étape à la fois et les deux autres étapes à la fois ... * @param head * @return q est le nœud intermédiaire * / noeud public SearchMid (nœud head) {nœud q = tête; Nœud p = tête; while (p! = null && p.next! = null && p.next.next! = null) {q = q.next; p = p.next.next; } return q; } / ** * Supprimer le nœud spécifié sans connaître le pointeur de tête * Le nœud de queue de la liste liée ne peut pas être supprimé car le prochain pointeur de son nœud de prédécesseur ne peut pas être défini sur vide après la suppression * Les autres nœuds peuvent échanger les valeurs de ce nœud et de son nœud successeur, puis de supprimer le nœud du successeur * @param n * @return * / public boolean deletenode (nœud n) {nœud) if (n == null || n.next == null) return false; int tmp = n.data; n.data = n.next.data; n.next.data = tmp; n.next = n.next.next; Retour Vrai; } / ** * Déterminez si deux listes liées se croisent * Si deux listes liées se croisent, il doit y avoir le même nœud de queue, traverser les deux listes liées, enregistrer les nœuds de queue et voir s'ils sont les mêmes nœuds de tête * @param h1 de la liste liée 1 * @param h2 nœud de tête de la liste liée 2 * @return si ils se croisent *. if (h1 == null || h2 == null) return false; Nœud tail1 = h1; while (tail1.next! = null) {tail1 = tail1.next; } Nœud tail2 = h2; while (tail2.next! = null) {Tail2 = Tail2.Next; } return tail1 == Tail2; } / ** * Trouvez le premier nœud qui coupe * @param h1 * @param h2 * @return * / noeud public getFirstmeetNode (nœud h1, nœud h2) {if (h1 == null || h2 == null) return null; Nœud tail1 = h1; int len1 = 1; while (tail1.next! = null) {tail1 = tail1.next; Len1 ++; } Nœud tail2 = h2; int len2 = 1; while (tail2.next! = null) {Tail2 = Tail2.Next; Len2 ++; } if (tail1! = Tail2) {return null; } Nœud t1 = h1; Nœud t2 = h2; // Découvrez la liste plus longue et passez par 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; } return t1; } public static void main (string [] args) {myLinkedList list = new myLinkedList (); }}Ce qui précède est tout le contenu de cet article. J'espère que le contenu de cet article sera d'une aide à l'étude ou au travail de chacun. J'espère également soutenir plus Wulin.com!