4、剑指offer——从尾到头打印链表java实现
**题目描述**
**输入一个链表，按链表从尾到头的顺序返回一个ArrayList。**
时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 32M，其他语言64M
思路：
1.如果链表为空，则直接返回空的ArrayList
2.如果链表非空，遍历链表，按照顺序将链表中的数据添加到ArrayList中
3.反转ArrayList（倒序输出）(倒序方法，文末补充）
/**
* public class ListNode {
* int val;
* ListNode next = null;
*
* ListNode(int val) {
* this.val = val;
* }
* }
*
*/
import java.util.ArrayList;
import java.util.Collections;
public class Solution {
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
//先创建一个空的ArrayList
ArrayList arrList = new ArrayList();
if(listNode == null) {
return arrList;
}
//遍历链表
int i = 0;
while(listNode.next != null) {
arrList.add(i,listNode.val);
i++;
listNode = listNode.next;
}
//将最后一个节点的数值添加到集合中
arrList.add(i,listNode.val);
//将集合反转
Collections.reverse(arrList);
//Collections.reverse(arrList);
return arrList;
}
}
补充:
集合的复制和反转
1.for循环方法：
2.System.arraycopy()方法：
3.Arrays.copyOf()方法：
4.Object.clone()方法：
public class Test {
public static void main(String[] args) {
int[] array1 = {1,2,3,4,5};
// 1.通过for循环
int[] array2 = new int[5];
for(int i = 0;i < array1.length;i++) {
array2[i] = array1[i];
}
for(int i = 0;i < array2.length;i++) {
System.out.print(array2[i]);
}
System.out.println();
//2.通过System.arraycopy()
int[] array3 = new int[5];
System.arraycopy(array1, 0, array3, 0, 5);
for (int i = 0; i < array3.length; i++) {
System.out.print(array3[i]);
}
System.out.println();
//3.通过Arrays.copyOf()
int[] array4 = new int[5];
array4 = Arrays.copyOf(array1, 5);
for (int i = 0; i < array4.length; i++) {
System.out.print(array4[i]);
}
System.out.println();
//4.通过Object.clone()
int[] array5 = new int[5];
array5 = array4.clone();
for (int i = 0; i < array5.length; i++) {
System.out.print(array5[i]);
}
}
}
各个方法的优缺点
1.for循环方法
代码灵活，但效率低。
2.System.arraycopy()方法
通过源码可以看到，其为native方法，即原生态方法。自然效率更高。
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
3.Arrays.copyOf()方法
同样看源码，它的实现还是基于System.arraycopy()，所以效率自然低于System.arraycpoy()。
public static int[] copyOf(int[] original, int newLength) {
int[] copy = new int[newLength];
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
4.Object.clone()方法
从源码来看同样也是native方法，但返回为Object类型，所以赋值时将发生强转，所以效率不如之前两种。
protected native Object clone() throws CloneNotSupportedException;
如何反转集合？
下面的示例反转使用Collections.reverse(ArrayList)方法的数组列表。
import java.util.ArrayList;
import java.util.Collections;
public class Main {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
arrayList.add("A");
arrayList.add("B");
arrayList.add("C");
arrayList.add("D");
arrayList.add("E");
System.out.println("Before Reverse Order: " + arrayList);
Collections.reverse(arrayList);
System.out.println("After Reverse Order: " + arrayList);
}
}
上面的代码示例将产生以下结果:
Before Reverse Order: [A, B, C, D, E]
After Reverse Order: [E, D, C, B, A]
