数据结构极客视频4

题目 leetcode50

解题思路 使用分治的方法 O(logN) 考虑N是单数还是双数 代码分为非递归与递归版
非递归

class Solution:
    def myPow(self, x: 'float', n: 'int') -> 'float':
        if n<0:
            x=1/x
            n=-n
        p =1
        while n:
            if n%2==1:
                p *=x
            x*=x
            n>>=1
        return p

递归

class Solution:
    def myPow(self, x: 'float', n: 'int') -> 'float':        
        if not n:
            return 1
        if n<0:
            return 1/self.myPow(x,-n)
      
        if n%2:
            return self.myPow(x,n-1)*x
        return self.myPow(x*x,n/2)
        

贪心算法

贪心算法使用场景

贪心算法题目 股票买卖

BFS与DFS 广度优先于深度优先搜索

广度优先

BFS 借用一个队列实现 队列的先进先出的特点 可以保证当前节点的孩子进去后 比下一个节点的孩子进去后先出来

def BFS(graph,start,end):
    queue =[]
    queue.append([start])
    visited.add(start)##对于树用不到  图的话 用得到
    while queue:
        node = queue.pop()
        visited.add(node)
        
        process(node)
        nodes = generate_related_nodes(node)## 找后继节点 并且后继节点没有被访问过
        queue.push(nodes)

深度优先

深度优先搜索 使用栈结果 栈的先进后出的性质 正好应用到深度优先中 由于递归也是使用栈实现的 所以代码可以有递归版本和非递归版本

递归版本

visited = set()## 图需要 检查是否重复
def  dfs(node,visited):
    visited.add(node)
    
    for next_node in node.children():
        if not next_node in visited:
            dfs(next_node,visited)

非递归版本

def DFS(self,tree):
    if tree.root is None:
        return []
    visited,stack=[],[tree.root]
    
    while stack:
        node = stack.pop()
        visited.add(node)
        
        precess(node)
        nodes = generate_related_nodes(node)
        stack.push(nodes)

题目 分层打印二叉树

---

方法1使用广度优先bfs 使用bfs 肯定用队列 先进先出 使用current_level记录当前行 注意下面代码是模板 如果是图的话 用visited记录下

---

def leveOrder(self,root):
    if not root:return []
    
    result = []
    queue = collections.deque()##使用双端队列
    queue.append(root) ##加到双端队列的右边
    
    # visited =set(root)
     while queue:
            level_size = len(queue)
            current_level =[]
            
            for _ in range(level_size):
                node = queue.popleft() ## 右边进 左边出
                current_level.append(node.val)
                if node.left:queue.append(node.left)
                if node.right:queue.append(node.right)
            result.append(current_level)
    return result

方法2 使用深度优先

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def levelOrder(self, root: 'TreeNode') -> 'List[List[int]]':
        if not root:
            return []
        self.result=[]##二维列表[[]]第一层记录的是二叉树中的层数 第二层记录的是数
        self.dfs(root,0)
        return self.result
    def dfs(self,root,level):
        if not root:return []
        if len(self.result)<level+1:
            self.result.append([])
        self.result[level].append(root.val)
        self.dfs(root.left,level+1)
        self.dfs(root.right,level+1)
        

题目 所有括号问题

使用深度优先的思想 并使用了剪枝策略 给定N 那么会有2*n的位置 一半是左括号 一半是右括号 使用深度优先搜索

class Solution:
    def generateParenthesis(self, n: 'int') -> 'List[str]':
        self.result=[]
        self._gen(0,0,n,"")
        return self.result
    def _gen(self,left,right,n,result):
        if n<=0:
            return result
        if left==n and right==n:
            self.result.append(result)
            return
        if left<n:
            self._gen(left+1,right,n,result+'(')
        if right<n and right<left:
            self._gen(left,right+1,n,result+')')