【菜鸡刷题-剑指offer06 - 牛客NC78】从尾到头打印链表 || 三种解法 || 遍历+栈 | 递归 | 头插法 反转链表 || python

---

@author = YHR | 代码原创 | 转载请标明来源！

---

---

题目描述

输入一个链表的头节点，从尾到头反过来返回每个节点的值
（用数组返回）

一个简单的反向遍历链表的题目~

---

解法一： 遍历 + 栈

1. 从头节点，依次遍历末尾，每次遍历节点的值压栈；
2. 栈依次pop，返回到数组中。（栈先进后出）

从头节点，P指针依次遍历，直至链表末尾，每次遍历节点的值压栈 :

栈依次pop，返回到数组中。（栈先进后出）:
代码：
（直接用数组表示栈，每次新插入，都插入到数组头部）

def traverseWithStack(head):
        Stack = []
        p = head
        while p is not None:
            Stack.insert(0, p.val)
            p=p.next
        return Stack

---

解法二： 递归

既然能用栈解决，则可以自然地联想到 “递归” ！

毕竟，递归也是基于系统压栈，出栈来的~

递归： 永远先打印 p.next， 再打印 p.val， 递归出口为 入口参数的node为空

不多说啦，直接上代码~

Stack = [] 

def loopTraverse(head):
    global Stack  # 全局变量
    p = head
    if p is not None:
        if p.next is not None:
            loopTraverse(p.next)  # 永远先打印 p.next
        Stack.append(p.val)  # 再打印 p.val
      
print(Stack)

---

解法三： 反转链表 - （牛客NC78）

1. 输入一个链表，反转链表后，输出新链表的表头， - 牛客NC78
2. 然后重新遍历新链表，输出结果。

利用 头插法 反转链表
（以下的方法无须申请新结点哦，即不需要占用新的空间，但是会修改原链表~）

1. 原始链表，初始化 newhead= None， newhead永远指向新链表的第一个节点。

2. 令aim指向oldhead，表示待处理的节点。 oldhead后移，表示未处理链表的第一个结点。
   

3. 令 aim.next = newhead， 即aim.next=None； newhead重新指向aim，（newhead永远指向 新链表 的第一个节点。）

4. aim = oldhead，表示指向当前要处理的节点； oldhead 继续后移一位，表示未处理链表的第一个结点。
   

5. 令 aim.next = newhead

newhead重新指向aim，（newhead永远指向 新链表 的第一个节点。）

6. aim = oldhead，表示指向当前要处理的节点； oldhead 继续后移一位，表示未处理链表的第一个结点。（此时oldhead走到末尾，指向None）

7. 令 aim.next = newhead， newhead重新指向aim，（newhead永远指向 新链表 的第一个节点。）
   
8. 令 aim = oldhead，表示指向当前要处理的节点，但由于此时oldhead走到末尾，指向None，所以aim 也为None，表示该链表处理完毕！退出循环。
9. newHead即为新链表的第一个节点。

代码
反转链表：

 def reverseLinkedList(self, head):
        # 1. revere this linked list
        newHead = None

        aim = head  # initial

        while aim is not None:
            oldhead = aim.next
            aim.next = newHead
            newHead = aim
            aim = oldhead

从头到尾， 遍历新链表。

        # 2. traverse this reverse linked list
        p = newHead
        traverse = []
        while p is not None:
            traverse.append(p.val)
            p = p.next
        
        return traverse