随笔 -（ 二叉树 ）

二叉搜索树及其操作与应用
最新推荐文章于 2025-11-24 15:27:16 发布
原创 最新推荐文章于 2025-11-24 15:27:16 发布 · 164 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #数据结构

二叉搜索树的操作集
BinTree Insert( BinTree BST, ElementType X )
{
	if(BST==NULL)
	{
		BST=(BinTree)malloc(sizeof(BinTree));
		BST->Data=X;
		BST->Left=NULL;
		BST->Right=NULL;
	}
	else
	{
		if(X>BST->Data)
			BST->Right=Insert(BST->Right,X);
		else if(X<BST->Data)
			BST->Left=Insert(BST->Left,X);
	}
	return BST;	
}
BinTree Delete( BinTree BST, ElementType X )
{
	if(BST==NULL)
		printf("Not Found\n");
	else
	{ 
		if(X>BST->Data)
			BST->Right=Delete(BST->Right,X);
		else if(X<BST->Data)
			BST->Left=Delete(BST->Left,X);
		else 
		{
			if(BST->Left&&BST->Right)
			{
				Position tmp=FindMin(BST->Right);
				BST->Data=tmp->Data;
				BST->Right=Delete(BST->Right,BST->Data);
			}
			else
			{
				Position tmp=BST;
				if(BST->Left)
					BST=BST->Left;
				else
					BST=BST->Right;
				free(tmp);
			}
		}
	}
	return BST;
}
Position Find( BinTree BST, ElementType X )
{
	if(BST)
	{
		if(X==BST->Data)
			return BST;
		else if(X>BST->Data)
			return Find(BST->Right,X);
		else
			return Find(BST->Left,X);
 
	}
	return BST;
}
Position FindMin( BinTree BST )
{
    if(BST)
	{
        while(BST->Left)
            BST=BST->Left;
    } 
    return BST; 
} 
Position FindMax( BinTree BST )
{
    if(BST)
	{
        while(BST->Right)
            BST=BST->Right;
    } 
    return BST; 
}
二叉搜索树中的最近公共祖先
int find(Tree T,int x)
{
	if(!T) return 0;
	if(x==T->Key) return 1;
	if(x<T->Key) return find(T->Left,x);
	else return find(T->Right,x);
}                                                         
int LCA( Tree T, int u, int v )
{
	if(!T) return ERROR;
	if(!find(T,u)||!find(T,v)) return ERROR;
	int data=T->Key;
	if((u>data&&v<data)||(u<data&&v>data)) return data;
	if(u==data||v==data) return data;
	if(u>data) return LCA(T->Right,u,v);
	else return LCA(T->Left,u,v);
}
统计二叉树叶子结点个数
int LeafCount(BiTree T)
{
    int count;
    if(T==NULL) count=0;
    else if(T->lchild==NULL&&T->rchild==NULL) count=1;
    else count=LeafCount(T->lchild)+LeafCount(T->rchild);
    return count;
}
二叉树的三种遍历（先序、中序和后序）
void Preorder(BiTree T)
{
	if(T)
	{
		printf(" %c",T->data);
		Preorder(T->lchild);
		Preorder(T->rchild);
	}
}
void Inorder(BiTree T)
{
	if(T)
	{
		Inorder(T->lchild);
		printf(" %c", T->data);
		Inorder(T->rchild);
	}
}
void Postorder(BiTree T)
{
	if(T)
	{
		Postorder(T->lchild);
		Postorder(T->rchild);
		printf(" %c", T->data);		
	}
}
二叉树的非递归遍历
void InorderTraversal( BinTree BT )
{
	BinTree t=BT;
	Stack s=CreateStack();
	while(t||!IsEmpty(s))
	{
		while(t)
		{
			Push(s,t);
			t=t->Left;
		}
		if(!IsEmpty(s))
		{
			t=Pop(s);
			printf(" %c",t->Data);
			t=t->Right;
		}
	}
}
void PreorderTraversal( BinTree BT )
{
    BinTree t=BT;
    Stack s=CreateStack();
    while(t||!IsEmpty(s))
    {
        while(t)
        {
            Push(s,t);
            printf(" %c",t->Data);
            t=t->Left;
        }
        if(!IsEmpty(s))
        {
            t=Pop(s);
            t=t->Right;
        }
    }
}
void PostorderTraversal( BinTree BT )
{
    BinTree t=BT;
    Stack s=CreateStack();
    while(t||!IsEmpty(s))
    {
        while(t)
        {
            Push(s,t);
            t->flag=1;
            t=t->Left;
        }
        if(!IsEmpty(s))
        {
            t=Pop(s);
            if(t->flag==1)
            {
                Push(s,t);
                t->flag = 2;
                t=t->Right;
            }
            else
            {
                printf(" %c",t->Data);
                t=NULL;
            }
        }
    }
}
是否二叉搜索树
bool IsBST ( BinTree T )
{
    if(T)
	{
        if(T->Left)
		{
            if(T->Left->Data>T->Data) return false;
            if(T->Left->Right)
                if(T->Left->Right->Data>T->Data) return false;
            else return IsBST(T->Left);
        }
        if(T->Right)
		{
            if(T->Right->Data<T->Data) return false;
            if(T->Right->Left)
                if(T->Right->Left->Data<T->Data) return false;
            else return IsBST(T->Right);
        }
    }
    return true;
}
7-41 还原二叉树 (25分)
#include<iostream>
#include<cstdio>
using namespace std;
const int maxn=1e5+10;
int n;
char a[110],b[110];
struct node
{
	int l;
	int r;
}tree[maxn];
int build(int l1,int r1,int l2,int r2)
{
	if(l1>r1) return -1;
	int root=a[l1],pos=l2;
	while(b[pos]!=root) pos++;
	int len=pos-l2;
	tree[root].l=build(l1+1,l1+len,l2,pos-1);
	tree[root].r=build(l1+len+1,r1,pos+1,r2);
	return root;
}
int look(int root)
{
	if(root==-1) return 0;
	else return max(look(tree[root].l),look(tree[root].r))+1;
}
int main()
{
	cin>>n;
	for(int i=1;i<=n;i++) cin>>a[i];
	for(int i=1;i<=n;i++) cin>>b[i];
	build(1,n,1,n);
	cout<<look(a[1]);
    return 0;
}
7-42 玩转二叉树 (25分)
#include<iostream>
#include<string>
#include<map>
#include<set>
//#include<unordered_map>
#include<queue>
#include<cstdio>
#include<vector>
#include<cstring>
#include<algorithm>
#include<iomanip>
#include<cmath>
#include<fstream>
#define X first
#define Y second
#define INF 0x3f3f3f3f
#define pii pair<int, int>
//#define pdi pair<double,int>
using namespace std;
typedef long long ll;
typedef unsigned long long llu;
const int maxn=1e5+10;
int n,a[110],b[110],ans[110],cnt; 
struct node
{
	int l;
	int r;
}tree[1010];
int build(int l1,int r1,int l2,int r2)
{
	if(l1>r1) return -1;
	int root=b[l2],pos=l1;
	while(a[pos]!=root) pos++;
	int len=pos-l1;
	tree[root].l=build(l1,pos-1,l2+1,l2+len);
	tree[root].r=build(pos+1,r1,l2+len+1,r2);
	return root;
} 
void change(int root)
{
	if(root==-1) return ;
	if(tree[root].l==-1&&tree[root].r==-1) return ;
	swap(tree[root].l,tree[root].r);
	change(tree[root].l);
	change(tree[root].r);
}
void pint(int root)
{
	queue<int>q;
	q.push(root);
	while(q.size())
	{
		int cur=q.front();
		q.pop();
		ans[cnt++]=cur;
		if(tree[cur].l!=-1) q.push(tree[cur].l);
		if(tree[cur].r!=-1) q.push(tree[cur].r);
	}
	for(int i=0;i<cnt;i++)
	{
		if(i==0) printf("%d",ans[i]);
		else printf(" %d",ans[i]);
	}
}
int main( )
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++) scanf("%d",&a[i]);
	for(int i=1;i<=n;i++) scanf("%d",&b[i]);
	build(1,n,1,n);
	change(b[1]);
	pint(b[1]);
	return 0;
}
树的遍历（25分）
#include<iostream>
#include<string>
#include<map>
#include<set>
//#include<unordered_map>
#include<queue>
#include<cstdio>
#include<vector>
#include<cstring>
#include<algorithm>
#include<iomanip>
#include<cmath>
#include<fstream>
#define X first
#define Y second
#define INF 0x3f3f3f3f
#define pii pair<int, int>
//#define pdi pair<double,int>
using namespace std;
typedef long long ll;
typedef unsigned long long llu;
const int maxn=1e5+10;
int n,a[110],b[110],ans[110],cnt; 
struct node
{
	int l;
	int r;
}tree[1010];
int build(int l1,int r1,int l2,int r2)
{
	if(l1>r1) return -1;
	int root=a[r2],pos=l1;
	while(b[pos]!=root) pos++;
	int len=pos-l1;
	tree[root].l=build(l1,pos-1,l2,l2+len-1);
	tree[root].r=build(pos+1,r1,l2+len,r2-1);
	return root;
}
void pint(int root)
{
	queue<int>q;
	q.push(root);
	while(q.size())
	{
		int cur=q.front();
		q.pop();
		ans[cnt++]=cur;
		if(tree[cur].l!=-1) q.push(tree[cur].l);
		if(tree[cur].r!=-1) q.push(tree[cur].r);
	}
	for(int i=0;i<cnt;i++)
	{
		if(i==0) printf("%d",ans[i]);
		else printf(" %d",ans[i]);
	}
}
int main( )
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++) scanf("%d",&a[i]);
	for(int i=1;i<=n;i++) scanf("%d",&b[i]);
	build(1,n,1,n);
	pint(a[n]);
	return 0;
}
7-44 搜索树判断 (25分)
#include<iostream>
#include<cstdio>
#include<vector>
using namespace std;
const int maxn=1e5+10;
int n,a[1010];
vector<int>v;
void getv(int l,int r,int flag)
{
	int root=a[l];
	int left=l+1,right=r;
	if(!flag)//原像 
	{
		while(left<=r&&a[left]<root) left++;
		while(right>l&&a[right]>=root) right--;
	} 
	else//镜像 
	{
		while(left<=r&&a[left]>=root) left++;
		while(right>l&&a[right]<root) right--;
	}
	if(left-right!=1) return ;
	getv(l+1,right,flag);
	getv(left,r,flag);
	v.push_back(root);
}
int main()
{
	cin>>n;
	for(int i=1;i<=n;i++) cin>>a[i];
	getv(1,n,0);
//	cout<<"!!"<<endl;
	if(v.size()!=n)
	{
		v.clear();
		getv(1,n,1);
	}
	if(v.size()==n)
	{
		cout<<"YES"<<endl;
		for(int i=0;i<n;i++)
		{
			if(i==0) cout<<v[i];
			else cout<<' '<<v[i];
		}
	}
	else cout<<"NO"<<endl;
    return 0;
}
7-45 是否完全二叉搜索树 (30分)
#include<iostream>
#include<string>
#include<cstdio>
using namespace std;
typedef long long ll;
typedef unsigned long long llu;
const int maxn=1e5+10;
int n,a[110],flag,cnt,tree[1010];
void build(int p,int pos)
{
	if(tree[p]==0) tree[p]=a[pos];
	else
	{
		if(a[pos]>tree[p]) build(p<<1,pos);
		else build(p<<1|1,pos);
	}
	return ;
}
int main( )
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++) scanf("%d",&a[i]),build(1,i);
	for(int i=1;i<1010;i++)
	{
	    if(tree[i])
		{ 
	 	    if(flag) cout<<" ";
	 	    else flag=1;
			cout<<tree[i];
	 	    cnt=i;
		}
	} 
	if(cnt>n) cout<<endl<<"NO"<<endl;
	else cout<<endl<<"YES"<<endl;
	return 0;
}
数据结构与算法随笔之------二叉树的遍历（一文搞懂二叉树的四种遍历）
markconca的博客
11-07 1140
二叉树的遍历 二叉树的遍历（traversing binary tree）是指从根结点出发，按照某种次序依次访问二叉树中所有的结点，使得每个结点被访问依次且仅被访问一次。 遍历分为四种，前序遍历，中序遍历，后序遍历及层序遍历 前序 中 左 右 中序 左 中 右 后序 左 右 中 1.前序遍历 若树为空，则空操作返回。否则...
完全二叉树的构造队列java_Java数据结构-二叉树及其遍历
weixin_39851914的博客
02-26 224
二叉树的定义：n(n>=0)个结点的有限集合，该集合或者为空集(称为空二叉树)，或者由一个根结点和两棵互相不相交的、分别称为根结点的左子树和右子树的二叉树组成。二叉树的特点：0<=度<=2；左右子树是有顺序的，不能颠倒；不论有几棵子树，也要区分它是左子树还是右子树。二叉树的五种基本形态：空二叉树；只有一个根结点；根结点只有左子树；根结点只有右子树；根结点既有左子树又有右子树。举例...
Java数据结构-二叉树及其遍历
chiweihun1888的博客
07-24 155
二叉树的定义：n(n>=0)个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互相不相交的、分别称为根结点的左子树和右子树的二叉树组成。 二叉树的特点： 0<=度<=2； 左右子树是有顺序的，不能颠倒； 不论有几棵子树...
【剑指 Offer 随笔】二叉树------55. 深度（递归）
qq_42281215的博客
11-12 166
剑指 Offer 55 - I. 二叉树的深度 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/er-cha-shu-de-shen-du-lcof 输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。 # python 3 # Definition for a binary tree node. # class TreeNode: # def __init__(s.
数据结构随笔——二叉树基础
一枚菜鸡
05-16 456
一、基本概念 二叉树是一个连通的无环图，并且每一个顶点的度不大于3。有根二叉树还要满足根结点的度不大于2。有了根结点之后，每个顶点定义了唯一的父结点，和最多2个子结点。 树的结点（node）：包含一个数据元素及若干指向子树的分支； 孩子结点（child node）：结点的子树的根称为该结点的孩子； 双亲结点：B 结点是A 结点的孩子，则A结点是B 结点的双亲； 兄弟结点：同一双亲的孩子结点； 堂...
算法随笔之二叉树的遍历
懒散的蜗牛
07-02 214
class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } } 1、前序遍历（根-左-右） //递归 List<Integer> list = new ArrayList<Integer>(); public List<Integer> preorderTraversal(TreeNode root) {.
LeetCode 题解随笔：二叉树
weixin_44114160的博客
05-05 1850
LeetCode 题解随笔：二叉树 刷题顺序参考：代码随想录
数据结构与算法（八）-二叉树（斜二叉树、满二叉树、完全二叉树、线索二叉树）...
weixin_30393907的博客
09-28 252
前言：前面了解了树的概念和基本的存储结构类型及树的分类，而在树中应用最广泛的种类是二叉树 一、简介 　　在树型结构中，如果每个父节点只有两个子节点，那么这样的树被称为二叉树（Binary tree）。其中，一个父结点的两个字节点分别叫做“左子节点”和“右子节点”。不过也不是所有父节点都有两个子节点，只有左子节点或者只有右子节点的情况也存在。另外，也会存在叶子结点，也就是一个子节点都没有的节点，...
No.1-Apache IoTDB 随笔 - Time Series DBMS 综述
热门推荐
阿里云云栖号
03-24 4万+
简介： 这是一篇无法一口气读完的、文字过万[正文字数14390]的长文，这是一个无法中途不上厕所就看完的、关于时序数据库的视频[时长111分钟]分享的文字整理.. 大家好，很开心能够和大家一起交流时序数据库的相关的内容 首先还是简单自我介绍一下，我是 孙金城，花名 金竹。我是2011年加入阿里，在2016年之前一直做公司内部的研发工作，包括阿里郎，Blink等平台。 从2016年到现在我一直重心在开源建设上面，包括ApacheFlink/ApacheBeam/ApacheIoTDB，在这个过.
数据结构随笔——二叉树和五个重要性质
吾主贞德的笔记本
05-08 4826
二叉树是最常用的数据结构之一，笔者过去一直将关注点放在复杂的树结构（例如红黑树，自平衡树），认为那些才是树的重要应用，但当重新由基本看起，才发现树的基本定中就隐藏着树这一结构的精髓。尽管是些浅薄蠢笨的理解和推演，但笔者还是满怀兴奋的想要将它记录下来。 一、二叉树的定义二叉树的定义不用多说，很多书本上都有明确的定义，但有些细节是笔者过去所没有注意的，先给出殷人昆教授对于二叉树的基本定义—— 二叉树
java版五子棋源码-shuati:刷题随笔
06-05
二叉树的最大深度 S #107 二叉树的层次遍历II S #108 将有序数组转换为二叉搜索树 S #110 平衡二叉树 S #111 二叉树的最小深度 S #112 路径总和 S #118 杨辉三角 S #119 杨辉三角II S #121 买卖股票的最佳时机 S #...
算法导论随笔(四)：树形结构与二叉树
天降风云的博客
08-28 843
算法的设计与实现都必须依赖于数据结构。在这篇文章中，我来介绍计算机理论中的最常见的数据结构之一：树。其实，树这种结构，并不只是存在于算法理论中，在计算机的其他领域也有着重要的作用。例如，我们所熟知的C，Java，C++等编程语言的编译器，都离不开树这个结构，因为树在词法分析中起到至关重要的作用。 1.树的定义 在计算机科学中，树是一个用来表示层级结构的抽象模型。一棵树中包含了一些节点(Node)，这些节点具有父子关系(Parent-Child relation)。下图中就是一棵树。 树形结构的应用除了前文
2025年全国青少年信息素养大赛复赛真题（算法创意实践挑战赛C++初中组试卷1：带解析）（7月6日试卷）
王老师青少年编程
11-21 667
2025年全国青少年信息素养大赛复赛真题（算法创意实践挑战赛C++初中组试卷1：带解析）（7月6日试卷）
代码随想录 63.不同路径Ⅱ
最新发布
m0_63814538的博客
11-24 171
4.确定遍历顺序：从递归公式可以看出一定是从左到右一层一层的遍历，这样保证推导dp[i][j]的时候，dp[i - 1][j]和dp[i][j - 1]一定是有数值的。所以本题的初始化代码如下所示：一旦遇到obstacleGrid[i][0] == 1的情况就停止dp[i][0]的赋值1的操作，dp[0][j]同理。1.确定dp数组（dp table）及其下标的含义：dp[i][j]表示从（0，0）出发，到（i，j）有dp[i][j]条不同的路径。下标（0，j）的初始化情况同理。
专题二 -- 滑动窗口
2301_79389054的博客
11-17 1358
初始化窗口：确定窗口的起始位置和初始大小，通常使用两个指针（如左指针和右指针）来标记窗口的边界。扩展窗口：移动右指针，将新元素纳入窗口，直到窗口满足问题的特定条件（如包含所有目标元素、达到特定大小等）。收缩窗口：一旦窗口满足条件，尝试移动左指针，尽可能缩小窗口，同时保持条件成立，以找到最优解（如最小长度、最大和等）。更新结果：在每次窗口满足条件时，记录当前窗口的状态（如长度、元素和等），并根据问题要求更新全局最优解。重复步骤：继续扩展和收缩窗口，直到右指针遍历完整个数组。
算法：二叉搜索树的最近公共祖先
czlczl20020925的博客
11-24 297
下面是详细的解释，说明为什么这是必然的。对于我们当前所在的任何节点。
算法沉淀第十二天（牛客练习赛146）
lingran__的博客
11-22 788
本文分享了牛客练习赛146的三道算法题解：1.《合格的机器》通过分析代币奇偶性，得出最优解是尽量使机器代币数为偶数，当总代币数≥2n时最多n-1台合格；2.《小灰灰的火焰星球2》通过排序施法顺序和预处理价值数组，实现高效计算最大收益；3.《盲目自大的小灰灰》通过计算得分区间，判断查询分数是否可能达到。每道题都包含题意分析、逻辑梳理和AC代码实现，适合算法学习者参考。
力扣每日一题：可被三整除的最大和
yyssas的博客
11-23 183
会发现：假如现在对于前i个元素，可以被三除余j，则对于第i个元素x，如果取了，那么要在前i-1个元素中，找到被三除余j-x。如果不取，就是在前i-1个元素中找到被三除余j。然后要考虑的是边界条件，就是当i<0的情况，此时对于前-1个元素，无疑只能找除3余0的，余1和余2均是不存在，因此设定余1余2都是负无穷，这样就不会取到了。最开始考虑的是用01背包问题，对每个元素动态取舍，最后找到最大值。但感觉用数组一直存，可能会爆炸，因为和可能会很大。因此选择动态递归的方式，找到取前i个和取前i+1个元素的关系。
【元启发算法】模拟退火（SA）：在温度起伏中，寻找最优解的诗意算法
Harrytutu_ZuiYue的博客
11-21 351
自然从不急于求成，金属在冷热交替中趋于稳定，算法亦在温度起落中逼近真理。” 寒冬里调温的空调、背包旅行时规划路线、手机 APP 优化资源分配 —— 生活中处处藏着 “寻找最优解” 的难题。有些问题看似简单，却因可选方案过多，让我们陷入 “局部最优” 的困境：就像在山谷中徒步，误以为眼前的山峰就是最高点，却不知翻过一座小山后，还有更广阔的天地。
期权定价-二叉树python
09-25
期权定价模型中的二叉树是一种常用的方法。它可以在给定期权条件和市场数据的情况下，通过构建二叉树来估计期权的价格。该模型的实现包括以下两个主要步骤：1. 从左到右生成二叉树，即根据期权到期时间和时间步长，...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值