单链表反转（包含详细的理解过程）

链表和数组是最基础的数据结构了，不过相比于数组，链表的结构更加复杂一点。

为什么一个图片会这么大，好吧，我也不知道。虽然丑，但是假装这就是好看的那个链表的结构了

那么要反转这个链表，需要反转的是什么呢，其实只需要把他的指针的指向换个顺序，将所有的next的顺序指向他的上一个这样的话，就ok了

是不是有种结束的感觉          hiahiahia

 

那么我们先手写一个链表的Node

 

class Node<T>{
    /**
     * 存放数据的地方
     */
    T val;

    /**
     * 存放引用的地方（C语言中的指针，意思差不多）
     */
    Node next;

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

    public T getVal() {
        return val;
    }

    public Node getNext() {
        return next;
    }

    public void setVal(T val) {
        this.val = val;
    }

    public void setNext(Node next) {
        this.next = next;
    }
}

好了，相信大家已经看到了 上面的这个链表的结构

那么接下来，我们要做的就是对他进行反转，那么首先我们写一个链表的工具类

public class LinkedNode {

    public Node getHeader() {
        return header;
    }

    private Node header;

    /**
     * 添加节点
     * @param val
     */
    public void addNode(int val){
        if(null==header){
            //一开始是没有后面的节点的
            header=new Node(val,null);
            return;
        }
        //每次添加的时候总是往最前面添加，单链表的结构就是不论从前往后还是从后往前都是添加到第一个了，也就是只有第一个才能开始查找起来
        header=new Node(val,header);
    }


    /**
     * 单链表反转
     * @param header
     * @return
     */
    public Node reverseLink(Node header){
        if(null==header||null==header.getNext()){
            return header;
        }
        Node cur=header.getNext();
        Node pre =header;
        while (null!=cur){
            //先把下一个节点临时存起来
            Node next = cur.getNext();
            //这一行才是核心，就是把next的指针从下一个  换成上一个
            cur.setNext(pre);
            //把上一个指针挪到当前的，准备下一个
            pre=cur;
            //把当前的指针挪到下一个，准备下一次呼唤
            cur=next;
        }
        //这个时候需要把一开始的头节点置空，不然就会出现循环引用的情况，因为改变之后的倒数第二个节点的next和原来的header形成相互引用
        header.setNext(null);
        return pre;
    }

    /**
     * 核心就是每次从最后一个加到第一个，然后不断地删掉多加的，和之前的循环不太一样的
     * @param header   每次递归获得的header都是一个节点的引用
     * @return
     */
    public Node reverseLinked2(Node header){
        if(null==header||null==header.getNext()){
            //这一步是最核心的，因为新的节点起点从这里开始
            return header;
        }
        //最后一个节点调用的时候最先返回的是最后一个节点,这个node引用是从之前的最后一个节点开始记录的，不断的添加新的节点每次添加一个header，而header执行到最后的时候其实是之前的第一个个节点
        Node node = reverseLinked2(header.getNext());

        //从倒数第二次递归开始获得的值，也就是倒数第二个节点要想给最后一个节点后面加值，就只能这样设置，最后一个节点的next设置为倒数第二个节点
        header.getNext().setNext(header);
        //这样的话，每次都是添加的header这个引用的这样一个几点
        header.setNext(null);

        return node;
    }

    public void iterate(Node header){
        if(null==header){
            return;
        }
        Node next = header;
        while (null!=next){
            System.out.print("  " + next.getVal());
            next=next.getNext();
        }
    }

}

 

ok，好了，最后我们来测试一下

class TestNode{
    public static void main(String[] args) {
        LinkedNode node =new LinkedNode();
        for (int i = 0; i < 4; i++) {
            node.addNode(i);
        }
        node.iterate(node.getHeader());
        System.out.println("反转前\n反转后");
        Node node1 = node.reverseLinked2(node.getHeader());
        node.iterate(node1);
    }
}

好了，结束了，下一次我们来讲下 链表中环的检测