目录
2.2.节点插入与删除(后面二叉搜索树与平衡二叉树会分别讲)
一、树与二叉树
1.树的存储
一般来说,树采用链表来定义:
typedef struct Node *PtrToNode;
typedef struct PtrToNode Tree;
typedef struct PtrToNode Position;
typedef int ElementType;
struct Node{
ElementType Data;
Position Left, Right;
};
当然,在静态树中,也可以利用数组来表示:
const int MAXN = 1000;
Typedef int ElementType;
struct Node{
ElementType Data;
int left, right;//Tree中的下标
}Tree[MAXN];
2.树的基本操作
这里以链表指针表示的动态二叉树为例。
2.1.节点查找
Position Find(Tree T, ElementType X){
if(T==NULL) return NULL;//没找到
if(T->data==X) return T;
return Find(T->left; X);
return Find(T->right; X);
}
2.2.节点插入与删除(后面二叉搜索树与平衡二叉树会分别讲)
二、树的遍历
1.二叉树的遍历
1.1.前序遍历
1)递归解法:
/*树的前序遍历
*使用:递归
*思路:先输出头结点,再遍历左子树和右子树
*/
void PreOrderTraversal(Tree T){
if(T){
printf("%d\n", T->data);
PreOrderTraversal(T->left);
PreOrderTraversal(T->right);
}
}
2)非递归解法:注意是或的关系,且进入循环前不push
/*树的前序遍历
*使用:栈stack,#include<stack>
*思路:先输出头结点,再遍历左子树和右子树
*/
void PreOrderTraversal(Tree T){
stack<Node> S;
Tree Tmp=T;
while(Tmp || !S.empty()){//树非空或堆栈非空
while(Tmp){ //树非空,打印并寻找左子树
printf("%d\n", Tmp->data);
S.push(Tmp);
Tmp=Tmp->left;
}
if(!S.empty()){ //堆栈非空,弹出并寻找右子树
Tmp=S.top();
S.pop();
Tmp=Tmp->right;
}
}
}
1.2.中序遍历
1)递归解法
/*树的中序遍历
*使用:递归
*思路:先遍历左子树,再输出头结点和右子树
*/
void InOrderTraversal(Tree T){
if(T){
InOrderTraversal(T->left);
printf("%d\n", T->data);
InOrderTraversal(T->right);
}
}
2)非递归解法
/*树的前序遍历
*使用:栈stack,#include<stack>
*思路:先遍历左子树,再输出头结点和右子树
*/
void InOrderTraversal(Tree T){
stack<Node> S;
Tree Tmp=T;
while(Tmp || !S.empty()){//树非空或堆栈非空
while(Tmp){ //树非空,打印并寻找左子树
S.push(Tmp);
Tmp=Tmp->left;
}
if(!S.empty()){ //堆栈非空,弹出并寻找右子树
printf("%d\n", Tmp->data);
Tmp=S.top();
S.pop();
Tmp=Tmp->right;
}
}
}
1.3.后序遍历
1)递归解法
/*树的后序遍历
*使用:递归
*思路:先遍历左子树和右子树,再输出头结点
*/
void PastOrderTraversal(Tree T){
if(T){
PastOrderTraversal(T->left);
printf("%d\n", T->data);
PastOrderTraversal(T->right);
}
}
2)非递归解法:需要在节点中加入bool类型的IsFirstTraversal标志位
void PastOrderTraversal(Tree T){//后续非递归
Tree Tmp = T;
stack<Tree> S;
while(Tmp || !S.empty()){
while(Tmp){
S.push(Tmp);
Tmp=Tmp->left;
}
if(!S.empty()){
Tmp=S.top();
S.pop();
if(Tmp->IsFirstTraversal){
Tmp->IsFirstTraversal=false;
S.push(Tmp);
Tmp=Tmp->right;
}
else{
cout<<Tmp->data;
}
}
}
}
1.4.层序遍历
层序遍历一般用非递归实现:
/*树的层序遍历
*使用:队列
*思路:头结点加入队列;之后头结点弹出队列并把其儿子入队;
* 循环直至队列为空*/
void LevelOrderTraversal(Tree T){
queue<Tree> Q;
if(T==NULL) return;//边界条件
Q.push(T);
while(!Q.empty()){
T=Q.front();
Q.pop();
printf("%d ", T->data);
if(T->left) Q.push(T->left);
if(T->right) Q.push(T->right);
}
}
1.5.已知遍历顺序建树
例:已知后序遍历和中序遍历,建树并输出层序遍历:
#include <iostream>
#include <queue>
//注意点:1.边界条件;
// 2.后序遍历开始位置和结束位置的确定不能依靠从中序遍历计算到的inRoot
using namespace std;
const int maxn = 35;
typedef struct Node *Tree;
struct Node{
int data;
Tree left=NULL, right=NULL;
};
int n, post[maxn], in[maxn];
Tree T;
/*后序遍历最后一位是根节点rootKey,
*在中序遍历找到rootKey所在位置root后,
*中序left到root-1是左子树,root+1到right是右子树
*后序left到root-1是左子树,root到right-1是右子树
*递归,找到边界条件:
*/
Tree GenerateTree(int postL, int postR, int inL, int inR){
if(postR<postL) return NULL;//边界条件
int inRoot;//中序遍历根节点的位置
//寻找根节点inRoot
for(inRoot=0; inRoot<inR+1; inRoot++){
if(in[inRoot]==post[postR]) break;
}
int numleft = inRoot-inL;//左子树长度,用于确定后序遍历左右子树范围
Tree tr = (Tree)malloc(sizeof(struct Node));//新建树节点,也可以用Tree tr = new Tree;不加括号
tr->data=post[postR];//根节点data赋值
tr->left=GenerateTree(postL, postL+numleft-1, inL, inRoot-1);//递归返回左子树
tr->right=GenerateTree(postL+numleft, postR-1, inRoot+1, inR);//递归返回右子树
return tr;
}
int pointer = 0;//空格控制器
void LevelOrderTraversal(){
queue<Tree> q;
q.push(T);
Tree tmp=T;
while(!q.empty()){
tmp=q.front();
q.pop();
cout<<tmp->data;
pointer++;
if(pointer!=n) cout<<" ";//空格控制
if(tmp->left) q.push(tmp->left);
if(tmp->right) q.push(tmp->right);
}
}
int main()
{
cin>>n;
for(int i=0; i<n; i++) cin>>post[i];//输入后序遍历
for(int i=0; i<n; i++) cin>>in[i];//输入中序遍历
T = GenerateTree(0, n-1, 0, n-1);
LevelOrderTraversal();
return 0;
}
2.一般树的遍历
本节针对节点个数不限且子节点没有先后次序的树。方便起见,对于一般树考试时希望采用静态写法:
const int maxn = 10000;
typedef int dataType;
struct Node{
dataType data;
vector<int> child;
}Tree[maxn];
由于子节点个数不定,因此一般树的遍历只考虑先序遍历和层序遍历。
2.1.先序遍历(递归、不考虑子节点排序)
void PreOrderTraversal(int u){
printf("%d\n", T[u].data);
for(int i=0; i<T[u].child.size(); i++){
PreOrderTraversal(T[u].child[i]);
}
}
2.2.层序遍历
void LevelOrderTraversal(int u){//非递归
queue<int> Q;
Q.push(u);
while(!Q.empty()){
u=Q.front();
Q.pop();
cout<<u<<endl;
for(int i=0; i<Tree[u].child.size(); i++){
Q.push(Tree[u].child[i]);
}
}
}
三、二叉搜索树
1.定义
二叉搜索树(Binary Search Tree, BST)又称作二叉查找树、排序二叉树等,是二叉树的一种特殊形式。BST的每一个节点的左子节点小于(或小于等于)该节点,右节点大于该节点,形成一种从左到右从小到大的存储形式。
性质:二叉搜索树的中序遍历有序
2.操作集
2.1.树的结构与建树
typedef struct Node *BST;
typedef BST Position;
struct Node{
int data;
Position left, right;
};
//建树
BST Create(int data[], int n){//数组以及数组中数据个数
BST T = NULL;//不能新建,最好为空
for(int i=0; i<n; i++){
Insert(data[i], T);
}
return T;
}
2.2.查找
1)查找任意元素
//查找
Position Search(int X, BST T){
if(T==NULL) return NULL;
if(X==T->data) return T;
else if(X<T->data) return Search(X, T->left);
else return Search(X, T->right);
}
2)查找最值
Position FindMin(BST T){//查找最小值
Position tmp = T;
if(tmp==NULL) return NULL;
while(tmp->left != NULL){
tmp=tmp->left;
}
return tmp;
}
Position FindMax(BST T){//查找最大值
Position tmp = T;
if(tmp==NULL) return NULL;
while(tmp->right != NULL){
tmp=tmp->right;
}
return tmp;
}
2.3.插入
//插入
void Insert(int X, BST T){
if(T==NULL){
BST tmp = new BST;
tmp->data=X;
tmp->left=tmp->right=NULL;
T=tmp;
}
if(X==T->data) return;//节点已存在
else if(X<T->data) Insert(X, T->left);
else Insert(X, T->right);
}
2.4.删除
void Delete(int X, BST T){
Position P = Search(X, T);//查找被删除元素位置
if(P->left==NULL && P->right==NULL){//没有子节点
free(P);//有待商榷?
}
//有两个子节点,找右子节点最小值替换
else if(P->right!=NULL && P->left!=NULL){
Position minRight = FindMin(P->right);
P->data=minRight->data;//替换data
Delete(minRight->data, P->right);
}
else if(P->left!=NULL){//左不为空,右为空
Position tmp = P->left;
P->data=tmp->data;
P->left=tmp->left;
P->right=tmp->right;
free(tmp);
}
else if(P->right!=NULL){//右不为空
Position tmp = P->right;
P->data=tmp->data;
P->left=tmp->left;
P->right=tmp->right;
free(tmp);
}
}
四、平衡二叉树
1.定义
所谓二叉平衡树,是在保持二叉搜索树性质的,且左右子树高度差的绝对值不超过1的二叉树。
性质:查询时间复杂度O(logn)
结构:仅增加了height即该节点的高度,叶节点为1,其上每一层父节点的高度是其左右子树最大值+1
typedef struct Node* Position;
typedef Position Tree;
struct Node{
int data, height;
Position left, right;
};
2.基本操作集
2.1.基本函数
Position NewNode(int v){//新建data是v的点
Position T = (Position)malloc(sizeof(struct Node));
T->data=v;
T->height=1;
T->left=T->right=NULL;
return T;
}
int GetHeight(Position P){
if(P==NULL) return 0;//空节点高度为0
else return P->height;
}
int GetBalanceFactor(Position P){
return GetHeight(P->left) - GetHeight(P->right);
}
void UpdateHeight(Position P){
P->height = max(GetHeight(P->left), GetHeight(P->right)) + 1;//左右儿子最大值+1
}
2.2.查找
//同二叉搜索树
Tree Search(int X, Tree T){
if(T==NULL) return NULL;
if(X==T->data) return T;
if(X<T->data) return T->left;
else(X<T->data) return T->right;
}
2.3.插入
//插入
void Insert(int X, Tree T){
if(T==NULL){
Position P = NewNode(X);
return;
}
if(X<T->data){
Insert(X, T->left);
UpdateHeight(T);//从低往上重置树各节点高度
if(GetBalanceFactor(T)==2){//判断本节点平衡因子是否为2,左大右小为正
if(GetBalanceFactor(T->left)==1){//LL型
T = RightRotate(T);
}
else if(GetBalanceFactor(T->right)==-1){//LR型
T->left = LeftRotate(T->left);
T = RightRotate(T);
}
}
}
else{
Insert(X, T->right);
UpdateHeight(T);
if(GetBalanceFactor(T)==-2){
if(GetBalanceFactor(T->right==-1)){//RR型
LeftRotate(T);
}
else if(GetBalanceFactor(T->right==1)){//RL型
RightRoTate(T->right);
LeftRotate(T);
}
}
}
}
其中左旋右旋分别是:
//左旋
Position LeftRotate(Tree T){
Tree tmp = T->right;//左旋就找右儿子
T->right=tmp->left;//第一步
tmp->left=T;//第二步
UpdateHeight(T);//先更新考下的节点的高度
UpdateHeight(tmp);//在更新考上节点的高度
return tmp;//第三步
}
//右旋
Position RightRotate(Tree T){
Tree tmp = T->left;
T->left=tmp->right;
tmp->right=T;
UpdateHeight(T);
UpdateHeight(tmp);
return tmp;
}