面试题1-从头到尾打印单链表

一.题目描述

输入一个链表头结点，按照从尾到头的顺序打印。

二.题目思路

这里提供三个思路：

    第一种方法：使用栈的方式  利用栈的特点  先进后出  后进先出

    第二种方法：采用递归的方式

    第三种方法：反转单链表后，打印链表

三.题目实现

Node类

public class Node {
    //用于保存节点中的数据
    private Object data;

    //用于保存下一个节点的地址值
    private Node next;

    public Node(Object data) {
        this.data = data;
    }

    public Node(Object data, Node next) {
        this.data = data;
        this.next = next;
    }

    public Object getData() {
        return data;
    }

    public Node getNext() {
        return next;
    }

    public void setData(Object data) {
        this.data = data;
    }

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

第一种方法实现：

     实现步骤：

     1.先创建一个栈

     2.从头到尾遍历单链表，然后将遍历出来的节点依次存入栈中

     3.遍历并打印输出栈中的节点

    /**
     * 从头到尾打印单链表  实现一 使用了栈
     * @param head
     */
    public static void printListFromTailToHead(Node head){
        //1.处理头结点为null的情况
        if (head == null){
            throw new NullPointerException();
        }
        //创建一个栈
        Stack<Node> stack = new Stack<>();
        //遍历单链表放入栈中
        while (head != null){
            stack.push(head);
            head = head.getNext();
        }
        //打印栈中的元素
        while (!stack.isEmpty()){
            Node node = stack.pop();
            System.out.println(node.getData());
        }
    }

第二种方法实现：

采用递归的方式

    /**
     * 方法二  使用递归的方式
     * @param headNode
     */
    public static void reversePrint(Node headNode){
        //1.判断headNode为null的情况
        if (headNode == null){
            return;
        }
        //2.从尾到头打印以headNode下一个节点为首节点的链表
        reversePrint(headNode.getNext());
        System.out.println(headNode.getData());
    }

第三种方式：反转单链表后打印输出   （此方法为反转单链表   并没有实现打印输出）

实现步骤：

1.定义一个节点，用来保存反转后链表的首节点

2.把原链表的首节点插入到反转后链表的最前面

3.更新原链表和反转后链表的首节点

4.循环执行步骤2和步骤3，直到原链表的首节点为null

 public static Node reverse(Node headNode){
        //1.判断headNode为null和单链表只有一个节点的情况
        if (headNode == null || headNode.getNext() == null){
            return headNode;
        }
        //2.定义一个节点，用于保存反转后链表的首节点
        Node reverse = null;
        //3.定义一个循环，用于实现链表的反转
        while (headNode!=null) {
            //4.获得headNode的下一个节点
            Node nextNode = headNode.getNext();
            //5.把headNode插入到反转后链表的最前面
            headNode.setNext(reverse);
            //6.更新反转后链表的首节点
            reverse = headNode;
            //7.更新需要反转链表的首节点
            headNode = nextNode;
        }
        //8.返回反装后链表的首节点
        return reverse;
    }