面试题1——反转单链表

题目

反转一个单链表

实现

1.（递归法）利用递归思想，从头结点递归遍历到最后一个结点，递归返回最后一个结点并修改指针，使指针指向前一个结点。

2.（移动指针）定义当前结点指针cur，前一个结点指针pre，循环迭代，计算下一个结点指针，每次将当前结点指针反转指向前一个结点。

定义结点：

Node.java

public class Node {
    public int value;
    public Node next;

    public Node(int data) {
        this.value = data;
    }
}

NodeReverse.java

import java.util.Stack;

public class NodeReverse {
    //===================单链表反转==================
    //反转，递归思想
    public static Node reverseRecur(Node node) {
        if (node == null || node.next == null) {
            return node;
        } else {
            Node nn = reverseRecur(node.next);
            //下一个节点的指针指向上一个节点
            node.next.next = node;
            //断掉当前节点指向下一节点的指针
            node.next = null;
            return nn;
        }
    }

    //反转，移动指针
    public static Node reverseMovePoint(Node node) {
        //前一个节点指针
        Node pre = null;
        //当前节点指针
        Node cur = node;
        while (cur != null) {
            //当前节点的下一个节点
            Node nextNode = cur.next;
            //当前节点指向下一个节点的指针反转，指向前一个节点
            cur.next = pre;
            //当前节点变前一个(pre)节点，前一个节点的指针指向当前节点
            pre = cur;
            //下一个节点变当前(cur)节点，当前节点指针指向下一个节点
            cur = nextNode;
        }
        return pre;
    }

    //==================倒着打印链表=====================
    //递归倒着打印
    public static void printTailRec(Node node){
        if (node.next ==null){
            System.out.print(node.value + " ");
            return;
        } else {
            printTailRec(node.next);
        }
        System.out.print(node.value + " ");
    }

    //遍历，用栈存储，倒着打印
    public static void printTailStack(Node node){
        Stack<Node> stack = new Stack<Node>();
        if (node == null){
            System.out.println("已经为null");
            return;
        }else {
            while (node != null){
                stack.push(node);
                node = node.next;
            }
            while (!stack.isEmpty()){
                System.out.print(stack.pop().value + " ");
            }
        }
    }

    //打印单链表
    public static void printLinked(Node head) {
        Node tmp = head;
        while (true) {
            System.out.print(tmp.value + " ");
            if (tmp.next == null)
                break;
            else
                tmp = tmp.next;
        }
    }

    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);
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;

        System.out.println("反转前打印==");
        printLinked(node1);
        System.out.println("");

        Node n = reverseRecur(node1);
        System.out.println("反转后打印==");
        printLinked(n);
        System.out.println("");

        Node nn = reverseMovePoint(n);
        System.out.println("再次反转后打印==");
        printLinked(nn);
        System.out.println("");

        //倒着打印链表
        System.out.println("倒着打印链表");
        printTailRec(node1);
        System.out.println("");
        printTailStack(node1);

    }
}

输出结果：

反转前打印==
1 2 3 4
反转后打印==
4 3 2 1
再次反转后打印==
1 2 3 4
倒着打印链表
4 3 2 1
4 3 2 1