课程笔记

最新推荐文章于 2024-10-12 13:59:20 发布
最新推荐文章于 2024-10-12 13:59:20 发布
阅读量388 收藏 1
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44867672/article/details/111464372
版权

文章目录

二叉排序树

一、性质

  1. 左子树 < 根节点
  2. 右子树 > 根节点
  3. 中序遍历的结果是一个有序序列

数据结构，就是定义一种性质并且维护这种性质。

二、插入操作

  1. 插入新的结点，一定会做做为叶子节点

三、删除操作

  1. 删除度为0的结点，直接删除
  2. 删除度为1的结点，把孤儿子树挂到其父节点上面
  3. 删除度为2的结点，可以转化成删除度为1的结点

对于度为2的结点：

  1. 前驱：左子树的最大值
  2. 后继：右子树的最小值

四、随堂练习

  1. 插入顺序会影响最终的树形结构
  2. 不同的树形结构，查找效率不同

平均查找效率：结点查找次数的期望值， 总 次 数 结 点 数 量 \frac{总次数}{结点数量} 结点数量总次数​，假设每个结点都被等概率查找。

五、扩展内容

  1. 二叉排序树删除代码优化

    1. 删除掉处理度为0的代码逻辑，不影响代码整体功能

  2. 如何解决排名相关排名相关的检索需求

      1. 修改二叉排序树的结构定义，增加 size 字段，记录每棵树的节点数量
      2. k = L S − 1 k = LS - 1 k=LS−1，根节点就是排名第 k 位的元素
      3. k ≤ L S k \le LS k≤LS，排名第 k 位的元素在左子树中
      4. k > L S ， s e a r c h k ( r o o t − > r c h i l d , k − L S − 1 ) k \gt LS，search_k(root->rchild, k - LS - 1) k>LS，searchk​(root−>rchild,k−LS−1)
    2. 解决 Top-K 问题（找到小于第 k 位的所有元素）
      1. 根节点就是第 k 位元素的话，就把左子树中的值全部输出出来
      2. 第 k 位在左子树中，前 k 位元素全都在左子树中
      3. 第 k 位在右子树中，说明根节点和左子树中的元素，都是前 k 位元素里面的值
    3. 二叉排序树和快速排序的关系
      1. 二叉排序树是快速排序在思维逻辑结构层面用的数据结构
      2. 思考1：快速排序的时间复杂度和二叉排序树建树时间复杂度之间的关系
      3. 思考2：快速选择算法和二叉排序树之间的关系
      4. 程序=算法+数据结构

    所谓算法设计及分析能力：分类讨论及归纳总结的能力

六、代码演示

#include <stdio.h>
#include <stdlib.h>

#define KEY(n) (n ? n->key : -1)
#define SIZE(n) (n ? n->size : 0)
#define L(n) (n ? n->lchild : NULL)

typedef struct Node {
    int key, size;
    struct Node *lchild, *rchild;
} Node;

void update_size(Node *root);

Node *getNewNode(int key) {
    Node *p = (Node *)malloc(sizeof(Node));
    p->key = key;
    p->size = 1;
    p->lchild = p->rchild = NULL;
    return p;
}

int search(Node *root,int val) {
    if (!root) return 0;
    if (root->key == val) return 1;
    if (root->key > val) return search(root->lchild, val);
    return search(root->rchild, val);
}

Node *insert(Node *root, int key) {
    if (!root) return getNewNode(key);
    if (root->key == key) return root;
    if (key < root->key) root->lchild = insert(root->lchild, key);
    else root->rchild = insert(root->rchild, key);
    update_size(root);
    return root;
}

Node *predecessor(Node *root) {
    Node *temp = root->lchild;
    while (temp->rchild) temp = root->rchild;
    return temp;
}

int search_k(Node *root, int k) {
    if (!root) return -1;
    if (SIZE(L(root)) == k - 1) return root->key;
    if (k <= SIZE(L(root))) {
        return search_k(root->lchild, k);
    }
    return search_k(root->rchild, k - SIZE(L(root->lchild)) - 1);
}

void update_size(Node *root) {
    root->size = SIZE(root->lchild) + SIZE(root->rchild) + 1;
    return ;
}

Node *erase(Node *root, int key) {
    if (!root) return NULL;
    if (key < root->key) {
        root->lchild = erase(root->lchild, key);
    } else if (key > root->key) {
        root->rchild = erase(root->rchild, key);
    } else {
        /*if (root->lchild == NULL && root->rchild == NULL) {
        free(root);
        return NULL;
    } else */
        if (root->lchild == NULL || root->rchild == NULL) {
            Node *temp = root->lchild ? root->rchild : root->rchild;
            free(root);
            return temp;
        } else {
            Node *temp = predecessor(root);
            root->key = temp->key;
            root->lchild = erase(root->lchild, temp->key);
        }
    }
    update_size(root);
    return root;
}

void clear(Node *root) {
    if (!root) return ;
    clear(root->lchild);
    clear(root->rchild);
    free(root);
    return ;
}

void print(Node *root) {
    printf("%d[%d], %d, %d\n", KEY(root), SIZE(root),KEY(root->lchild), KEY(root->rchild));
    return ;
}

void output(Node *root) {
    if (!root) return ;
    output(root->lchild);
    print(root);
    output(root->rchild);
    return ;
}

void output_k(Node *root, int k) {
    if (k == 0 || !root) return ;
    if (k <= SIZE(L(root))) {
        output_k(root->lchild, k);
    } else {
        output(root->lchild);
        print(root);
        output_k(root->rchild, k - SIZE(L(root->lchild)) - 1);
    }
    return ;
}

int main() {
    int op, val;
    Node *root = NULL;
    while (~scanf("%d%d", &op, &val)) {
        switch (op) {
            case 0: printf("search %d, result : %d\n", val, search(root, val)); break;
            case 1: root = insert(root, val); break;
            case 2: root = erase(root, val); break;
            case 3: {
                printf("search k = %d, result : %d\n", val, search_k(root, val));
                output_k(root, val);
                printf("----------\n");
            } break;
            case 4: {
                printf("output top-%d elements\n", val);
                output_k(root, val);
                printf("----------\n");
            } break;
        }
        if (op == 1 || op == 2) {
            output(root);
            printf("------------\n");
        }
    }
    return 0;
}

平衡二叉树排序树 之 AVL 树

一、学习重点

  1. 平衡二叉树排序树，本质上也是二叉排序树，所以拥有二叉排序树的所有性质
  2. 平衡二叉树排序树的学习重点，在于平衡条件以及平衡调整的相关学习

二、性质

  1. 平衡条件：左右子树高度差不超过 1

三、课中思考

  1. AVL 树改进的是节点数量的下限
  2. 树高 = 生命长度，节点数量 = 生命财富，不同的算法，达到的结果是不同的
  3. 教育提升的是底限，而不是上限，上限取决于能力和运气

思考：

  1. 高度为 Ｈ 的BS树，所包含的结点数量在上面范围之内?
  2. 高度为H的AVL树，所包含的结点数量在上面范围之内?

BS树： H ≤ H\le H≤SIZE ≤ 2 H − 1 \le2^H-1 ≤2H−1

AVL树：设low(H)为高度为H的树最少包含结点，则 l o w ( H − 2 ) + l o w ( H − 1 ) + 1 ≤ S I Z E ≤ 2 H − 1 low(H - 2) + low(H - 1) + 1 \le SIZE \le 2^H - 1 low(H−2)+low(H−1)+1≤SIZE≤2H−1， 设结点数为n，树高为h，则有 h = log ⁡ a ( n ) h=\log_a(n) h=loga​(n)， 1.5 ≤ a ≤ 2 1.5\le a \le 2 1.5≤a≤2

四、平衡调整策略

基本操作：

  1. 左旋：要旋转的结点K1的右节点K3成为新的根节点，原K3的左子树称为K1的右子树

  2. 右旋：要旋转的结点K1的左节点K2成为新的根节点，原K2的右子树称为K1的左子树

  1. 发生在回溯阶段的，第一个失衡节点处

  2. 理解平衡调整策略的关键在于：分析清楚四种情况下，ABCD 四棵子树树高的关系

  3. LL，大右旋

    设A、B、C、D的树高分别为 h 1 h_1 h1​、 h 2 h_2 h2​、 h 3 h_3 h3​、 h 4 h_4 h4​，则存在以下关系：

    h 1 + 1 = m a x ( h 3 , h 4 ) + 3 → h 1 = m a x ( h 3 , h 4 ) + 2 = h 2 + 1 h_1 + 1 = max(h_3, h_4) + 3\rightarrow h_1 = max(h_3, h_4) + 2 = h_2 + 1 h1​+1=max(h3​,h4​)+3→h1​=max(h3​,h4​)+2=h2​+1

    则调整后：

    A和K1， B和K3高度相等

  4. LR，先小左旋，再大右旋

    image-20201220220158253

    m a x ( h 2 , h 3 ) = h 4 = h 1 max(h_2, h_3) = h_4 = h_1 max(h2​,h3​)=h4​=h1​

  5. RL，先小右旋，再大左旋

  6. RR，大左旋

五、代码演示

  1. 插入和删除以后，注意重新计算树高字段
  2. 引入了 NIL 阶段，代替 NULL，NULL 不可访问，NIL 是一个是实际节点，可访问
#include <iostream>
#include <cstdio>
#include <stdlib.h>

#define L(n) (n->lchild)
#define R(n) (n->rchild)
#define H(n) (n->h)

typedef struct Node {
    int key, h;
    struct Node *lchild, *rchild;
} Node;

Node __NIL;
#define NIL (&__NIL)
__attribute__((constructor))
void init_NIL() {
    NIL->key = 0, NIL->h = 0;
    NIL->lchild = NIL->rchild = NIL;
    return ;
}

void update_high(Node *root);

Node *getNewNode(int key) {
    Node *p = (Node *)malloc(sizeof(Node));
    p->key = key;
    p->h = 1;
    p->lchild = p->rchild = NIL;
    return p;
}

void clear(Node *root) {
    if (root == NIL) return ;
    clear(root->lchild);
    clear(root->rchild);
    free(root);
    return ;
}

Node *left_rotate(Node *root) {
    Node *temp = root->rchild;
    root->rchild = temp->lchild;
    temp->lchild = root;
    update_high(root);
    update_high(temp);
    return temp;
}

Node *right_rotate(Node *root) {
    Node *temp = root->lchild;
    root->lchild = temp->rchild;
    temp->rchild = root;
    update_high(root);
    update_high(temp);
    return temp;
}

Node *maintain(Node *root) {
    if (abs(H(L(root)) - H(R(root))) <= 1) return root;
    if (root->lchild->h > root->rchild->h) {
        if (root->lchild->lchild->h < root->lchild->rchild->h) {
            root->lchild = left_rotate(root->lchild);
        }
        root = right_rotate(root);
    } else {
        if (root->rchild->rchild->h < root->rchild->lchild->h) {
            root->rchild = right_rotate(root->rchild);
        }
        root = left_rotate(root);
    }
    return root;
}

void update_high(Node *root) {
    root->h = (H(L(root)) > H(R(root)) ? H(L(root)) : H(R(root))) + 1;
}

void print(Node *root) {
    printf("%d[%d], %d, %d\n", root->key, root->h, root->lchild->key, root->rchild->key);
    return ;
}

void output(Node *root) {
    if (root == NIL) return ;
    print(root);
    output(root->lchild);
    output(root->rchild);
    return ;
}

Node *insert(Node *root, int key) {
    if (root == NIL) return getNewNode(key);
    if (root->key == key) return root;
    if (root->key > key) {
        root->lchild = insert(root->lchild, key);
    } else {
        root->rchild = insert(root->rchild, key);
    }
    update_high(root);
    return maintain(root);
}

Node *predecessor(Node *root) {
    Node *temp = root->lchild;
    while (temp->rchild) temp = temp->rchild;
    return temp;
}

Node *erase(Node *root, int key) {
    if (root == NIL) return NIL;
    if (key < root->key) {
        root->lchild = erase(root->lchild, key);
    } else if (root->key < key) {
        root->rchild = erase(root->rchild, key);
    } else {
        if (root->lchild == NIL || root->rchild == NIL) {
            Node *temp = root->lchild ? root->lchild : root->rchild;
            free(root);
            return temp;
        } else {
            Node *temp = predecessor(root);
            root->key = temp->key;
            root->lchild = erase(root->lchild, temp->key);
        }
    }
    update_high(root);
    return maintain(root);
}

int main() {
    int op, val;
    Node *root = NIL;
    while (~scanf("%d%d", &op, &val)) {
        switch (op) {
            case 0: root = erase(root, val);
            case 1: root = insert(root, val);
        }
        output(root);
        printf("--------\n");
    }
    return 0;
}

扩展小tips

vim按列添加和删除：

  1. 按列添加，首先按ctrl + V，接下来用箭头键选中列，再按shift + I，输出要添加的内容，再按ESC键。

    image-20201220222447050
    image-20201220222533087

  2. 按列删除，首先按ctrl + V，接下来用箭头键选中列，再按x即可删除选择列的内容。

肥磊
关注
acwing算法基础课笔记
m0_61542284的博客
09-09 6037
第一章 基础算法（一）： 一、快速排序： 1.确定区间中的某一点，如a[l],a[r],a[(l+r)/2]等等， 2.将数组分为左右两边，左边全为比分界点小的数，右边全为比分界点大的数， 代码实现： void quick_sort(int q[],int l,int r) { if(l>=r) return 0;//meiyoushu int i=l-1,j=r+1; int x=q[l]; while(i<j) { do i++; wh
《黑马程序员C++》课程笔记总结
热门推荐
半生瓜のblog
08-14 16万+
我的小站——半生瓜のblog 黑马程序员C++视频——黑马程序员匠心之作|C++教程从0到1入门编程,学习编程不再难 笔记列表&对应视频 基础部分(1-83)——如果你准备学习C++,并且有C语言的基础，我希望你能简单的过一遍知识点。 核心部分(84-146)——C++核心编程部分-内存分区模型-引用-函数提高-类与对象-文件操作 案例1(147-166)——职工管理系统——C++实现职工管理系统 进阶部分(167-263)——C++提高编程部分-泛型编程-STL 案例2(264-281)—.
刘知远团队大模型公开课笔记汇总【持续更新中】
m0_52784465的博客
04-23 447
清华大学大模型公开课
YOLO课程笔记
m0_49534117的博客
10-04 716
认为当前框要预测的为真实框，所以希望该框置信度为1（但是因为有IOU的差别，所以其实希望它的置新度为IOU）如果一个真实框和多个候选框重合，之选IOU最大的作为前景，其他的为背景，希望它们的置信度为0（也就是按照不含物体的置信度误差考虑）。1.训练：对于一个框，会生成两个候选框，候选框中通过与真实值IOU,找最大，对最大的候选框选定（要的框），来作微调（回归x,y,h,w）6.框多了，MAP不一定好，因为你不能保证每个框都是好的框，都是符合原始物体形状的框，但是识别率确实提高了。1.多尺度：术业有专攻。
网络安全课程笔记
weixin_51406400的博客
06-29 163
我们学校在暑假期间开设了10天的网络安全的课程，同时也要求我们每一天都要做笔记，记录自己的学习情况，我这里还是利用思维导图去记录自己的笔记。在这里分享一下，希望对你们有一些帮助。...
python课笔记
weizhou40的博客
12-30 425
狂神JavaWeb课程笔记
qq_41607196的博客
05-10 2385
笔记注释 该笔记主要目的是接触和了解javaweb的基本概念，狂神的课程后面的项目没有细看，项目部分的笔记参考了网络的一些帖子。 值得一提 的是本人在学习javaweb时用的是idea社区版，在一些部分和狂神课程中的操作不同，解决了一些版本不同存在的坑，一些操作差异本文也都给出了演示，并且实现了相同的功能。 本笔记主要为了记录自己的学习文档，存在很多不足，也欢迎大家一起交流，但是新手起步，清温柔以待。 1.web的基本概念 1.1前言 web开发： web，网页的意思 静态web html、css
【笔记】李宏毅机器学习与深度学习课程笔记——神奇宝贝分类 案列讲解入门
m0_46103905的博客
04-22 673
上一节课讲的是预测，这节课讲的是分类。主要是拿神奇宝贝的分类举例子，通过这节课，了解了高斯分布在机器学习中的应用、了解了升维的操作以及减少参数以减少误差的trick。
专升本计算机基础课程笔记汇总
LYQ_YXQ的博客
07-26 1120
本文用于本人专升本计算机基础课程笔记汇总
测试课程笔记2
m0_64288612的博客
06-22 151
测试笔记。
七下第16课笔记.zip
07-08
标题中的“七下第16课笔记.zip”表明这是一个与初中第七学期（通常指的是初一下学期）第16课相关的学习资料压缩包。这通常涵盖了某个特定学科的课程重点、难点解析、课后习题解答或者是老师的讲义等内容。由于是...
狂神笔记，b站狂神说课程笔记大全(最新)
09-19
b站狂神说课程笔记大全，每个部分都有 狂神说java系列笔记（java基础+javaweb+ssm+微服务）全套 狂神说上课笔记未删减 Java基础到技术升级 1、JavaSE：Java入门 2、JavaSE：基础语法 3、JavaSE：流程控制 4、JavaSE...
超详细MIT线性代数公开课笔记-完整版
03-29
本次课程笔记所涉及的线性代数的知识点主要包括以下几个方面： 1. 线性方程组的矩阵表示：线性代数的基本问题之一是解决n元一次方程组。一个n元一次方程组可以表示为矩阵形式Ax=b，其中A是系数矩阵，x是未知数向量...
《江西家长在线》第二课笔记 --“家庭教育成功与失败的教育反思”.pdf
10-31
《江西家长在线》第二课笔记 --“家庭教育成功与失败的教育反思”.pdf
TL学院诸葛老师JVM架构师课程笔记.zip
05-20
TL学院诸葛老师JVM架构师课程笔记TL学院诸葛老师JVM架构师课程笔记TL学院诸葛老师JVM架构师课程笔记TL学院诸葛老师JVM架构师课程笔记TL学院诸葛老师JVM架构师课程笔记TL学院诸葛老师JVM架构师课程笔记TL学院诸葛老师...
【数据结构-栈】【贪心】力扣2434. 使用机器人打印字典序最小的字符串
sjsjs11的博客
10-12 284
我们可以思考，将t想象成一个栈，先进后出，然后当栈顶元素的值，也就是t的末尾的值比字符串s中的任何一个字符都要小的时候，那么我们就要将栈顶元素推入p中，也就是写出来的字符串，这样才能保证最小字典序列。，由于0代表a，1代表b…执行第一个操作四次，得到 p=“” ，s=“” ，t=“bdda”。执行第一个操作三次，得到 p=“” ，s=“” ，t=“zza”。执行第一个操作，得到 p=“ab” ，s=“” ，t=“c”。执行第二个操作，得到 p=“abc” ，s=“” ，t=“”。
Java：数据结构-ArrayList和顺序表（2）
blamep的博客
10-09 705
创建一个空的ArrayList，指定容量为initialCapacity。
数据结构编程实践20讲(Python版)—09B树
最新发布
AnFany
10-12 710
数据结构编程实践20讲(Python版)—09B树
（JAVA）浅入数据结构 “堆” - 实现和理论
拔高、提升、创新！
10-09 541
在树结构上做出一部分改变的堆结构，是如何实现的呢？强烈建议初学者来看一看噢~！
langchain 课程笔记
08-17
您可以在以下地址找到langchain的课程笔记：https://learn.deeplearning.ai/langchain-chat-with-your-data/lesson/1/introduction [1。在开始之前，您需要创建一个名为langchain的虚拟环境，并安装langchain和open...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值