二叉树的各种操作：前序、中序、后序、层序遍历，二叉树搜索、插入和删除等操作

1.概述

定义：树是一个或多个节点的有效集合，且其中：

存在一个称为根的特定节点

其余的节点被分成n个互不相交的集合T,其中每个集合都是一棵树，称为子树。

结点的度：一个结点的子树数目称为该结点的度；

树的度：所有结点度当中，度最高的一个。（上图树的度是3）；

叶子结点：度为0的节点；

层(level)：根结点的层定义为1；根的孩子为第二层结点，依此类推

树的深度（depth)或高度（height)：树中最大的结点层

2 二叉树

2.1基本概念

定义：二叉树（binary tree)是有限多个节点的集合，这个集合或者空集，或者 由一个根节点和两颗互不相交的、分别称为左子树和右子树组成。

二叉树的性质：

在二叉树中，第i层的节点数最多为2i−1,i≥12^{i-1},i≥1；

在深度为k的二叉树中，节点总数最多为2k−1,k≥12^k-1,k≥1；

叶子节点n0n_0的个数与度为2的节点n_2个数之间的关系为：n0=n2+1n_0=n_2+1

满二叉树（full binary tree):是深度为k的满二叉树是具有2k−12^k-1个节点的二叉树，除了叶结点外每一个结点都有左右子叶且叶子结点都处在最底层的二叉树

完全二叉树：若设二叉树的高度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第h层有叶子结点，并且叶子结点都是从左到右依次排布，这就是完全二叉树。

2. 2二叉树的存储表示

数组存储表示：对节点从1到n进行编号，因此可以使用一个一维数组来存储这些点。

引理：对于一课n个节点的完全二叉树（深度log2n+1log_2n+1）采用顺序存储 表示，那么对于任意一个下标为i节点有：

若i≠1i≠1，则其父节点parent(i)的编号为i/2;若i=1,则i是根节点；

若2i<n2i，则其左孩子为2i;

若2i+1<n2i+1,则其右孩子为2i+1;

链式存储:

树的头结点定义：

typedef int ElementType;
typedef struct BinaryTreeNode BinTree;
struct BinaryTreeNode
{
ElementType data;
BinaryTreeNode* left;
BinaryTreeNode* right;
};

2.3 二叉树的遍历

三种遍历：

- LVR:中序遍历（inoder);

- LRV:后续遍历（postorder);

- VLR:前序遍历（preoeder）;

表达式树：表达式树的树叶是操作数，常数或变量，二其他的节点为操作符(operator)，表达式三种遍历顺序与表达式的中缀(infix)、后缀（postfix)和前缀（prefix)形式之间存在一种自然的对应关系。

代码实现：

#ifndef BINARYTREE_H
#define BINARYTREE_H

typedef int ElementType;
struct BinaryTreeNode
{
ElementType data;
BinaryTreeNode* left;
BinaryTreeNode* right;
};

void PreOrder(BinaryTreeNode* pRoot);//前序遍历
void PostOrder(BinaryTreeNode* pRoot);//后续遍历
void InOrder(BinaryTreeNode* pRoot);//中序遍历
void LevelOrder(BinaryTreeNode* pRoot);//层序遍历
#endif

#include"BinaryTree.h"
#include<stdio.h>
#include<stdlib.h>
#include<queue>
/*1.递归的实现二叉树的遍历*/
//前序遍历
void PreOrder(BinaryTreeNode* pRoot)
{
if (pRoot == NULL)
return;
printf("%d ", pRoot->data);
PreOrder(pRoot->left);
PreOrder(pRoot->right);
}

//后续遍历
void PostOrder(BinaryTreeNode* pRoot)
{
if (pRoot == NULL)
return;
PreOrder(pRoot->left);
PreOrder(pRoot->right);
printf("%d ", pRoot->data);

}

//中序遍历
void InOrder(BinaryTreeNode* pRoot)
{
if (pRoot == NULL)
return;
PreOrder(pRoot->left);
printf("%d ", pRoot->data);
PreOrder(pRoot->right);
}

//层序遍历
void LevelOrder(BinaryTreeNode* pRoot)
{
if (pRoot == NULL)
return;
std::queue<BinaryTreeNode*> tree_node_queue;
tree_node_queue.push(pRoot);
while (tree_node_queue.size()>0)
{
pRoot = tree_node_queue.front();
tree_node_queue.pop();
printf("%d ", pRoot->data);
if (pRoot->left != NULL)
tree_node_queue.push(pRoot->left);
if (pRoot->right != NULL)
tree_node_queue.push(pRoot->right);
}
}

3. 二叉搜索树

3.1 概述

关键字唯一

非空左子树的值一定小于子树根节点的值

右节点值一定大于根节点的值

左右子树仍然是二叉搜索树

3.2 二叉搜索树的各种操作

查找

插入

删除

#ifndef BINARYTREE_H
#define BINARYTREE_H

typedef int ElementType;
struct BinaryTreeNode
{
ElementType data;
BinaryTreeNode* left;
BinaryTreeNode* right;
};

void PreOrder(BinaryTreeNode* pRoot);//前序遍历
void PostOrder(BinaryTreeNode* pRoot);//后续遍历
void InOrder(BinaryTreeNode* pRoot);//中序遍历
void LevelOrder(BinaryTreeNode* pRoot);//层序遍历
BinaryTreeNode* BinaryTreeSearchRecursive(BinaryTreeNode* pRoot, ElementType key);//二叉搜索树查找（递归）
BinaryTreeNode* BinaryTreeSearch(BinaryTreeNode* pRoot, ElementType key);//二叉搜索树查找（迭代）
bool BinaryTreeInsert(BinaryTreeNode* &pRoot, ElementType key);//二叉树节点插入
bool BinaryTreeDelete(BinaryTreeNode* &pRoot, ElementType key);//二叉树节点删除

#endif

#include"BinaryTree.h"
#include<stdio.h>
#include<stdlib.h>
#include<queue>
/*1.递归的实现二叉树的遍历*/
//前序遍历
void PreOrder(BinaryTreeNode* pRoot)
{
if (pRoot == NULL)
return;
printf("%d ", pRoot->data);
PreOrder(pRoot->left);
PreOrder(pRoot->right);
}

//后续遍历
void PostOrder(BinaryTreeNode* pRoot)
{
if (pRoot == NULL)
return;
PreOrder(pRoot->left);
PreOrder(pRoot->right);
printf("%d ", pRoot->data);

}

//中序遍历
void InOrder(BinaryTreeNode* pRoot)
{
if (pRoot == NULL)
return;
PreOrder(pRoot->left);
printf("%d ", pRoot->data);
PreOrder(pRoot->right);
}

//层序遍历
void LevelOrder(BinaryTreeNode* pRoot)
{
if (pRoot == NULL)
return;
std::queue<BinaryTreeNode*> tree_node_queue;
tree_node_queue.push(pRoot);
while (tree_node_queue.size() > 0)
{
pRoot = tree_node_queue.front();
tree_node_queue.pop();
printf("%d ", pRoot->data);
if (pRoot->left != NULL)
tree_node_queue.push(pRoot->left);
if (pRoot->right != NULL)
tree_node_queue.push(pRoot->right);
}
}

//二叉搜索树查找(递归）
BinaryTreeNode* BinaryTreeSearchRecursive(BinaryTreeNode* pRoot, ElementType key)
{
if (pRoot == NULL || key == pRoot->data)
return pRoot;
if (key < pRoot->data)
return BinaryTreeSearchRecursive(pRoot->left, key);
else
return BinaryTreeSearchRecursive(pRoot->right, key);
}

//二叉搜索树查找（迭代）时间复杂度：o(h)
BinaryTreeNode* BinaryTreeSearch(BinaryTreeNode* pRoot, ElementType key)
{
while (pRoot != NULL && key != pRoot->data)
{
if (key < pRoot->data)
pRoot = pRoot->left;
else
pRoot = pRoot->right;
}
return pRoot;
}
//二叉树插入
bool BinaryTreeInsert(BinaryTreeNode* &pRoot, ElementType key)
{
BinaryTreeNode* pParent = NULL;
BinaryTreeNode* pNode = pRoot;
while (pNode != NULL&&pNode->data != key)
{
pParent = pNode;
if (key < pNode->data)
pNode = pNode->left;
else
pNode = pNode->right;
}
if (pNode != NULL)//key已经存在
return false;
BinaryTreeNode* pNodeInsert = (BinaryTreeNode*)malloc(sizeof(BinaryTreeNode));
if (pNodeInsert == NULL)//内存申请失败
return false;
pNodeInsert->data = key;
pNodeInsert->left = pNodeInsert->right = NULL;

if (pParent == NULL)//树为空，新插入的节点为根节点
pRoot = pNodeInsert;
else if (key < pParent->data)
pParent->left = pNodeInsert;
else
pParent->right = pNodeInsert;
return true;
}

//二叉树节点删除
bool BinaryTreeDelete(BinaryTreeNode* &pRoot, ElementType key)
{
BinaryTreeNode *pNext, *pFather = NULL;
BinaryTreeNode* pNode = pRoot;
int pos = 0;//待删除节点的位置，0代表根节点，-1代表左节点，1代表右节点
while (pNode != NULL&&pNode->data != key)
{
pFather = pNode;
if (key < pNode->data)

{
pos = -1;
pNode = pNode->left;
}
else
{
pos = 1;
pNode = pNode->right;
}
}
if (pNode == NULL)//节点不存在
return false;
if (pNode->left != NULL&&pNode->right != NULL)//待删除的节点有两个孩子
{
pFather = pNode;
pos = -1;
pNext = pNode->left;//用其左树中的最大元素替代删除元素
while (pNext->right != NULL)
{
pos = 1;
pFather = pNext;
pNext = pNext->right;
}
pNode->data = pNext->data;//替换
pNode = pNext;//更新需要删除的元素
}

if (pNode->left != NULL)//待删除节点只有左孩子
pNext = pNode->left;
else if (pNode->right != NULL)//只有右节点
pNext = pNode->right;
else                //待删除节点没有孩子
pNext = NULL;
if (pos == 0)//待删除节点为根节点
pRoot = pNext;
else if (pos == -1)//待删除节点为左孩子
pFather->left = pNext;
else                         //待删除节点为右孩子
pFather->right = pNext;

delete pNode;//删除节点
pNode = NULL;
return true;
}

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

int main()
{
BinaryTreeNode* pRootNode = NULL;
BinaryTreeNode* pFind;
BinaryTreeInsert(pRootNode, 30);
BinaryTreeInsert(pRootNode, 5);
BinaryTreeInsert(pRootNode, 2);
BinaryTreeInsert(pRootNode, 40);
BinaryTreeInsert(pRootNode, 35);
BinaryTreeInsert(pRootNode, 80);
BinaryTreeInsert(pRootNode, 32);
BinaryTreeInsert(pRootNode, 38);

PreOrder(pRootNode);
printf("1.前序遍历\n");

InOrder(pRootNode);
printf("2.中序遍历\n");

PostOrder(pRootNode);
printf("3.后序遍历\n");

LevelOrder(pRootNode);
printf("4.层序遍历\n");

pFind = BinaryTreeSearch(pRootNode, 35);
if (pFind)
printf("5.找到的节点为：%d\n", pFind->data);
else
printf("5.未找到节点");

pFind = BinaryTreeSearchRecursive(pRootNode, 33);
if (pFind)
printf("6.找到的节点为：%d\n", pFind->data);
else
printf("6.未找到节点\n");
if (BinaryTreeInsert(pRootNode, 33))
{
printf("7.插入成功\n");
LevelOrder(pRootNode);
}
if (BinaryTreeDelete(pRootNode, 33))
{
printf("8.删除成功\n");
LevelOrder(pRootNode);
}
if (BinaryTreeDelete(pRootNode, 35))
{
printf("8.删除成功\n");
LevelOrder(pRootNode);
}
return 0;
}