链表拓展之双向链表

前言

在前面已经总结了单链表，有了单链表的基础会很好理解双链表的实现，忘记了可以跳转——>http://t.csdnimg.cn/GFPk9

接下来就由我带着各位看官来认识今天的主角吧~

什么是双向链表 

在单链表的基础上，它有两个方向的链接，一个链接指向前一个节点，另一个链接指向下一个节点。每个节点通常包含两个部分：数据(val)部分和两个指针部分，即前向指针(prev)和后向指针(next)。这使得在双向链表中，可以双向遍历数据,搭配下面图片更好理解~

因为是双向链表，为了分清头尾，定义头结点head和尾结点last，同时别忘在各自的末尾置null~这样一个完整的双向链表就表示出来了。 

双向链表的基本方法

这里就用图来表示

boolean add(E e)	尾插 e
void add(int index, E element)	将 e 插入到 index 位置
boolean contains(Object o)	判断元素o是否在表中
E remove(int index)	删除 index 位置元素
boolean remove(Object o)	删除遇到的第一个 o
E get(int index)	获取下标 index 位置元素
E set(int index, E element)	将下标 index 位置元素设置为 element
void clear()	清空

这里就引用了LinkedList类，观察代码演示就能理解这些方法的使用。

import java.util.LinkedList;

public class Test3 {
    public static void main(String[] args) {
        LinkedList<Integer> list=new LinkedList<>();
        list.add(1);//尾插法
        list.add(2);
        list.add(3);
        list.add(4);
        System.out.println(list.size());//获取链表长度
        System.out.println(list);//打印链表

        System.out.println("插入");
        list.add(0,5);//指定位置插入
        System.out.println(list);

        boolean a= list.contains(4);//判断指定元素是否在list当中
        System.out.println(a);

        list.set(0,6);//替换指定位置的元素
        System.out.println(list);

        System.out.println("移除");
        list.remove(0);//移除指定位置
        list.removeFirst();//头删
        list.removeLast();//尾删
        System.out.println(list);

        list.clear();
        System.out.println(list);//清空链表
}
}

运行结果如图（搭配代码就能理解通透了）：

双向链表的模拟实现

首先初始化一个双向链表，对于一个单节点，存储的val值，前驱和后继，然后定义头尾节点表示顺序。对比这张图，便好理解了~

1.添加元素 

public class MyLinkedList {
    static class ListNode {
        public int val;
        public ListNode prev;//前驱
        public ListNode next;//后继

        public ListNode(int val) {
            this.val = val;
        }
    }

    public ListNode head;// 头结点
    public ListNode last;// 尾节点

头插法：原理其实和单向链表的头插原理是类似的，不过就是要多考虑一个方向 

头插法 

        //头插法
       public void addFirst(int data) {
           LinkedList node= new LinkedList(data);
           if(head==null){
               head=node;
               last=node;
           }
           node.next=head;
           head.prev=node;
           head=node;
       }

尾插法 

尾插法的原理是一样的，头插反着来就是了

 //尾插法
       public void addLast(int data){
           LinkedList node=new LinkedList(data);
           if(head==null){
               head=node;
               last=head;
           }
           node.next=last;
           last.prev=node;
           last=node;
           }

任意位置插入 

 修改节点的指向的就可以实现这个效果了，注意改变的指向次序

    // 任意位置插入,第一个数据节点为0号下标
    public boolean addIndex(int index, int data) {
        if (index < 0 || index > size()) {
            return false;
        }
        if (index == 0) {//头插
            addFirst(data);
            return true;
        }
        if (index == size()) {//尾插
            addLast(data);
            return true;
        }
        ListNode cur = findIndex(index);
        ListNode node = new ListNode(data);

        node.next = cur;
        cur.prev.next=node;//cur.prev.next表示的是cur的前一个节点的next
        node.prev = cur.prev;//cur.prev表示的是cur的前一个节点
        cur.prev=node;
        return true;
    }

    //找到要删除元素的下标
    public ListNode findIndex(int index) {
        ListNode cur = head;
        while (index != 0) {
            cur = cur.next;
            index--;
        }
        return cur;
    }

2.删除元素 

 删除该节点就是没有节点指向它了，直接跨过它了

删除第一次出现的指定元素 

    // 删除第一次出现关键字为key的节点
    public void remove(int key) {
        ListNode cur = head;
        while (cur != null) {
            if (cur.val == key) {
                if (cur == head) { //头删
                    head = cur.next;
                    if (head != null) {
                        head.prev = null; //如果头节点不为空，将新的头节点的prev设置为null
                    }
                } else {
                    cur.prev.next = cur.next;//将cur的前一个节点的next指向cur的下一个节点
                    if (cur.next != null) {
                        cur.next.prev = cur.prev;//将cur的下一个节点的prev指向cur的前一个节点
                    }
                }
                break;//找到就退出循环
            }
            cur = cur.next;
        }
    }

删除所有指定元素 

 两者是很相似的，区别在于有无break跳出循环

    // 删除第一次出现关键字为key的节点
    public void remove(int key) {
        ListNode cur = head;
        while (cur != null) {
            if (cur.val == key) {
                if (cur == head) { //头删
                    head = cur.next;
                    if (head != null) {
                        head.prev = null; //如果头节点不为空，将新的头节点的prev设置为null
                    }
                } else {
                    cur.prev.next = cur.next;//将cur的前一个节点的next指向cur的下一个节点
                    if (cur.next != null) {
                        cur.next.prev = cur.prev;//将cur的下一个节点的prev指向cur的前一个节点
                    }
                }
            
            }
            cur = cur.next;
        }
    }

3.清空链表 

清空整张链表也不难，将头尾都置null，将节点间的联系断开即可 

//清空整张链表
    public void clear() {
        ListNode cur=head;
        while(cur!=null){
            ListNode CurN=cur.next;
            cur.next=null;//逐个断开节点之间的连接
            cur.prev=null;
            cur=CurN;
        }
        head=last=null;//并将头节点和尾节点都置为null
    }

4.单双链表相同的方法 

 下面这三种方法，其实和方向无关了，所以总结在一处，，其实和单向链表是一模一样了

查找指定元素是否在链表中 

 //查找是否包含关键字key是否在单链表当中
       public boolean contains(int key){
           LinkedList cur=head;
           while(cur!=null){
               if(cur.val==key){
                   return true;}
               cur=cur.next;}
           return false;
           }

打印链表 

//打印链表
 
public  void display(){
         LinkedList cur=head;
         while(cur!=null){
             System.out.print(cur.val+" ");
             cur=cur.next;}
         System.out.println();
     }

获取链表长度 

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

ArrayList和LinkedList的区别

在实际场景当中，这两种数据结构有着各自的优势，但区别还是要熟悉的，总结在这里了~

不同点	ArrayList	LinkedList
存储空间上	物理上一定连续	逻辑上连续，但物理上不一定连续
随机访问	支持O(1)	不支持：O(N)
头插	需要搬移元素，效率低O(N)	只需修改引用的指向，时间复杂度为O(1)
插入	空间不够时需要扩容	没有容量的概念
应用场景	元素高效存储+频繁访问	任意位置插入和删除频繁

那文章的内容就总结到这里，如果觉得有帮助不妨点个免费的赞吧，您的支持是我更新的最大动力，下次见~