秋招常考题

1、反转链表

1、为防止与原来的链表结构断裂，需要保存当前的结构信息，即tmp=hHead.next

2、直接用pHead反向指向，pHead.next=pre

3、开始时pre=None

4、元素后移。pre=pHead，此时pHead.next反向已经指向了，但之前tmp保存了原始的hHead.next信息

所以，pHead=tmp

5、有的博客里用pre，cur，这里cur=pHead

# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    # 返回ListNode
    def ReverseList(self, pHead):
        if not pHead or not pHead.next:
            return pHead
        last = None   #指向上一个节点
        while pHead:
            #先用tmp保存pHead的下一个节点的信息，
            #保证单链表不会因为失去pHead节点的next而就此断裂
            tmp = pHead.next   
            #保存完next，就可以让pHead的next指向last了
            pHead.next = last
            #让last，pHead依次向后移动一个节点，继续下一次的指针反转
            last = pHead
            pHead = tmp
        return last

2、查找链表第一个相同节点

1.分别遍历两个链表，如果尾节点不同则不相交，返回None，如果尾节点相同则求相交结点。 
2.求相交结点的方法是，求出链表长度的差值，长链表的指针先想后移动lenA-lenB。然后两个链表一起往后走，若结点相同则第一个相交点。

class Solution(object):
    def getIntersectionNode(self, headA, headB):
        """
        :type head1, head1: ListNode
        :rtype: ListNode
        """
        lenA, lenB = 0, 0
        pA = headA
        pB = headB
        while pA:
            pA = pA.next
            lenA += 1
        while pB:
            pB = pB.next
            lenB += 1
        pA = headA
        pB = headB
        if lenA > lenB:
            for i in range(lenA-lenB):
                pA = pA.next
        else:
            for i in range(lenB-lenA):
                pB = pB.next
        while pA!=pB:
            pA = pA.next
            pB = pB.next
        return pA

3、二叉树的层次遍历

方法1 ，利用队列，python 列表来模拟，入队一个节点之后，把该节点左右子树也分别入队，之后该节点出队，直到队列中没有节点。

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回从上到下每个节点值列表，例：[1,2,3]
    def PrintFromTopToBottom(self, root):
        # write code here
        outList=[]
        queue=[root]
        while queue!=[] and root:
            outList.append(queue[0].val)
            if queue[0].left!=None:
                queue.append(queue[0].left)
            if queue[0].right!=None:
                queue.append(queue[0].right)
            queue.pop(0)
        return outList
--------------------- 
作者：lyshello123 
来源：CSDN 
原文：https://blog.csdn.net/songyunli1111/article/details/81706801 
版权声明：本文为博主原创文章，转载请附上博文链接！

方法2，不用队列，每一次遍历一层所有的节点

def PrintFromTopToBottom(self, root):
        if not root:
            return []
        currentStack = [root]
        outList= []
        while currentStack:
            nextStack = []
            for point in currentStack:
                if point.left: 
                    nextStack.append(point.left)
                if i.right: 
                    nextStack.append(point.right)
                outList.append(point.val)
            currentStack = nextStack
        return outList

4、求二叉树深度（根节点到叶节点）

利用层次遍历，遍历一层，深度加一

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def TreeDepth(self, pRoot):
        # write code here
        if not pRoot:
            return 0
        a = [pRoot]
        d = 0
        while a:
            for node in a:
                b = []
                if node.left:
                    b.append(node.left)
                if node.right:
                    b.append(node.right)
                a = b #层次遍历
                d +=1 
        return d

5 深度优先遍历

利用栈，这个数据结构。也是先序遍历，即根左右。先左，后右。

由于深度优先遍历的结果，是利用出栈的结果。也就是左节点先出栈，右节点后出栈。

由于栈先进后出，所以进栈的时候，要先进右节点，后进左节点

栈为空 循环结束

def DFS(root):
    if not root:
        return 
    stack =[]
    stack.append(root)
    result = []
    while stack:
        now_node = stack.pop()
        result.append(now_node)
        if now_node.right:
            stack.append(noe_node.right)
        if now_node.left:
            stack.append(now_node.left)
    return result