算法训练营 查找算法（二叉查找树）

已于 2022-03-14 15:59:07 修改
阅读量1.2k 收藏 4
点赞数 1
文章标签： 算法 b树 数据结构
于 2022-03-13 15:51:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_20144897/article/details/123457470
版权

二叉查找树

原理

  • 二叉查找树，又叫作二叉搜索树、二叉排序树，是一种对查找和排序都有用的特殊二叉树
  • 二叉查找树或是空树，或是满足如下性质的二叉树：
    ①若其左子树非空，则左子树上所有节点的值均小于根节点的值；
    ②若其右子树非空，则右子树上所有忽而短板的值均大于根节点的值；
    ③其左右子树本身各是一棵二叉查找树。
  • 二叉查找树的特性：左子树<根<右子树，即二叉查找树的中序遍历是一个递增序列。

二叉查找树的查找

  • 因为二叉查找树的中序遍历有序性，所以查找与二分查找类似，每次都缩小查找范围，查找效率较高
算法设计
  1. 若二叉查找树为空，查找失败，则返回空指针
  2. 若二叉查找树非空，则将待查找关键字x与根节点的关键字T->data进行比较。
  • 若x == T->data，查找成功，则返回T
  • 若x < T->data，则递归查找左子树
  • 若x < T->data，则递归查找右子树

二叉树的插入

  • 因为二叉查找树的中序遍历存在有序性，所以首先要查找待插入关键字的插入位置，当查找不成功时，再将待插入关键字作为新的叶子节点称为最优一个查找节点的左孩子或右孩子
算法设计
  1. 若二叉查找树为空，则创建一个新的节点s，将待插入关键字放入新节点的数据域，将s节点作为根结点，左右子树均为空。
  2. 若二叉查找树非空，则将待查找关键字x与根结点的关键字T->data进行比较。
  • 若x<T->data，则将x插入左子树中
  • 若x>T->data，则将x插入右子树中

二叉查找树的创建

  • 二叉查找树的创建可以从空树开始，按照输入关键字的顺序依次进行插入操作，最终得到一颗二叉查找树。
算法设计
  1. 初始化二叉查找树为空树，T = NULL；
  2. 输入一个关键字x，将x插入二叉查找树T中；
  3. 重复步骤2，直到关键字输入完毕

二叉查找树的删除

  • 首先要在二叉查找树中找到待删除节点，然后执行删除操作。假设指针p指向待删除节点，指针f指向p的双亲节点。根据待删除节点所在位置的不同，删除操作的处理方法也不同，可以分为下面三种情况。
  1. 被删除节点的左子树为空，如果被删除节点的左子树为空，则令其右子树子承父业代替其位置即可。
  2. 被删除节点的右子树为空。如果被删除节点的右子树为空，则令其左子树子承父业代替其位置即可。
  3. 被删除节点的左右子树均不为空。根据二叉查找树的中序有序性，删除该节点时，可以用其直接前驱（或直接后继）代替其位置，然后删除其直接前驱（或直接后继）即可。
算法设计
  1. 在二叉查找树中查找待删除关键字的位置，p指向待删除节点，f指向p的双亲节点，如果查找失败，则返回。
  2. 如果查找成功，则分三种情况进行删除操作。
  • 如果被删除节点的左子树为空，则令其右子树子承父业代替其位置即可。
  • 如果被删除节点的右子树为空，则令其左子树子承父业代替其位置即可。
  • 如果被删除节点的左右子树均不为空，则令其直接前驱（或者直接后继）代替它，再删除其直接前驱（或直接后继）

算法实现

#include<iostream>
using namespace std;
#define ENDFLAG -1
typedef int ElemType;
typedef struct BSTNode{
    ElemType data;	//结点数据域
    BSTNode *lchild,*rchild;	//左右孩子指针
}BSTNode,*BSTree;
BSTree SearchBST(BSTree T,ElemType key); //二叉排序树的递归查找
void InsertBST(BSTree &T,ElemType e); //二叉排序树的插入
void CreateBST(BSTree &T ); //二叉排序树的创建
void DeleteBST(BSTree &T,char key);
void InOrderTraverse(BSTree &T);//中序遍历
int main()
{
    BSTree T;
    cout<<"请输入一些整型数，-1结束"<<endl;
    CreateBST(T);
    cout<<"当前有序二叉树中序遍历结果为"<<endl;
    InOrderTraverse(T);
    cout<<endl;
    ElemType key;//待查找或待删除内容
    cout<<"请输入待查找关键字"<<endl;
    cin>>key;
    BSTree result=SearchBST(T,key);
    if(result)
        cout<<"找到"<<key<<endl;
    else
        cout<<"未找到"<<key<<endl;
    cout<<"请输入待删除关键字"<<endl;
    cin>>key;
    DeleteBST(T,key);
    cout<<"当前有序二叉树中序遍历结果为"<<endl;
    InOrderTraverse(T);
    return 0;
}

BSTree SearchBST(BSTree T,ElemType key){
    //若查找成功，则返回指向该数据元素结点的指针，否则返回空指针
    if((!T)|| key==T->data)
        return T;
    else if (key<T->data)
        return SearchBST(T->lchild,key);//在左子树中继续查找
    else
        return SearchBST(T->rchild,key); //在右子树中继续查找
}

void InsertBST(BSTree &T,ElemType e){
    //当二叉排序树T中不存在关键字等于e的数据元素时，则插入该元素
    if(!T)
    {
        BSTree S=new BSTNode; //生成新结点
        S->data=e;             //新结点S的数据域置为e
        S->lchild=S->rchild=NULL;//新结点S作为叶子结点
        T=S;            		//把新结点S链接到已找到的插入位置
    }
    else if(e<T->data)
        InsertBST(T->lchild,e );//插入左子树
    else if(e>T->data)
        InsertBST(T->rchild,e);//插入右子树
}

void CreateBST(BSTree &T ){
    //依次读入一个关键字为key的结点，将此结点插入二叉排序树T中
    T=NULL;
    ElemType e;
    cin>>e;
    while(e!=ENDFLAG)//ENDFLAG为自定义常量，作为输入结束标志
    {
        InsertBST(T,e);  //插入二叉排序树T中
        cin>>e;
    }
}

void DeleteBST(BSTree &T,char key){
    //从二叉排序树T中删除关键字等于key的结点
    BSTree p=T;BSTree f=NULL;
    BSTree q;
    BSTree s;
    if(!T) return; //树为空则返回
    while(p)//查找
    {
        if(p->data==key) break;  //找到关键字等于key的结点p，结束循环
        f=p;                //f为p的双亲
        if (p->data>key)
            p=p->lchild; //在p的左子树中继续查找
        else
            p=p->rchild; //在p的右子树中继续查找
    }
    if(!p) return; //找不到被删结点则返回
    //三种情况：p左右子树均不空、无右子树、无左子树
    if((p->lchild)&&(p->rchild))//被删结点p左右子树均不空
    {
        q=p;
        s=p->lchild;
        while(s->rchild)//在p的左子树中继续查找其前驱结点，即最右下结点
        {
            q=s;
            s=s->rchild;
        }
        p->data=s->data;  //s的值赋值给被删结点p,然后删除s结点
        if(q!=p)
            q->rchild=s->lchild; //重接q的右子树
        else
            q->lchild=s->lchild; //重接q的左子树
        delete s;
    }
    else
    {
        if(!p->rchild)//被删结点p无右子树，只需重接其左子树
        {
            q=p;
            p=p->lchild;
        }
        else if(!p->lchild)//被删结点p无左子树，只需重接其右子树
        {
            q=p;
            p=p->rchild;
        }
        /*――――――――――将p所指的子树挂接到其双亲结点f相应的位置――――――――*/
        if(!f)
            T=p;  //被删结点为根结点
        else if(q==f->lchild)
            f->lchild=p; //挂接到f的左子树位置
        else
            f->rchild=p;//挂接到f的右子树位置
        delete q;
    }
}

void InOrderTraverse(BSTree &T){
    if(T)
    {
        InOrderTraverse(T->lchild);
        cout<<T->data<<"\t";
        InOrderTraverse(T->rchild);
    }
}

输入与输出：

请输入一些整型数，-1结束
35 98 65 44 34 87 98 -1
当前有序二叉树中序遍历结果为
34      35      44      65      87      98
请输入待查找关键字
44
找到44
请输入待删除关键字
87
当前有序二叉树中序遍历结果为
34      35      44      65      98

训练1：落叶

题目描述

给定一个字母二叉搜索树的树叶删除序列，输出树的先序遍历。

输入：输入包含多个测试用例。每个测试用例都是一行或多行大写字母序列，每行都给出按上述描述步骤从二叉搜索树中删除的树叶，每行给出的字母都按字母升序排列。在测试用例之间以一行分隔，该行仅包含一个星号“*”。在最后一个测试用例后给出一行，该行仅给出一个符号“$”。在输入中没有空格或空行。

输出：对于每个测试用例，都有唯一的二叉搜索树，单行输出该树的先序遍历。

算法设计

  • 最后一个字母一定为树根，先输入的字母在树的深层，可以逆序建树。
  • 读入字母序列后用字符串存储，然后逆序创建二叉搜索树；
  • 将小的字母插入左子树中，将大的字母插入右子树中。输出该数的先序遍历序列：根、左子树、右子树。

算法实现

#include<iostream>
#include<cstring>
#include<string>
using namespace std;
struct data{ //树结构
    int l,r;
    char c;
}tree[110];
int cnt=1;
void insert(int t,char ch); //在二叉搜索树中插入字符ch
void preorder(int t); //先序遍历
int main(){
    string s1,s;
    while(1){
        s="";
        memset(tree,0,sizeof(tree)); //初始化树
        while(cin>>s1&&s1[0]!='*'&&s1[0]!='$')
			s+=s1;
        for(int i=s.length()-1;i>=0;i--)
        	insert(1,s[i]);
        preorder(1);
        cout<<endl;
        if(s1[0]=='$')
			break;
    }
}
void insert(int t,char ch){
    if(!tree[t].c){
        tree[t].c=ch;
        return;
    }
    if(ch<tree[t].c){
        if(!tree[t].l){
            tree[++cnt].c=ch;
            tree[t].l=cnt;
        }
        else
            insert(tree[t].l,ch);
    }
    if(ch>tree[t].c){
        if(!tree[t].r){
            tree[++cnt].c=ch;
            tree[t].r=cnt;
        }
        else
            insert(tree[t].r,ch);
    }
}

void preorder(int t){
    if(!tree[t].c)
        return;
    cout<<tree[t].c;
    preorder(tree[t].l);
    preorder(tree[t].r);
}

输入：

BDHPY
CM
GQ
K
*
AC
B
$

输出：

KGCBDHQMPY

训练2：完全二叉搜索树

题目描述

有一颗无限的完全二叉树，节点中的数字是1,2,3,…如下图所示。在根节点为X的子树中，可以从左侧节点向下，直到最后一级获得该子树中的最小数，也可以从右侧节点向下找到该子树中的最大数。求解X的子树中的最小数和最大数是多少。

输入：第1行包含一个整数 N N N，表示查询的数量。在接下来的 N N N行中，每行都包含一个数字，表示根号位 X X X的子树（ 1 ≤ X ≤ 2 31 − 1 1 \leq X \leq 2^{31}-1 1≤X≤231−1）

输出：共 N N N行，其中第 i i i行包含第 i i i个查询的答案

算法设计

  • 有规律可循，若 n n n为奇数，那么必然是叶子节点，最大数和最小数都是它自己，否则求 n n n所在的层数（倒数的层数，底层为0层），它的层数就是 n n n的二进制表示中从低位开始第1个1所处的位置i（最后一个非0位）。
  • 例如， 6 = ( 110 ) 2 6 = (110)_{2} 6=(110)2​，“110”从低位开始第1个“1”的位置为1，因此6在第1层： 12 = ( 1100 ) 2 12 = (1100)_{2} 12=(1100)2​，“1100”从低位开始第1个“1”的位置为2，因此12在第2层
  1. 求解lowbit(n) = n & (-n)
  2. 令k = lowbit(n)-1，输出最小数n-k，最大数n+k。

算法实现

#include<iostream>
using namespace std;

int lowbit(int n){
	return n&(-n);
}

int main(){
	int T,n,k;
	cin>>T;
	while(T--){
		cin>>n;
		k=lowbit(n)-1;
		cout<<n-k<<" "<<n+k<<endl;
	}
	return 0;
}

输入：

2
8
10

输出：

1 15
9 11

训练3：硬木种类

题目描述

某国有数百种硬木树种，该国自然资源部利用卫星成像技术编译了一份特定日期每棵树的物种清单。计算每个物种占所有种群的百分比

输入：输入包括没课树的物种清单，每行一棵树。物种名称不超过30个字符，卜曹刚1000000棵树。

输出：按字母顺序输出植物种群中代表的每个物种的名称，然后是占所有种群的百分比，保留小数点后4位。

算法设计

  1. 使用二叉搜索树，先将每个单词都存入二叉树中，没出现一次就修改该单词所在节点cnt++；最后通过中序遍历输出结果
  2. 排序后统计，并输出结果

算法实现

#include<iostream>
#include<cstdio>
#include<string>
#include<algorithm>
using namespace std;
int sum=0;
typedef struct node{
    string word;
    struct node *l,*r;
    int cnt;
}*nodeptr;
nodeptr rt;
string w;
void insertBST(nodeptr &root,string s); //将字符串s插入到二叉搜索树root中
void midprint(nodeptr root); //中序遍历
int main(){
    rt=NULL;//一定要初始化
    while(getline(cin,w)){//输入完回车，按ctrl+z，回车
        insertBST(rt,w);
        sum++;
    }
    midprint(rt);
    return 0;
}
void insertBST(nodeptr &root,string s){//将字符串s插入到二叉搜索树root中
    if(root==NULL){
        nodeptr p=new node;
        p->l=p->r=NULL;
        p->cnt=1;
        p->word=s;
        root=p;
    }
    else if(s==root->word)
        root->cnt++;
    else if(s<root->word)
        insertBST(root->l,s);
    else
        insertBST(root->r,s);
}

void midprint(nodeptr root){//中序遍历
    if(root!=NULL){
        midprint(root->l);
        cout<<root->word;
        printf(" %.4lf\n",((double)root->cnt/(double)sum)*100);
        midprint(root->r);
    }
}

输入：

Red Alder
Ash
Aspen
Basswood
Ash
Beech
Yellow Birch
Ash
Cherry
Cottonwood
Ash
Cypress
Red Elm
Gum
Hackberry
White Oak
Hickory
Pecan
Hard Maple
White Oak
Soft Maple
Red Oak
Red Oak
White Oak
Poplan
Sassafras
Sycamore
Black Walnut
Willow
#

输出：

Ash 13.7931
Aspen 3.4483
Basswood 3.4483
Beech 3.4483
Black Walnut 3.4483
Cherry 3.4483
Cottonwood 3.4483
Cypress 3.4483
Gum 3.4483
Hackberry 3.4483
Hard Maple 3.4483
Hickory 3.4483
Pecan 3.4483
Poplan 3.4483
Red Alder 3.4483
Red Elm 3.4483
Red Oak 6.8966
Sassafras 3.4483
Soft Maple 3.4483
Sycamore 3.4483
White Oak 10.3448
Willow 3.4483
Yellow Birch 3.4483

训练4：二叉搜索树

题目描述

判断两个序列是否为同一个二叉搜索树序列

输入：第1行包含一个数n（1 \leq n \leq 20），表示有n个序列需要判断，在n = 0时输入结束。接下来的一行是一个序列，序列长度小于10，包含0~9的数字，没有重复的数字，根据这个序列可以构造出一颗二叉搜索树。再接下来的n行有n个序列，每个序列的格式都跟第1个序列一样，请判断这两个序列能否组成同一颗二叉树。

输出：如果序列相同，则输出“YES”，否则输出“NO”

算法设计

  • 可以先通过判断二叉搜索树的先序遍历序列是否相同来输出结果。
  • 因为根据二叉搜索树的中序有序性，先序遍历序列相同，中序遍历序列也一定相同。
  • 通过先序遍历序列和中序遍历序列可以唯一确定一颗二叉树
  1. 使用二叉搜索树，先将每个数字都存进二叉搜索树中，得到先序遍历；
  2. 将后面每一行的每个数字都存进二叉搜索树中，得到先序遍历，比较其是否相等，如果相等，则输出“YES”，否则输出“NO”。

算法实现

#include<cstdio>
#include<cstring>
using namespace std;
int cnt;
char a[15],b[15],c[15];
typedef struct node{
    int num;
    node *lc,*rc;
}*nodeptr;
nodeptr root;
void Insert(nodeptr &t,int x); //将x插入到二叉搜索树t中
void preorder(nodeptr t,char b[]); //中序遍历
int main(){
    int n;
    while(scanf("%d",&n),n){
        cnt=0;
        root=NULL;
        scanf("%s",a);
        for(int i=0;a[i]!='\0';i++)
            Insert(root,a[i]-'0');
        preorder(root,b);
        b[cnt]='\0';
        while(n--){
            cnt=0;
            root=NULL;
            scanf("%s",a);
            for(int i=0;a[i]!='\0';i++)
                Insert(root,a[i]-'0');
            preorder(root,c);
            c[cnt]='\0';
            if(strcmp(b,c)==0)//c++字符串可以用==比较 
                printf("YES\n");
            else
                printf("NO\n");
        }
    }
    return 0;
}
void Insert(nodeptr &t,int x){//将x插入到二叉搜索树t中 
    nodeptr p;
    if(t==NULL){
        p=new node;
        p->lc=NULL;
        p->rc=NULL;
        p->num=x;
        t=p;
    }
    else{
        if(x<=t->num)
            Insert(t->lc,x);//插入到左子树 
        else
            Insert(t->rc,x);//插入到右子树 
    }
}

void preorder(nodeptr t,char b[]){//中序遍历 
    if(t){
        b[cnt++]=t->num+'0';
        preorder(t->lc,b);
        preorder(t->rc,b);
    }
}

输入：

2
567432
543267
576342
0

输出：

YES
NO
羽星_s
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
二叉树查找算法
wjyiooo的博客
03-16 4452
定义树节点 class TreeNode: def __init__(self, x): self.val = x self.left = None self.right = None 先序遍历，递归 def preorder(root:TreeNode): """递归地，先序遍历二叉树""" if root == None...
算法之二叉查找树
独自登高楼 望断天涯路
10-09 1180
package com.eshore.sweetop.dataframe;import java.util.Random;import com.eshore.sweetop.data.KeyData;import com.eshore.sweetop.data.Node;/* * bintree */public class Bintree {    private Node root;
用 Map 计算硬木种类
实践求真知
03-15 709
一问题描述 某国有数百种硬木，该国自然资源部利用卫星成像技术编制了一份特定日期每棵树的物种清单。计算物种占所有种群的百分比。 输入：输入包括每棵树的物种清单，每行一棵树。 输出：按字母顺序输出植物种群中代表的每个物种的名称，然后是占所有种群的百分比，保留小数后4位。 输入样例： H R E G F D S E F D H U Y T G H F R D G J Y N H G F R I L J H T F R D E H G F T K H exit 输出样例 D 9.5238 .
C++二叉搜索树
weixin_41368411的博客
09-08 284
二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:（1）若它的左子树不为空，则左子树上所有节点的值都小于根节点的值（2）若它的右子树不为空，则右子树上所有节点的值都大于根节点的值（3）它的左右子树也分别为二叉搜索树。
算法训练营day43
最新发布
stmfresher的博客
05-29 368
【代码】算法训练营day43。
算法训练营
zxiaoguliang的博客
10-04 107
思路: 同上一题类似，区别在于不能重复使用数组元素，因此需要判断相同元素不在同一树层。思路: 需要加一个判断回文串函数，利用双指针即可解决。时间复杂度：O(n*2^n)；空间复杂度：O(n)时间复杂度：O(n*2^n)；空间复杂度：O(n)时间复杂度：O(n*2^n)；空间复杂度：O(n)
代码随想录算法训练营day52|第九章 动态规划part13
mrmobi的博客
03-10 878
明确了这一点，要理解需要两层嵌套遍历就容易一点，要依次更新每一个dp[i]，就必须每次都遍历一整遍前面的nums，一旦发现有小于当前nums[i]的，就证明当前nums[i]可以作为原来（以nums[j]为结尾的）子序列的新结尾，并且试图更新dp[i]的值，注意外层遍历从下标1开始（0前面没有元素，不可以用来更新dp[0]），内层循环从0开始到 i 前结束（遍历所有可能成为 以nums[i]结尾子序列的倒数第二个值 的数）。本题相对于昨天的动态规划：300.最长递增子序列 最大的区别在于“连续”。
二叉查找树
qq_45832461的博客
08-27 9127
二叉查找树 简介 二叉查找树(Binary Search Tree，BST)，又叫做二叉排序树、二叉搜索树，是一种对查找和排序都有用的特殊二叉树。 二叉查找树或是空树，或是满足如下三个性质的二叉树： 若其左子树非空，则左子树上所有节点的值都小于根节点的值 若其右子树非空，则右子树上所有节点的值都大于根节点的值 其左右子树都是一棵二叉查找树 二叉查找树的特性：左子树<根<右子树，即二叉查找树的中序遍历是一个递增序列。 如下图所示，其中序遍历为{5,18,29,25,32,25,69} 我们
Ruby实现的最优二叉查找树算法
01-21
算法导论上的伪码改写而成，加上导论的课后练习第一题的解的构造函数。 代码如下: #encoding: utf-8 =begin author: xu jin date: Nov 11, 2012 Optimal Binary Search Tree to find by using EditDistance ...
二叉查找树算法.zip
04-24
图算法：图算法用于处理图结构的数据，如最短路径算法（如Dijkstra算法、Floyd-Warshall算法）、最小生成树算法（如Prim算法、Kruskal算法）等。 动态规划：动态规划是一种通过将问题分解成更小的子问题来解决复杂...
c语言实现二叉查找树实例方法
12-26
JJDiaries(阿呆) 邮箱：JJDiaries@gmail.com日期: 2013-11-13============================================二叉查找树，支持的操作包括：SERACH、MINIMUM、MAXIMUM、PREDECESSOR、SUCCESSOR、INSERT、DELETE。
转载 查找算法 二叉排序树.doc
05-08
二叉排序树，也被称为二叉查找树，是一种特殊类型的二叉树，其设计目的是为了高效地执行查找、插入和删除等操作。它满足以下三个特性： 1. 如果二叉排序树为空，那么它就是空树。 2. 如果树不为空，那么左子树中...
算法训练营Day16
momolinshaomo的博客
12-15 1003
Java #二叉树给定一个二叉树，判断它是否是高度平衡的二叉树。本题中，一棵高度平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。题目要求的是每个节点，这样就想到了把问题分为多个子问题，利用递归来解。注意：• 高度通常是指从一个节点到其最远叶子节点的最长路径上的边数。• 在一个树结构中，树的高度通常是指根节点的高度，即从根节点到最远叶子节点的最长路径。• 例如，在一棵二叉树中，根节点的高度是从根节点到最远叶子节点的边的数量。
代码随想录算法训练营总结篇
zwq54argfun的博客
03-17 449
为期两个月的算法训练营终于完结撒花了，回想这两个月一路走来，每天提醒自己的第一件事就是去做训练营的题目，然后看视频，写日志总结，最后打卡，都成了习惯了哈哈~ 这两个月以来，自己从一个看见算法题就发怵，到能够一刷就AC某些medium题目，虽然我知道离大厂笔试要求还有不小的距离，不过我会继续努力的，后面我肯定还会二刷三刷，说不定还要继续报名跟训练营呢~说起跟着卡哥训练营的节奏，真的很能督促自己不断的进步学习，其实在报名之前，我自己有过一段时间坚持刷力扣，每天就做三道题，按照不同数据结构的分类来做，
代码随想录算法训练营第一天丨数组part 01
grace_it的博客
01-11 967
数组（Array）是一种线性表数据结构。它用一组连续的内存空间，来存储一组具有相同类型的数据。值得注意的是正是因为这两个限制，数组中的任意一个数据元素都可以随机访问，同时也有弊端，比如要想在数组中删除、插入一个数据，为了保证连续性，就需要做大量的数据移动工作。
算法训练营总结
memolaner的博客
03-29 825
经过60天的坚持打卡，系统的过了一遍leetcode经典题目，包括数组（二分查找）、链表、哈希表、字符串、栈与队列、二叉树、回溯、贪心、动态规划、单调栈。由于有一定的基础，也是本着练习C++的想法入门的，所有的题目会先用熟悉的python写一遍，再用C++写一遍。在入门C++方面，群友助教答疑非常有用，如果是自己看书或者资料，很难快速的定位问题。在有经验的人帮助下，可以非常快速的解决问题，开始上手leetcode类型的代码，给下一步编写C++程序奠定了很好的基础。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

羽星_s

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值