【数据结构】—— Java实现双向链表

一、链表的概念及结构

我们在单链表中，有了next指针。这就使得我们查找下一个结点的时间复杂度为O(1)。可是我们要查找的是上一个结点的话，那最坏的时间复杂度就是O(n)了，因为我们每次都要从头遍历查找。

为了克服单向性这一缺点，我们就提出了双向链表。双向链表（double linked list）是在单链表的每个结点中，在设置一个指向其前驱结点的指针域。 所以双向链表的结构都有两个指针域，一个指向直接后继，另一个指向直接前驱。

二、头指针与头结点的异同

• 头指针
  1.头指针是指链表指向第一个结点的指针，若链表有头节点，则是指向头节点的指针。
  2.头指针是具有标识作用，所以常用头指针冠以链表的命名
  3.无论链表是否为空，头指针均不为空。头指针是链表的必要元素
  若头指针为空，则链表不存在。

• 头结点
  1.头结点是为了操作的统一和方便而设立的，放在第一元素的结点之前，其数据域一般无意义（也可存放链表的长度）
  2.有了头结点，对在第一元素结点前插入结点和删除第一节点，其操作与其他结点的操作就统一了
  3.头节点不一定是链表的必须元素

三、代码实现

public class LinkedList {
    //一般脱离类无实际意义，所以定义为静态类
    static class Node {
        int val;
        Node prev;
        Node next;

        public Node(){
        }

        public Node (int val) {
            this.val = val;
        }
    }
    //定义头结点和尾结点
    Node head;
    Node last;

        //头插法
        public void addFirst(int val){
            Node node = new Node(val);
            if (head == null) {
                head = node;
                last = node;
                return ;
            }
            node.next = head;
            head.prev = node;
            head = node;
        }
        //尾插法
        public void addLast(int val){
            Node node = new Node(val);
            if (head == null) {
                head = node;
                last = node;
                return ;
            }
            last.next = node;
            node.prev = last;
            last = node;
        }
        //任意位置插入,第一个数据节点为0号下标
        public boolean addIndex(int index,int val){
            if (head == null) {
                return false;
            }
            //判断所给的索引合法性
            if (index < 0 || index > size()) {
                throw new RuntimeException("the index is not illegal!");
            }
            //第一个位置插入的时候，此时就是头插法
            if (index == 0) {
                addFirst(val);
                return true;
            }
            //最后一个位置插入则为尾插法
            if (index == size()) {
                addLast(val);
                return true;
            }
            //最后考虑中间位置的插入即可
            //1.定义临时头结点，先走到待插入位置的前一个位置
            Node temp = head;
            while (index > 1) {
                temp = temp.next;
                index--;
            }
            //2.对元素进行插入
            Node node = new Node(val);
            node.next = temp.next;
            node.prev = temp;
            temp.next.prev = node;
            temp.next = node;
            return true;
        }

        //查找是否包含关键字key是否在单链表当中
        public boolean contains(int key){
            if (head == null) {
                return false;
            }
            //只要在链表找到我们就返回false就行
            Node temp = head;
            while (temp != null) {
                if (temp.val == key) {
                    return true;
                }
                temp = temp.next;
            }
            return false;
        }

        //删除第一次出现关键字为key的节点
        public void remove(int key){
            if (head == null) {
                return ;
            }
            //只要存在我们才可以去删除
            if (!contains(key)) {
                throw new RuntimeException("the key is not exist !");
            }
            //如果是头节点的情况就直接删除
            if (head.val == key) {
                head  = head.next;
                head.prev = null;
                return ;
            }

            //1.找到第一次出现的关键字key的前一个位置
            Node temp = head;
            while (temp != null) {
                if (temp.val == key) {
                    temp.prev.next = temp.next;
                    temp.next.prev = temp.prev;
                    return;
                }
                temp = temp.next;
            }
        }

        //删除所有值为key的节点
        public void removeAllKey(int key){
            if (head == null) {
                return ;
            }
            while (contains(key)) {
                remove(key);
            }
        }

        //得到单链表的长度
        public int size(){
            if(head == null) {
                return 0;
            }
            Node temp = head;
            int size = 0;
            while (temp != null) {
                size++;
                temp = temp.next;
            }
            return size;
        }

        //遍历双向链表
        public void display(){
            if (head == null) {
                return ;
            }
            Node temp = head;
            while (temp != null) {
                System.out.print(temp.val + " ");
                temp = temp.next;
            }
        }

        //清空链表
        public void clear(){
            head = null;
            last = null;
        }
}