聊聊链表的那些事儿

1. 说说单链表
   理论方面我们就来谈谈什么叫链表，其实链表最关键的就是指针这个概念，用java语言来说的话就是引用。首先我们来看看链表中的每个node节点是怎样的。

class Node<T>{
    T item;
    Node<T> next;
    public Node(T element,Node<T> next){
        this.item = element;
        this.next = next;
    }
}

这是我写的一个node节点，大家可以很简单的就能看出来，他就是一个类，但是这个类中有一个next变量其竟然类型是自身node类，这就是引用，它默认是null，但是当我们使用Node该节点的对象时，调用该对象的next变量指向另一个node节点，这是二者之间就建立起了联系，即：

Node<T> node1 = new Node<T>(element,next);
Node<T> node2 = new Node<T>(element,next);
node1.next = node2;

这里就是将node2的地址赋给了node1中next这个变量，那么下次如果再想访问node2，我可以直接使用node1调用next这个变量就能访问到了。

有人可能要说，那我直接用数组的下标不是更方便吗？此话确实不假，但是链表自然有他独到的优势，它的优势就体现在增加和删除！如果数组想要增加或删除一个元素，那么他移动后面的所有数据，其时间复杂度代价是非常巨大的。而链表想要增加或者删除一个元素，只需要改变next这个变量的指向就可以了。

值得注意的一点是，数组是一串连续的地址，但是链表不是，他们每个元素都记录了下一个元素的地址，因此他们在物理磁盘中，并不是连续的。之所以提到这一点，就是为了让大家不要把数组的思维惯性带到了链表中。在链表中，一个节点，就可以代表以他为首的整条链（单链表），换句话说，不存在nodelist这种东西，一个head节点就够了！

现在，我们再来说说链表的遍历，千万要注意，不要有数组的惯性思维去思考链表，链表中是没有下标这种说法的，它的遍历必须要通过next来一步一步往下走。也就是说他只能这样一步步遍历：

Node<T> f= first;
        while (f.next!=null){
            f=f.next;
        }

这个方法就是得到头结点，然后一步一步通过next去遍历，重点就是这个链表的最后一个节点，记住这一点，通过next去遍历这点很重要！！！

好了，说了这么多我们来实战一个例子吧！其实链表的增删改查都不难，只要你掌握了node节点的内部结构以及链表遍历的特有规律，很容易就写出来了。但是，重点是你如何利用这两样东西，写出更多的功能？？？你确定你能灵活领用这两个特征吗？下面我们来写一个两个有序列表合并的例子：

class Node2{
    int value;
    Node2 next;
    public Node2(int element,Node2 next){
        this.value = element;
        this.next = next;
    }
}
public class Demo3 {
    Node2 first;
    Node2 last;
    int size = 0;
    public void addFirst(int element){
        Node2 f = first;
        Node2 newNode = new Node2(element,f);
        first = newNode;
        if(f == null){
            last = first;
        }
        size++;
    }
    public void add(int element){
        Node2 f = first;
        Node2 newNode = new Node2(element,null);
        if (first==null){
            addFirst(element);
        }else {
            for(int i=0;i<size-1;i++){
                f=f.next;
            }
            f.next=newNode;
            size++;
        }

    }
    //这个方法是重中之重，毫不脸红的说，这个方法并不是我想出来的，它是一个相对比较固定的算法，早有大牛弄出来了
    //看到了吗??简简单单几行代码,将链表遍历的特征体现的淋漓尽致,更是充分利用了链表一个节点即一个链的特征,经常写数组很少写链表的往往不太习惯呢!
    public static Node2 merge(Node2 head1,Node2 head2){
        Node2 head = head1.value<=head2.value?head1:head2;
        Node2 cr1 = head1.value<=head2.value?head1:head2;
        Node2 cr2 = head1.value>head2.value?head1:head2;
        Node2 pre = cr1;
        Node2 next = cr1.next;//这个节点主要是为了记录cr2的下一个节点,用于作为中间变量
        while(cr1!=null&&cr2!=null){
            if(cr1.value<=cr2.value){
                pre=cr1;
                cr1 = cr1.next;
            }else{
                next=cr2.next;//将此时cr2节点的下一个节点给next,作为中间变量
                pre.next=cr2;
                cr2.next=cr1;//这步主要是为了可以简化上面if语句里面的内容,并且使得pre的next节点是cr1
                pre=cr2;//递进,让pre节点向前递进
                cr2=next;//让cr2回到正轨,回到他的那条链当前节点,通过next作为中间变量向下递进
            }
        }
        pre.next=cr1==null?cr2:cr1;
        return head;
    }

    public static String toString(Node2 node){
        Node2 n = node;
        String str = "";
        while(n.next!=null){
            str+=n.value+",";
            n=n.next;
        }
        str+=n.value;
        return str;
    }
    public static void main(String args[]){
        Demo3 demo3_1 = new Demo3();
        demo3_1.add(1);
        demo3_1.add(2);
        demo3_1.add(5);

        Demo3 demo3_2 = new Demo3();
        demo3_2.add(1);
        demo3_2.add(3);
        demo3_2.add(4);

        Node2 head = merge(demo3_1.first,demo3_2.first);
        System.out.println(toString(head));
    }
}

2. 简单说说双链表
   其实你真正理解了单链表，那么双链表自然也不再话下，其实在真正应用中，单链表往往比双链表用的多得多，因为双链表相对单链表可以说仅有一个优势，那就是知道一个节点就可以直接访问前面的一个节点，但是我觉得这个优势的应用场景并不多，你想想，我们一般都是根据节点里的元素去进行查找之类的操作，很少有直接知道节点的时候把。

行了，废话不多说，我直接贴上双链表相关增删改查代码吧，这些都很简单，知道原理很容易就写出来，还是那句话，想掌握牢固就去做题目，题目中让你实现的需求往往需要你对链表有这更深的理解与应用。

双链表代码如下：

class Node4{
    int value;
    Node4 pre;
    Node4 next;
    public Node4(Node4 pre,int element,Node4 next){
        this.value = element;
        this.pre = pre;
        this.next = next;
    }
}
public class Demo4 {
    Node4 first;
    Node4 last;
    int size;
    public void addFrist(int element){
        Node4 f = first;
        Node4 newNode = new Node4(null,element,f);
        if(f!=null) {
            f.pre = newNode;
        }
        first = newNode;
        if(f==null){
            last = first;
        }
        size++;
    }

    public void add(int element){
        Node4 head = first;
        Node4 newNode = new Node4(null,element,null);
        if(size==0){
            addFrist(element);
            return;
        }else{
            for (int i=0;i<size-1;i++) {
                head = head.next;
            }
            head.next = newNode;
            newNode.pre = head;
            size++;
        }
    }

    public void insert(int index,int element){
        Node4 head = first;
        Node4 newNode = new Node4(null,element,null);
        if(index<=0){
            addFrist(element);
        }else if(index>=size){
            add(element);
        }else {
            for(int i=0;i<index-2;i++){
                head = head.next;
            }
            newNode.next = head.next;
            head.next = newNode;
            newNode.pre = head;
            size++;
        }
    }

    public boolean remove(int index){
        Node4 head = first;
        if(index<1||index>size){
            return false;
        }else {
            for(int i=1;i<index-1;i++){
                head = head.next;
            }
            head.next = head.next.next;
            head.next.pre = head;
            size--;
            return true;
        }
    }

    public String toString(){
        String str = "";
        Node4 head = first;
        for(int i=0;i<size;i++){
            str += head.value+",";
            head = head.next;
        }
        return str;
    }

    public static void main(String args[]){
        Demo4 demo4 = new Demo4();
        demo4.add(1);
        demo4.add(2);
        demo4.add(3);
        demo4.add(4);
        demo4.insert(2,22);
        demo4.remove(3);
        System.out.println(demo4.toString());
    }
}

我这个人通常时候写代码不太喜欢写注释，这不是一个好习惯，下次尽量改正，如果有什么不太理解的地方尽管私聊我QZQ