技術標籤：java

雙向連結串列

雙向連結串列練習
頭插法
尾插法
列印連結串列
查詢連結串列中是否含有某值
刪除值為key的第一個節點
刪除值為key的所有節點
清空連結串列

/**
 * Crtated with IntelliJ IDEA.
 * Destcription:
 * User: hp
 * Date: 2021-01-07
 * Time: 19:46
 */
public class DoublieLinkedList {
    public static void main(String[] args) {
        DoublieLinkedList1 l1 = new DoublieLinkedList1();
        l1.addFirst(10);
        l1.addFirst(9);
        l1.addFirst(9);
        l1.addFirst(8);
        l1.addFirst(7);
        l1.addFirst(7);
        l1.addFirst(7);
        l1.addLast(99);
        l1.addLast(99);
        l1.addLast(99);
        l1.addLast(99);
        System.out.println(l1.size());
        l1.display();
        //l1.addIndex(4,100);
        //l1.remove(99);
        l1.removeAllKey(9);
        l1.display();
        System.out.println(l1.contains(111));
        l1.clear();
        l1.display();
    }

}

//節點類
class ListNode {
    private int val;
    private ListNode next;

    public int getVal() {

        return val;
    }

    public void setVal(int val) {

        this.val = val;
    }

    public void setNext(ListNode next) {

        this.next = next;
    }

    public void setPrev(ListNode prev) {

        this.prev = prev;
    }

    public ListNode getNext() {

        return next;
    }

    public ListNode getPrev() {

        return prev;
    }

    private ListNode prev;

    //alt+insert   ->   Constructor
    public ListNode(int val) {

        this.val = val;
    }
}

class DoublieLinkedList1 {

    private ListNode head;//頭
    private ListNode last;//尾


    //頭插法
    public void addFirst(int data) {
        ListNode node = new ListNode(data);
        if (this.head == null) {
            head = node;
            last = node;
        } else {
            node.setNext(head);
            head.setPrev(node);
            head = node;
        }
    }

    //尾插法
    public void addLast(int data) {
        ListNode node = new ListNode(data);
        if (this.head == null) {
            head = node;
            last = node;
        } else {
            last.setNext(node);
            node.setPrev(last);
            last = node;
        }
    }

    //任意位置插入,第一個資料節點為0號下標
    public void addIndex(int index, int data) {
    //輸入位置是否合法
        if(index<0||index>size()){
            return;
        }
        //頭插
        if(index==0){
            addFirst(data);
            return;
        }
        //尾插
        if(index==size()){
            addLast(data);
            return;
        }
        //找要插入的位置
        ListNode cur=this.head;
        while(index!=0){
            index--;
            cur=cur.getNext();
        }
        //刪除
        ListNode node=new ListNode(data);
        node.setNext(cur);
        node.setPrev(cur.getPrev());
        cur.getPrev().setNext(node);
        cur.setPrev(node);
    }

    //查詢是否包含關鍵字key是否在單鏈表當中
    public boolean contains(int key) {
        if(this.head==null){
            return false;
        }
        ListNode cur=this.head;
        while(cur!=null){
            if(cur.getVal()==key){
                return true;
            }
            cur=cur.getNext();
        }
        return false;
    }



    //查詢關鍵字key節點，並返回該節點
    public ListNode containsKeyNode(int key) {
        if(this.head==null){
            return null;
        }
        ListNode cur=this.head;
        while(cur!=null){
            if(cur.getVal()==key){
                return cur;
            }
            cur=cur.getNext();
        }
        return null;
    }

    //刪除第一次出現關鍵字為key的節點
    public void remove(int key) {
        ListNode text=containsKeyNode(key);
        if(text==null){
            System.out.println("該節點不存在");
            return ;
        }
        //頭結點
        if(text==head){
            head=head.getNext();
            head.setPrev(null);
            return ;
            //尾結點
        }else if(text==last){
            last=last.getPrev();
            last.setNext(null);
            //其他節點
        }else {
            text.getPrev().setNext(text.getNext());
            text.getNext().setPrev(text.getPrev());
        }
    }

    //刪除所有值為key的節點
    public void removeAllKey(int key) {
        ListNode text = containsKeyNode(key);
        if (text == null) {
            System.out.println("該節點不存在");
        }
        //迴圈遍歷連結串列
        while (text != null) {
        //該值為key時，即為要刪除的節點時
            if (text.getVal() == key) {
            //若刪除的為頭結點時
                if (text == head) {
                    head = head.getNext();
                    head.setPrev(null);
                    //刪除的為尾結點時
                } else if (text == last) {
                    last = last.getPrev();
                    last.setNext(null);
                    //刪除的為中間節點時
                } else {
                    text.getPrev().setNext(text.getNext());
                    text.getNext().setPrev(text.getPrev());
                }
            }
            
            text = text.getNext();
        }
    }




    //得到連結串列的長度
    public int size() {
        if(this.head==null){
            return -1;
        }
        ListNode cur=this.head;
        int count =0;
        while(cur!=null){
            count++;
            cur=cur.getNext();
        }
        return count;
    }


    //列印連結串列
    public void display() {
        if (head == null) {
            System.out.println("連結串列為空");
            return;
        }
        ListNode cur = head;
        while (cur != null) {
            System.out.print(cur.getVal() + " ");
            cur = cur.getNext();
        }
        System.out.println();
    }


//清空雙向連結串列
    public void clear() {
        ListNode cur=this.head;
        while(cur!=null){
            ListNode curNext=cur.getNext();
            cur.setPrev(null);
            cur.setNext(null);
            cur=curNext;
        }
       this.head=null;
        this.last=null;
    }
}