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

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

剑指Offer 

基础知识

链表是一种很常见的基本数据结构，因为它的结构简单，通过指针把若干个节点连接成链状结构。链表的创建、插入结点、删除结点等操作都是很容易实现的。链表是一种动态的数据结构，因为在创建链表的时候，无须知道链表的长度。当插入一个新的结点的时候，首先为新的节点分配内存，然后把指针指向新的节点。因为链表是通过指针链接的，不需要整块的连续内存，因此它的空间利用效率比数组高。但是这也造成了在链表中的查询只能从某一节点开始沿着指针遍历链表，它的时间效率为O(n)。下面实现一个简单的链表函数：

1. class ListNode{ 

   ---

2. public int val; 

   ---

3. public ListNode next = null; 

   ---

4. public ListNode(int val){ 

   ---

5. this.val = val; 

   ---

6. } 

   ---

7. } 

   ---

8. void add(ListNode head, int val){ 

   ---

9. ListNode n = new ListNode(val); 

   ---

10. if(head== null) 

    ---

11. head = n; 

    ---

12. else{ 

    ---

13. ListNode tmp = head; 

    ---

14. while(tmp.next != null){ 

    ---

15. tmp = tmp.next; 

    ---

16. } 

    ---

17. tmp.next = n; 

    ---

18. } 

    ---

19. } 

    ---

20.  

    ---

21. boolean remove(ListNode head, int val){ 

    ---

22. if(head == null) 

    ---

23. return false; 

    ---

24. if(head.val == val){ 

    ---

25. head = head.next; 

    ---

26. return true; 

    ---

27. } 

    ---

28. ListNode deletedNode = null; 

    ---

29. ListNode tmp = head; 

    ---

30. while(tmp.next != null && tmp.next.val != val){ 

    ---

31. tmp = tmp.next; 

    ---

32. } 

    ---

33. if(tmp.next != null && tmp.next.val == val){ 

    ---

34. deletedNode = tmp.next; 

    ---

35. tmp.next = tmp.next.next; 

    ---

36. return true; 

    ---

37. } 

    ---

38. return false;  

    ---

39. } 

    ---

题目

输入一个链表的头结点，从头到尾反过来打印每个结点的值。

解题思路及代码

1. 单向链表只能按照指针从头到尾一个方向来访问，这个要求的是从尾到头。可以借助栈来实现链表的反转。当从头到尾访问的时候，把链表的每一个结点压入到栈中，根据栈后进先出的特点，那么最后入栈的结点最先出栈，这样逐一输出栈中的结点，就能完成链表的反转。

1. import java.util.ArrayList; 

   ---

2. import java.util.Stack; 

   ---

3. public class Solution { 

   ---

4. public ArrayList<Integer> printListFromTailToHead(ListNode listNode) { 

   ---

5. ArrayList<Integer> res = new ArrayList<>(); 

   ---

6. if(listNode == null) 

   ---

7. return res; 

   ---

8. Stack<ListNode> s = new Stack<>(); 

   ---

9. ListNode pos = listNode; 

   ---

10. while(pos != null){ 

    ---

11. s.push(pos); 

    ---

12. pos = pos.next; 

    ---

13. } 

    ---

14. while(!s.isEmpty()){ 

    ---

15. res.add(s.pop().val); 

    ---

16. } 

    ---

17. return res; 

    ---

18. } 

    ---

19. } 

    ---

2. 使用递归，当访问到每一个结点的时候，如果它的下一个结点不为空，那么先输出它后面的结点，然后输出它自身。(但是递归有个问题，当链表很长的时候，就会导致函数的调用的层级很深，这就有可能导致函数的调用栈溢出。

1. import java.util.ArrayList; 

   ---

2. public class Solution{ 

   ---

3. public ArrayList<Integer> printListFromTailToHead(ListNode listNode) { 

   ---

4. ArrayList<Integer> res = new ArrayList<>(); 

   ---

5. if(listNode == null){ 

   ---

6. return res; 

   ---

7. recursive(listNode,res); 

   ---

8. return res; 

   ---

9. } 

   ---

10. public void recursive(listNode node, ArrayList<Integer> res){ 

    ---

11. if(node== null) 

    ---

12. return; 

    ---

13. else{ 

    ---

14. recursive(node.next,res); 

    ---

15. } 

    ---

16. res.add(node.val); 

    ---

17. } 

    ---

18. } 

    ---