剑指offer--3. 从尾到头打印链表

题目描述
输入一个链表，按链表从尾到头的顺序返回一个ArrayList。

方法一：自己的暴力写法

分析：

1. 首先获取链表的长度
2. 接着构造相同长度的int数组
3. 数组以倒序的方式依次加入链表中的元素

注意：

1. 链表还要熟悉，多看

代码：

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> alist = new ArrayList<Integer>();
        ListNode p = listNode;
        if(p==null){          
            return alist;
        }
        int length = 0;
       
        while(p!=null){
            length++;
            p = p.next;
        }
         int[] a = new int[length]; 
        while(listNode!=null){
              a[--length] = listNode.val;
              listNode = listNode.next;
        }
        for(int i=0;i<a.length;i++){
            alist.add(a[i]);
        }
         return alist;
    }
}

方法二: 使用栈解决

分析：
用栈来解决的话，思路比较清晰，由于栈是先进后出，因此遍历链表一次将值放入栈中，再依次取出即可。

注意：

1. 在java中使用栈时，我们不优先使用Stack类，而是常用双端队列来实现。Deque 接口及其实现提供了 LIFO 堆栈操作的更完整和更一致的 set，应该优先使用此 set，而非Stack类。例如： Deque stack = new ArrayDeque();此时它的入栈出栈则变为
   

代码：

import java.util.ArrayList;
import java.util.Deque;
import java.util.ArrayDeque;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> alist = new ArrayList<Integer>();
        ListNode p = listNode;
        if(p==null){          
            return alist;
        }
        Deque<Integer> d = new ArrayDeque<Integer>();
        while(p!=null){
           d.addFirst(p.val);
           p = p.next;
        }
        while(!d.isEmpty()){
            alist.add(d.removeFirst());
        }
        return alist;
    }
}

方法三 ：单链表反转

分析：
反转单链表

代码：

import java.util.ArrayList;

public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        // 尝试单链表的反转
        ArrayList<Integer> alist = new ArrayList<Integer>();
        ListNode p = listNode;
        if(p==null){          
            return alist;
        }
        ListNode head = null;
     
        while(p!=null){
            ListNode next = p.next;
            p.next = head;
            head = p;
            p = next;
        }
        while(head!=null) {
            alist.add(head.val);
            head = head.next;

        }
        return alist;
    }
}

方法四： 递归

import java.util.ArrayList;

public class Solution {
    ArrayList<Integer> alist = new ArrayList<Integer>();
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        // 递归的使用
        
        ListNode p = listNode;
        if(p==null){          
            return alist;
        }
        recurve(p);
        return alist;
       }
        // 递归函数
    private void recurve(ListNode head){
        // 递归到尾节点指向的空指针时，不再递归调用
        if(head!=null){
            recurve(head.next);
            alist.add(head.val);
        }
    }
}