Java construit une liste doublement liée (ajouter, supprimer, vérifier et modifier)

Une liste doublement liée, également appelée liste doublement liée, est un type de liste liée. Chacun de ses nœuds de données possède deux pointeurs , qui pointent respectivement vers le successeur direct et le prédécesseur direct. Par conséquent, à partir de n'importe quel nœud de la liste doublement liée, il est facile d'accéder à ses nœuds prédécesseurs et à ses nœuds successeurs. Généralement, on construit une liste chaînée doublement circulaire .

code afficher comme ci-dessous:

package seqlist.doublelinked;

public class DoubleLinkedList {
    private int size;
    private Node head;
    private Node tail;

    //增
    public void addFirst(int val){
        Node node=new Node(null,val,head);
        if(head==null){
            tail=node;
        }else {
            head.prev=node;
        }
        head=node;
        size++;
    }
    public void addLast(int val){
        Node node=new Node(tail,val,null);
        if(tail==null){
            head=node;
        }else {
            tail.next=node;
        }
        tail=node;
        size++;
    }
    public void addIndex(int index,int val){
        if(index<0||index>size){
            System.out.println("add index illegal!");
        }else if(index==0){
            addFirst(val);
        }else if(index==size){
            addLast(val);
        }else {
            Node prev=node(index-1);
            Node node=new Node(prev,val,prev.next);
            prev.next.prev=node;
            prev.next=node;
            size++;
        }
    }

    //查
    public int get(int index){
        if(rangeIndex(index)){
            return node(index).val;
        }else {
            System.out.println("get index illegal!");
            return -1;
        }
    }

    //判断是否存在
    public boolean isExist(int val){
        for (Node x=head;x!=null;x=x.next) {
            if(x.val==val){
                return true;
            }
        }
        return false;
    }

    //改
    public void change(int index,int val){
        if(rangeIndex(index)){
            Node oldNode=node(index);
            oldNode.val=val;
        }else {
            System.out.println("get index illegal!");
        }
    }

    //删
    public void removeIndex(int index){
        if (rangeIndex(index)){
            Node node=node(index);
            unLink(node);
        }else {
            System.out.println("remove index illegal!");
        }
    }
    public void removeFirst(){
        removeIndex(0);
    }
    public void removeLast(){
        removeIndex(size-1);
    }
    public void removeValOnce(int val){
        for(Node x=head;x!=null;x=x.next){
            if(x.val==val){
                unLink(x);
            }
        }
    }
    public void removeValeAll(int val){
        for (Node x=head;x!=null;){
            if(x.val==val){
                Node node=x.next;
                unLink(x);
                x=node;
            }else {
                x=x.next;
            }
        }
    }

    //删除指定节点
    public void unLink(Node node){
        //分治思想
        Node prev= node.prev;
        Node next= node.next;
        if(prev==null){
            head=next;
        }else {
            prev.next=next;
            node.prev=null;
        }
        if(next==null){
            tail=prev;
        }else {
            next.prev=prev;
            node.next=null;
        }
        size--;
    }

    //判断合法性
    public boolean rangeIndex(int index){
        if(index<0||index>=size){
            return false;
        }else {
            return true;
        }
    }

    //得到索引节点
    public Node node(int index){
        Node ret=null;
        if(index<(size>>1)){
            ret=head;
            for (int i = 0; i < index; i++) {
                ret=ret.next;
            }
        }else {
            ret=tail;
            for (int i = size-1; i > index; i++) {
                ret=ret.prev;
            }
        }
        return ret;
}

    //输出
    public String toString(){
        String ret="";
        Node node=head;
        while (node!=null){
            ret+=node.val;
            ret+="->";
            node=node.next;
        }
        ret+="null";
        return ret;
    }
}

class Node{
    Node prev;
    int val;
    Node next;

    public Node(int val){
        this.val=val;
    }
    public Node(Node prev,int val,Node next){
        this.prev=prev;
        this.val=val;
        this.next=next;
    }
}

La méthode de référence est la suivante :

package seqlist;

import seqlist.doublelinked.DoubleLinkedList;

public class Test {
    public static void main(String[] args) {
        DoubleLinkedList doubleLinkedList=new DoubleLinkedList();
        doubleLinkedList.addFirst(1);
        doubleLinkedList.addLast(3);
        doubleLinkedList.addLast(4);
        doubleLinkedList.addIndex(1,2);
        //增 1->2->3->4->null
        System.out.println(doubleLinkedList);
        //查 2
        System.out.println(doubleLinkedList.get(1));
        //是否存在 true
        System.out.println(doubleLinkedList.isExist(1));

        //改 10->2->3->4->null
        doubleLinkedList.change(0,10);
        System.out.println(doubleLinkedList);

        //删 3->null
        doubleLinkedList.removeFirst();
        doubleLinkedList.removeLast();
        doubleLinkedList.removeIndex(0);
        System.out.println(doubleLinkedList);

        //增 1->2->3->4->5->5->null
        doubleLinkedList.addFirst(2);
        doubleLinkedList.addFirst(1);
        doubleLinkedList.addLast(4);
        doubleLinkedList.addIndex(4,5);
        doubleLinkedList.addLast(5);
        System.out.println(doubleLinkedList);
        //删 3->null
        doubleLinkedList.removeFirst();
        doubleLinkedList.removeValOnce(2);
        doubleLinkedList.removeValeAll(5);
        doubleLinkedList.removeLast();
        System.out.println(doubleLinkedList);

    }
}

Sur la base des entrées ci-dessus, les résultats sont les suivants :