剑指offer--从尾到头打印链表 （链表 动态数组）

题目描述

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

本题考查的知识点是链表、栈，概念还不熟悉，先来熟悉一下基础吧

ArrayList 动态数组

通过添加和删除元素，就可以动态改变数组的长度
优点：
1、支持自动改变大小
2、可以灵活的插入元素
3、可以灵活的删除元素
局限：
比一般的数组速度慢一些

ArrayList和List的关系，参考这位博主Arraylist和List的关系
ArrayList和Array区别：

• Array数组是静态的，一旦创建后无法更改数组的大小，他是java的对象，不提供任何方法，只提供一个公开的length属性返回数组的长度
• ArrayList是一个可以调整自身大小的动态数组，它是一个类，拥有类的所有属性。

在java中用ArrayList声明一个int型的数组

ArrayList<integer> list = new ArrayList<integer>(); //整数list
ArrayList<int[]> list = new ArrayList<int[]>();//数组list

1、初始化

ArrayList arr1 = new ArrayList();//不初始化容量
ArrayList arr2 = new ArrayList(3);//初始化容量为3
ArrayList arr3 = new ArrayList(a);//用一个集合或数组初始化a为一个数组

2、添加元素
将value对象添加到ArrayList的结尾处–add(object value)

ArrayList arr4 = new ArrayList();
arr4.add("a");
arr4.add("b");
arr4.add("c");
//输出结果为
a,b,c

在指定index位置，添加新元素value–add(int index,Object value)
3、删除元素
删除指定位置的元素，并返回该元素–remove()

arr.remove("a");//根据对象删除
arr.remove(0);//根据下标删除元素

4、获取ArrayList的大小，返回元素个数–size()

arr.size();//获取arr数组的大小

5、用指定元素object替换集合中index位置的元素–set(index,object)

arr.set(1,"a");//设置arr中第一个元素为a

ListNode java链表

ListNode是由自己定义的java中的链表对象，类结构如下：

public class ListNode{
    int val;//该节点的值
    ListNode next;//下一节点的位置
}

ListNode list = new ListNode();
list.val;
list.next;  //后边没有括号

栈stack

java中stack的方法包括：

1. push(num) 入栈
2. pop() 出栈
3. empty() 判断栈是否为空
4. peek() 获取栈顶元素
5. search(num) 判断num是否在栈中，在返回1，不在返回-1

ArrayList 中有个方法是 add(index,value)，可以指定 index 位置插入 value 值

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> list = new ArrayList();
        while(listNode!=null){
            list.add(0,listNode.val);
            listNode = listNode.next;
        }
        return list;
    }
}

递归解法

import java.util.ArrayList;

public class Solution {
    ArrayList<Integer> list = new ArrayList();
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        if(listNode != null){
			printListFromTailToHead(listNode.next);//递归
			list.add(listNode.val);
		}
        return list;
    }
}

利用栈

import java.util.ArrayList;
import java.util.Stack;//记得导包
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList list = new ArrayList();
    	Stack stack = new Stack();
    	while(listNode != null){
    		stack.push(listNode.val);
    		listNode = listNode.next;
    	}
    	while(!stack.empty()){
    		list.add(stack.pop());
    	}
    	return list;
    }
}

递归代码简单，但是当链表长度不断增加的时候，就会导致递归深度加深，从而有可能导致函数调用栈溢出，显然使用栈基于循环来实现代码的鲁棒性要好一些。