从尾到头打印链表

题目描述

输入一个链表，按链表从尾到头的顺序返回一个ArrayList

解题思路

思路一：借助栈Stack先进后出的特性，顺序遍历单链表进行压栈操作，遍历完后出栈装入ArrayList

思路二：使用递归的思想，先不保存头结点中的数据，而是先递归至最后一个结点后，将数据装入ArrayList

解题代码一

思路一核心方法

    /**
     * 使用递归的思想，先不保存头结点中的数据，而是先递归至最后一个结点后，将数据装入ArrayList
     */
    private static ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        if (listNode != null) {
            printListFromTailToHead(listNode.next);
            results.add((Integer) listNode.val);
        }
        return results;
    }

思路一完整案例 

import java.util.*;

/**
 * @program: LeeCode
 * @description: 从尾至头打印链表
 * @author: Mario
 * @create: 2019-09-15 15:05
 * @version: 1.0
 */

public class TailHeadPrintListNode {
    private static ArrayList<Integer> results = new ArrayList<>();
    public static void main(String[] args) {
        // 定一个简单的单链表
        ListNode listNode1 = new ListNode<Integer>(5);
        ListNode listNode2 = new ListNode<Integer>(81);
        ListNode listNode3 = new ListNode<Integer>(61);
        ListNode listNode4 = new ListNode<Integer>(95);
        listNode1.next = listNode2;
        listNode2.next = listNode3;
        listNode3.next = listNode4;
        List result = printListFromTailToHead(listNode1);
        for (Object num : result) {
            System.out.print(num + " ");
        }
    }

    /**
     * 使用递归的思想，先不保存头结点中的数据，而是先递归至最后一个结点后，将数据装入ArrayList
     */
    private static ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        if (listNode != null) {
            printListFromTailToHead(listNode.next);
            results.add((Integer) listNode.val);
        }
        return results;
    }

}
// 单链表实现
class ListNode<T>{
    ListNode next;
    T val;

    ListNode(T val) {
        this.val = val;
    }
}

解题代码二

思路二核心方法 

    /**
     * 借助栈Stack先进后出的特性，顺序遍历单链表进行压栈操作，遍历完后出栈装入ArrayList
     */
    private static ArrayList<Integer> printListFromTailToHead02(ListNode listNode) {
        Stack<Integer> stack = new Stack<>();
        // 进栈
        while (listNode != null) {
            stack.push((Integer) listNode.val);
            listNode = listNode.next;
        }
        ArrayList<Integer> results = new ArrayList<>(stack.size());
        // 出栈
        while (!stack.isEmpty()) {
            results.add(stack.pop());
        }
        return results;
    }

思路二完整案例

import java.util.*;

/**
 * @program: LeeCode
 * @description: 从尾至头打印链表
 * @author: Mario
 * @create: 2019-09-15 15:05
 * @version: 1.0
 */

public class TailHeadPrintListNode {
    private static ArrayList<Integer> results = new ArrayList<>();
    public static void main(String[] args) {
        // 定一个简单的单链表
        ListNode listNode1 = new ListNode<Integer>(5);
        ListNode listNode2 = new ListNode<Integer>(81);
        ListNode listNode3 = new ListNode<Integer>(61);
        ListNode listNode4 = new ListNode<Integer>(95);
        listNode1.next = listNode2;
        listNode2.next = listNode3;
        listNode3.next = listNode4;
        List result = printListFromTailToHead(listNode1);
        for (Object num : result) {
            System.out.print(num + " ");
        }
    }

    /**
     * 借助栈Stack先进后出的特性，顺序遍历单链表进行压栈操作，遍历完后出栈装入ArrayList
     */
    private static ArrayList<Integer> printListFromTailToHead02(ListNode listNode) {
        Stack<Integer> stack = new Stack<>();
        // 进栈
        while (listNode != null) {
            stack.push((Integer) listNode.val);
            listNode = listNode.next;
        }
        ArrayList<Integer> results = new ArrayList<>(stack.size());
        // 出栈
        while (!stack.isEmpty()) {
            results.add(stack.pop());
        }
        return results;
    }

}
// 单链表实现
class ListNode<T>{
    ListNode next;
    T val;

    ListNode(T val) {
        this.val = val;
    }
}