Java 迭代 递归 反转 单链表 双向链表

Java 迭代 递归 反转 单链表 双向链表

private static int[] ints = new int[]{1, 2, 3, 4, 5};

    /**
     * 根据数组构造单链表
     */
    private static Node getNode() {
        Node node = new Node(-1);
        Node cursor = node;
        for (int i = 0; i < ints.length; i++) {
            cursor.value = ints[i];
            if (i < ints.length - 1) {
                cursor.next = new Node(-1);
            } else {
                cursor.next = null;
            }
            cursor = cursor.next;
        }
        return node;
    }

    /**
     * 迭代 - 反转链表
     */
    private static Node reverseNodeW(Node node) {
        Node temp;
        Node result = null;
        while (node != null) {
            temp = node.next;
            node.next = result;
            result = node;
            node = temp;
        }
        return result;
    }

    /**
     * 递归 - 反转 链表
     */
    private static Node reverseNodeR(Node node) {
        if (node == null || node.next == null) {
            return node;
        }
        Node result = reverseNodeR(node.next);
        node.next.next = node;
        node.next = null;
        return result;
    }

    /**
     * 根据数组构造双向链表
     */
    private static DoubleNode getDoubleNode() {
        DoubleNode node = new DoubleNode(ints[0]);
        DoubleNode temp = node;
        DoubleNode last = null;
        for (int i = 0; i < ints.length; i++) {
            temp.value = ints[i];
            temp.last = last;
            if (i < ints.length - 1) {
                temp.next = new DoubleNode(ints[i + 1]);
            } else {
                temp.next = null;
            }
            last = temp;
            temp = temp.next;
        }
        return node;
    }

    /**
     * 迭代 - 反转 双向链表
     */
    private static DoubleNode reverseDoubleW(DoubleNode node) {
        DoubleNode last = null;
        DoubleNode next;
        while (node != null) {
            next = node.next;
            node.last = next;
            node.next = last;
            last = node;
            node = next;
        }
        return last;
    }

    /**
     * 递归 - 反转 双向链表
     */
    private static DoubleNode reverseDoubleR(DoubleNode node) {
        if (node == null) {
            return node;
        }
        if (node.next == null) {
            //这里node结点是原始双向链表最后一个结点，所以反转时，这个结点是新链表头结点，则last为null
            node.last = null;
            return node;
        }
        DoubleNode result = reverseDoubleR(node.next);
        node.next.next = node;
        node.last = node.next;
        if (nodeOriginalRoot.value == node.value) {
            node.next = null;
        }
        return result;
    }

    /**
     * 双向链表记录原始头结点
     */
    private static DoubleNode nodeOriginalRoot = null;

    public static void main(String[] args) {
//        Node original = getNode();
//        Node res = reverseNodeR(original);
//        System.out.println("---zzz-----root.val = " + res.value);
        DoubleNode original = getDoubleNode();
        nodeOriginalRoot = original;
        DoubleNode res = reverseDoubleR(original);
        System.out.println("---zzz-----root.val = " + res.value);
    }