阶段总结-树与递归

最新推荐文章于 2024-06-15 23:36:03 发布

ListenYin

最新推荐文章于 2024-06-15 23:36:03 发布

阅读量32

点赞数

文章标签：算法

本文链接：https://blog.csdn.net/qq_41662142/article/details/132433785

版权

阶段总结-树与递归

树基础

树的相关概念

度：节点个数，节点的度，树的度
叶子结点：没有子节点，度为0
无序树：节点没有顺序关关系
有序树：节点有顺序关系
二叉树：树的度为2
树的深度：

树的定义

两种定义形式：链表定义和数组定义

二叉树的定义


class TreeNode:
    def __init(val, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

N叉树的定义


class Node:
    def __init__(self, val, children=None)：
        self.val = val
        self.children = children

树的遍历

分为深度优先遍历和广度优先遍历

其中深度优先遍历又分为前序、中序、后序三种

树的深度优先遍历

分为前序、中序、后序三种

前序遍历：中左右
中序遍历：左中右
后序遍历：左右中

通过前中后序遍历恢复二叉树

两种情况：

通过前序遍历和中序遍历恢复二叉树
通过后序遍历和中序遍历恢复二叉树

记住前中后序遍历的特点
前序：中左右
中序：左中右
后序：左右中

通过递归实现二叉树的前中后序遍历

熟练掌握一个即可，其他类似；以前序遍历为例，掌握其核心算法

# 递归实现二叉树前序遍历
def pre_order(root, res):
    if not root:
        return
    res.add(root.val)
    pre_order(root.left, res)
    pre_order(root.right, res)

通过迭代实现二叉树的前中后序遍历

前中后序遍历不太一样，需要熟记

前序遍历

def pre_order(root):
    if not root:
        return
    res = []
    stack = []
    node = root
    while node or stack:
        while node:
            res.append(node.val)
            stack.append(node)
            node = node.left
        node = stack.pop()
        node = node.right
    return res

中序遍历

def in_order(root):
    if not root:
        return
    res = []
    stack = []
    node = root
    while node or stack:
        while node:
            stack.append(node)
            node = node.left
        node = stack.pop()
        res.append(node.val)
        node = node.right
    return res

后序遍历

翻转法：观察可以发现，将后续遍历反转过来后，跟前序遍历有点类似，只不过逻辑变成了中右左，参考前序遍历的实现逻辑改造下，再将结果翻转，就可以获得后序遍历的结果

def post_order(root):
    if not root:
        return
    res = []
    stack = []
    node = root
    while node or stack:
        while node:
            res.append(node.val)
            stack.append(node)
            node = node.right
        node = stack.pop()
        node = node.left
    return reversed(res)

深度优先经典算法题

二叉树中双指针

经典题目：

判断两棵树是否相同
对称二叉树
合并二叉树

路径专题

经典题目：

二叉树的所有路径
路径总和

翻转妙用

经典题目：
翻转二叉树

二叉树的深度和高度问题

经典题目

最大深度问题
判断平衡树
最小深度
N叉树的最大深度

公共祖先问题

经典题目
寻找最近公共祖先

树的广度优先遍历（层次遍历）

层次遍历的核心算法

二叉树的层序遍历，按层返回节点值，借助队列实现

重要：掌握核心算法，其他题目多为在核心算法上变化衍生得到解决方法

#!/usr/bin/python
# -*- coding: utf-8 -*-
# @Time : 2023/8/22 4:16 下午
# @Author : ListenYin
# @Email : yls060912@163.com
# @File : 层序遍历核心算法.py
# @Project : yupisufancun
import collections


class TreeNode:
    def __init__(self, val, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


def level_order(root):
    if not root:
        return []
    res = []
    queue = collections.deque([root])

    while queue:
        tmp = []
        n = len(queue)
        for i in range(n):
            node = queue.popleft()
            tmp.append(node)
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)

        res.append(tmp)

    return res


def init_tree():
    tree_node3 = TreeNode(3)
    tree_node9 = TreeNode(9)
    tree_node20 = TreeNode(20)
    tree_node15 = TreeNode(15)
    tree_node7 = TreeNode(7)

    tree_node3.left = tree_node9
    tree_node3.right = tree_node20
    tree_node20.left = tree_node15
    tree_node20.right = tree_node7
    return tree_node3


if __name__ == '__main__':
    level_node_list = (level_order(init_tree()))
    for i in level_node_list:
        print([j.val for j in i])

题目衍生：遍历变化

此类题目有：自底向上遍历，锯齿形层序遍历，N叉树层序遍历

题目衍生：每层元素处理

此类题目有：在每个树行中找最大值，在每个树行中找平均值，二叉树右视图，最底层最左边

递归基础

递归的特征

所有的递归有两个基本的特征

执行范围不断缩小
终止条件判断在递归调用的前面

如何写递归

四步法：

从大到小递推
分情况讨论，明确结束条件
组合出完整方法
验证，画图推演（ToDo待完善确认）

分治思想

分治法/分治思想
即分而治之，把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题…直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。
注：分治是很多高效算法的基础，如二分查找、排序算法（快速排序、归并排序）等

二分查找

基本二分查找

循环方式


def binary_search(array, low, high, target):
    while low <= high:
        mid = (low + high) // 2
        if array[mid] == target:
            return mid
        elif array[mid] > target:
            high = mid - 1
        else:
            low = mid + 1
    return -1

递归方式


def binary_search(array, low, high, target):
    if low > high:
        return -1
    mid = (low + high) // 2
    if array[mid] == target:
        return mid
    elif array[mid] > target:
        return binary_search(array, low, mid - 1, target)
    else:
        return binary_search(array, mid + 1, high, target)

有重复元素的二分查找

"""
题目：
有重复元素的二分查找，如果有重复元素则找左侧第一个
"""


def binary_search(nums, target):
    if not nums:
        return -1
    left = 0
    right = len(nums) - 1

    while left < right:
        mid = (left + right) // 2
        if nums[mid] < target:
            left = mid + 1
        elif nums[mid] == target:
            right = mid
        else:
            right = mid - 1
    return right if nums[right] == target else -1


if __name__ == '__main__':
    print(binary_search([], 4))  # -1
    print(binary_search([0, 1, 2, 3], 10))  # -1
    print(binary_search([0, 1, 2, 3], -10))  # -1

    print(binary_search([0, 1, 2, 3, 4, 5], 4))  # 4
    print(binary_search([0, 1, 2, 3, 3, 4, 5], 3))  # 3
    print(binary_search([0, 1, 2, 3, 3, 3, 4, 5], 3))  # 3
    print(binary_search([0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 5], 3))  # 3

二分查找与搜索树高频问题

中序遍历与二叉搜索的关系

基于二分查找的拓展问题

经典题目

山脉数组的峰顶索引
旋转数字的最小数字
找缺失数字
优化求平方根

中序遍历与搜索树

理解二叉搜索树的概念

若它的左子树不为空，则左子树上所有节点的值均小于它根节点的值
若它的右子树不为空，则右子树上所有节点的值均大于它根节点的值
它的左子树、右子树也分别为二叉排序树

经典题目

二叉搜索树中搜索特定值
验证二叉搜索树

快速排序与归并排序

快速排序

快速排序
快速排序核心：二叉树的前序遍历+对撞型双指针

def quick_sort(array, start, end):
    if start >= end:
        return

    pivot = array[(start + end) // 2]
    left, right = start, end
    while left < right:
        while array[left] < pivot:
            left += 1
        while array[right] > pivot:
            right -= 1
        if left <= right:
            array[left], array[right] = array[right], array[left]
            left += 1
            right -= 1
            
    quick_sort(array, start, right)
    quick_sort(array, left, end)

归并排序

归并排序原理
归并排序（merge-sort）简单来说就是将大的序列先视为若干个比较小的数组，分成几个比较小的结构，然后利用归并的思想实现的排序算法，该算法采用经典的分治策略

分：将问题分成一些小的问题分别求解
治：将分的阶段得到的各答案“合”在一起

#!/usr/bin/python
# -*- coding: utf-8 -*-
# @Time : 2023/8/22 10:58 上午
# @Author : ListenYin
# @Email : yls060912@163.com
# @File : 归并排序.py
# @Project : yupisufancun

def merge(left, right):
    ll, rr = 0, 0
    nums = []

    while ll < len(left) and rr < len(right):
        if left[ll] < right[rr]:
            nums.append(left[ll])
            ll += 1
        else:
            nums.append(right[rr])
            rr += 1

    nums += left[ll:]
    nums += right[rr:]
    return nums


def merge_sort(nums):
    if not nums or len(nums) <= 1:
        return nums
    index = (len(nums)) // 2  # 从中间划分两个子序列
    left = merge_sort(nums[:index])  # 对左侧子序列进行递归排序
    right = merge_sort(nums[index:])  # 对右侧子序列进行递归排序
    return merge(left, right)  # 归并


if __name__ == '__main__':
    test1 = [1, 3, 45, 23, 23, 12, 43, 45, 33, 21]
    print(merge_sort(test1))  # [1, 3, 12, 21, 23, 23, 33, 43, 45, 45]