单链表的翻转【java】递归法和迭代法，详细解释

#单链表的翻转【java】

java自带的linkedList已经有封装好的方法，这里研究的是自定的节点

例 原链表
0 1 2 3 4 5 6
翻转后
0 6 5 4 3 2 1

首先建立一个节点类，可以在这个类添加一些自己需要的方法，

必须的 getnext() setnext() getdata() …
和结点的构造我就不赘述了，大家一看代码就明白

其他的我就简单的添加了一个legnth方法获取长度便于后面使用

public
class Node {
    private int Data;// 数据域
    private Node Next;// 指针域

    public Node(){

    };
    public Node(int Data) {
        // super();
        this.Data = Data;
    }

    public int getData() {
        return Data;
    }

    public void setData(int Data) {
        this.Data = Data;
    }

    public Node getNext() {
        return Next;
    }

    public void setNext(Node Next) {

        this.Next = Next;
    }
    public int length(Node head){
        int count = 0;
        while (head.getNext()!=null){
            count++;
            head = head.getNext();
        }
        return count;
    }
}

递归方法：

1. 代码的核心是后面的递归翻转，如果一开始没有看懂可以先构建一个比较短的链表，在纸上画一下程序执行流程即可
2. 像节点链接成链表，链表输出这些小段代码，都有多种实现方式，我这里就用了比较笨的容易看懂的

class javaReaverse {
    public static void main(String[] args) {
        Node head = new Node(0);
        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        Node node4 = new Node(4);
        Node node5 = new Node(5);

//        链接在一起形成链表
        head.setNext(node1);
        node1.setNext(node2);
        node2.setNext(node3);
        node3.setNext(node4);
        node4.setNext(node5);


//       先保存当前的头部以方便于翻转后的打印
        Node start = head;

        // 调用反转方法获取新的头部
        head = Reverse(head);


        // 打印反转后的结果
        while (null != head) {
            System.out.print(head.getData());
            head = head.getNext();
        }
    }

//     递归翻转法，如果一开始没有读懂可以在纸上比划着就好读懂
    public static Node Reverse(Node head) {
        // head看作是前一结点，head.getNext()是当前结点，newHead是反转后新链表的头结点

//        递归结束的条件，以及到了最后的位置
        if (head == null || head.getNext() == null) {
//        直接返回该结点
            return head;
        }
        Node newHead = Reverse(head.getNext());// 先反转后续节点head.getNext()
        head.getNext().setNext(head);// 将当前节点的下一节点指向当前节点，完成翻转
        head.setNext(null);// 将当前节点的下一节点位置置为空
        return newHead;
    }
}

迭代法

1. 迭代法创建了三个变量(指针)，顺次往后交替
2. 我该方法的风格是为了单段链表的分段翻转写的(该题的进阶，我在那篇文章里详细解释了该方法，以及上面三个变量的用法)

public class ReverseLinkedListed2 {

    public static void main(String[] args) {

//        创建节点
        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        Node node4 = new Node(4);
        Node node5 = new Node(5);
        Node node6 = new Node(6);
        Node node7 = new Node(7);
        Node node8 = new Node(8);

//        设置头节点
        Node head = new Node();
        head.setNext(node1);

//        形成链表
        node1.setNext(node2);
        node2.setNext(node3);
        node3.setNext(node4);
        node4.setNext(node5);
        node5.setNext(node6);
        node6.setNext(node7);
        node7.setNext(node8);

        Reverse(head,head.length(head));

        head = head.getNext();
        while (head != null){
            System.out.println(head.getData());
            head = head.getNext();
        }
    }


    public static Node Reverse(Node head,int length){


//    创建三个判断位置

        Node current = head.getNext();
        Node next = current.getNext();
        Node tmp = next.getNext();
        Node nonReverseHead = current;


        for (int count = 1; count <length ; count++) {
//        翻转
            next.setNext(current);
//        将current next tmp顺次后移
            current = next;
            next = tmp;

            if (tmp != null){
                tmp = tmp.getNext();
            }
        }

//    移动head指向的位置
    head.getNext().setNext(next);
        head.setNext(current);
        return nonReverseHead;
    }

}

【注】关于单段链表分段翻转，这个的进阶可以去看的另一篇文章