数据结构树c语言（C基础语法梳理数据结构树）
数据结构树c语言（C基础语法梳理数据结构树）a.若 i = 1，为根，否则双亲为 ⌊ i / 2 ⌋（5）对于含 n 个结点的完全二叉树中编号为 i （1 <= i <= n） 的结点（2）深度为 k 的二叉树最多 2k - 1 个结点 （k >= 1）（3）度为 0 的结点数为 n0，度为 2 的结点数为 n2，则 n0 = n2 1（4）有 n 个结点的完全二叉树深度 k = ⌊ log2(n) ⌋ 1
本期是C 基础语法分享的第十四节，今天给大家来梳理一下树！
BinaryTree.cpp：
#include <stdio.h>
#include <stdlib.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -1
#define SUCCESS 1
#define UNSUCCESS 0
#define dataNum 5
int i = 0;
int dep = 0;
char data[dataNum] = { 'A' 'B' 'C' 'D' 'E' };
typedef int Status;
typedef char TElemType;
// 二叉树结构
typedef struct BiTNode
{
TElemType data;
struct BiTNode *lchild *rchild;
}BiTNode *BiTree;
// 初始化一个空树
void InitBiTree(BiTree &T)
{
T = NULL;
}
// 构建二叉树
BiTree MakeBiTree(TElemType e BiTree L BiTree R)
{
BiTree t;
t = (BiTree)malloc(sizeof(BiTNode));
if (NULL == t) return NULL;
t->data = e;
t->lchild = L;
t->rchild = R;
return t;
}
// 访问结点
Status visit(TElemType e)
{
printf("%c" e);
return OK;
}
// 对二叉树T求叶子结点数目
int Leaves(BiTree T)
{
int l = 0 r = 0;
if (NULL == T) return 0;
if (NULL == T->lchild && NULL == T->rchild) return 1;
// 求左子树叶子数目
l = Leaves(T->lchild);
// 求右子树叶子数目
r = Leaves(T->rchild);
// 组合
return r l;
}
// 层次遍历：dep是个全局变量 高度
int depTraverse(BiTree T)
{
if (NULL == T) return ERROR;
dep = (depTraverse(T->lchild) > depTraverse(T->rchild)) ? depTraverse(T->lchild) : depTraverse(T->rchild);
return dep 1;
}
// 高度遍历：lev是局部变量，层次
void levTraverse(BiTree T Status(*visit)(TElemType e) int lev)
{
if (NULL == T) return;
visit(T->data);
printf("的层次是%d\n" lev);
levTraverse(T->lchild visit lev);
levTraverse(T->rchild visit lev);
}
// num是个全局变量
void InOrderTraverse(BiTree T Status(*visit)(TElemType e) int &num)
{
if (NULL == T) return;
visit(T->data);
if (NULL == T->lchild && NULL == T->rchild) { printf("是叶子结点"); num ; }
else printf("不是叶子结点");
printf("\n");
InOrderTraverse(T->lchild visit num);
InOrderTraverse(T->rchild visit num);
}
// 二叉树判空
Status BiTreeEmpty(BiTree T)
{
if (NULL == T) return TRUE;
return FALSE;
}
// 打断二叉树：置空二叉树的左右子树
Status BreakBiTree(BiTree &T BiTree &L BiTree &R)
{
if (NULL == T) return ERROR;
L = T->lchild;
R = T->rchild;
T->lchild = NULL;
T->rchild = NULL;
return OK;
}
// 替换左子树
Status ReplaceLeft(BiTree &T BiTree <)
{
BiTree temp;
if (NULL == T) return ERROR;
temp = T->lchild;
T->lchild = LT;
LT = temp;
return OK;
}
// 替换右子树
Status ReplaceRight(BiTree &T BiTree &RT)
{
BiTree temp;
if (NULL == T) return ERROR;
temp = T->rchild;
T->rchild = RT;
RT = temp;
return OK;
}
// 合并二叉树
void UnionBiTree(BiTree &Ttemp)
{
BiTree L = NULL R = NULL;
L = MakeBiTree(data[i ] NULL NULL);
R = MakeBiTree(data[i ] NULL NULL);
ReplaceLeft(Ttemp L);
ReplaceRight(Ttemp R);
}
int main()
{
BiTree T = NULL Ttemp = NULL;
InitBiTree(T);
if (TRUE == BiTreeEmpty(T)) printf("初始化T为空\n");
else printf("初始化T不为空\n");
T = MakeBiTree(data[i ] NULL NULL);
Ttemp = T;
UnionBiTree(Ttemp);
Ttemp = T->lchild;
UnionBiTree(Ttemp);
Status(*visit1)(TElemType);
visit1 = visit;
int num = 0;
InOrderTraverse(T visit1 num);
printf("叶子结点是 %d\n" num);
printf("叶子结点是 %d\n" Leaves(T));
int lev = 1;
levTraverse(T visit1 lev);
printf("高度是 %d\n" depTraverse(T));
getchar();
return 0;
}
性质
（1）非空二叉树第 i 层最多 2(i-1) 个结点 （i >= 1）
（2）深度为 k 的二叉树最多 2k - 1 个结点 （k >= 1）
（3）度为 0 的结点数为 n0，度为 2 的结点数为 n2，则 n0 = n2 1
（4）有 n 个结点的完全二叉树深度 k = ⌊ log2(n) ⌋ 1
（5）对于含 n 个结点的完全二叉树中编号为 i （1 <= i <= n） 的结点
a.若 i = 1，为根，否则双亲为 ⌊ i / 2 ⌋
b.若 2i > n，则 i 结点没有左孩子，否则孩子编号为 2i
c.若 2i 1 > n，则 i 结点没有右孩子，否则孩子编号为 2i 1
存储结构
二叉树数据结构
typedef struct BiTNode
{
TElemType data;
struct BiTNode *lchild *rchild;
}BiTNode *BiTree;
顺序存储
二叉树顺序存储图片
链式存储
二叉树链式存储图片
遍历方式
a.先序遍历
b.中序遍历
c.后续遍历
d.层次遍历
分类
（1）满二叉树
（2）完全二叉树（堆）
大顶堆：根 >= 左 && 根 >= 右
小顶堆：根 <= 左 && 根 <= 右
（3）二叉查找树（二叉排序树）：左 < 根 < 右
（4）平衡二叉树（AVL树）：| 左子树树高 - 右子树树高 | <= 1
（5）最小失衡树：平衡二叉树插入新结点导致失衡的子树：调整：
LL型：根的左孩子右旋
RR型：根的右孩子左旋
LR型：根的左孩子左旋，再右旋
RL型：右孩子的左子树，先右旋，再左旋
其他树及森林1、树的存储结构
（1）双亲表示法
（2）双亲孩子表示法
（3）孩子兄弟表示法
并查集
一种不相交的子集所构成的集合 S = {S1 S2 ... Sn}
2、平衡二叉树（AVL树）
性质
（1）| 左子树树高 - 右子树树高 | <= 1
（2）平衡二叉树必定是二叉搜索树，反之则不一定
（3）最小二叉平衡树的节点的公式：F(n)=F(n-1) F(n-2) 1 （1 是根节点，F(n-1) 是左子树的节点数量，F(n-2) 是右子树的节点数量）
平衡二叉树图片
最小失衡树
平衡二叉树插入新结点导致失衡的子树
调整：
LL 型：根的左孩子右旋
RR 型：根的右孩子左旋
LR 型：根的左孩子左旋，再右旋
RL 型：右孩子的左子树，先右旋，再左旋
3、红黑树
RedBlackTree.cpp：
#define BLACK 1
#define RED 0
#include <iostream>
using namespace std;
class bst {
private:
struct Node {
int value;
bool color;
Node *leftTree *rightTree *parent;
Node() : value(0) color(RED) leftTree(NULL) rightTree(NULL) parent(NULL) { }
Node* grandparent() {
if (parent == NULL) {
return NULL;
}
return parent->parent;
}
Node* uncle() {
if (grandparent() == NULL) {
return NULL;
}
if (parent == grandparent()->rightTree)
return grandparent()->leftTree;
else
return grandparent()->rightTree;
}
Node* sibling() {
if (parent->leftTree == this)
return parent->rightTree;
else
return parent->leftTree;
}
};
void rotate_right(Node *p) {
Node *gp = p->grandparent();
Node *fa = p->parent;
Node *y = p->rightTree;
fa->leftTree = y;
if (y != NIL)
y->parent = fa;
p->rightTree = fa;
fa->parent = p;
if (root == fa)
root = p;
p->parent = gp;
if (gp != NULL) {
if (gp->leftTree == fa)
gp->leftTree = p;
else
gp->rightTree = p;
}
}
void rotate_left(Node *p) {
if (p->parent == NULL) {
root = p;
return;
}
Node *gp = p->grandparent();
Node *fa = p->parent;
Node *y = p->leftTree;
fa->rightTree = y;
if (y != NIL)
y->parent = fa;
p->leftTree = fa;
fa->parent = p;
if (root == fa)
root = p;
p->parent = gp;
if (gp != NULL) {
if (gp->leftTree == fa)
gp->leftTree = p;
else
gp->rightTree = p;
}
}
void inorder(Node *p) {
if (p == NIL)
return;
if (p->leftTree)
inorder(p->leftTree);
cout << p->value << " ";
if (p->rightTree)
inorder(p->rightTree);
}
string outputColor(bool color) {
return color ? "BLACK" : "RED";
}
Node* getSmallestChild(Node *p) {
if (p->leftTree == NIL)
return p;
return getSmallestChild(p->leftTree);
}
bool delete_child(Node *p int data) {
if (p->value > data) {
if (p->leftTree == NIL) {
return false;
}
return delete_child(p->leftTree data);
}
else if (p->value < data) {
if (p->rightTree == NIL) {
return false;
}
return delete_child(p->rightTree data);
}
else if (p->value == data) {
if (p->rightTree == NIL) {
delete_one_child(p);
return true;
}
Node *smallest = getSmallestChild(p->rightTree);
swap(p->value smallest->value);
delete_one_child(smallest);
return true;
}
else {
return false;
}
}
void delete_one_child(Node *p) {
Node *child = p->leftTree == NIL ? p->rightTree : p->leftTree;
if (p->parent == NULL && p->leftTree == NIL && p->rightTree == NIL) {
p = NULL;
root = p;
return;
}
if (p->parent == NULL) {
delete p;
child->parent = NULL;
root = child;
root->color = BLACK;
return;
}
if (p->parent->leftTree == p) {
p->parent->leftTree = child;
}
else {
p->parent->rightTree = child;
}
child->parent = p->parent;
if (p->color == BLACK) {
if (child->color == RED) {
child->color = BLACK;
}
else
delete_case(child);
}
delete p;
}
void delete_case(Node *p) {
if (p->parent == NULL) {
p->color = BLACK;
return;
}
if (p->sibling()->color == RED) {
p->parent->color = RED;
p->sibling()->color = BLACK;
if (p == p->parent->leftTree)
rotate_left(p->sibling());
else
rotate_right(p->sibling());
}
if (p->parent->color == BLACK && p->sibling()->color == BLACK
&& p->sibling()->leftTree->color == BLACK && p->sibling()->rightTree->color == BLACK) {
p->sibling()->color = RED;
delete_case(p->parent);
}
else if (p->parent->color == RED && p->sibling()->color == BLACK
&& p->sibling()->leftTree->color == BLACK && p->sibling()->rightTree->color == BLACK) {
p->sibling()->color = RED;
p->parent->color = BLACK;
}
else {
if (p->sibling()->color == BLACK) {
if (p == p->parent->leftTree && p->sibling()->leftTree->color == RED
&& p->sibling()->rightTree->color == BLACK) {
p->sibling()->color = RED;
p->sibling()->leftTree->color = BLACK;
rotate_right(p->sibling()->leftTree);
}
else if (p == p->parent->rightTree && p->sibling()->leftTree->color == BLACK
&& p->sibling()->rightTree->color == RED) {
p->sibling()->color = RED;
p->sibling()->rightTree->color = BLACK;
rotate_left(p->sibling()->rightTree);
}
}
p->sibling()->color = p->parent->color;
p->parent->color = BLACK;
if (p == p->parent->leftTree) {
p->sibling()->rightTree->color = BLACK;
rotate_left(p->sibling());
}
else {
p->sibling()->leftTree->color = BLACK;
rotate_right(p->sibling());
}
}
}
void insert(Node *p int data) {
if (p->value >= data) {
if (p->leftTree != NIL)
insert(p->leftTree data);
else {
Node *tmp = new Node();
tmp->value = data;
tmp->leftTree = tmp->rightTree = NIL;
tmp->parent = p;
p->leftTree = tmp;
insert_case(tmp);
}
}
else {
if (p->rightTree != NIL)
insert(p->rightTree data);
else {
Node *tmp = new Node();
tmp->value = data;
tmp->leftTree = tmp->rightTree = NIL;
tmp->parent = p;
p->rightTree = tmp;
insert_case(tmp);
}
}
}
void insert_case(Node *p) {
if (p->parent == NULL) {
root = p;
p->color = BLACK;
return;
}
if (p->parent->color == RED) {
if (p->uncle()->color == RED) {
p->parent->color = p->uncle()->color = BLACK;
p->grandparent()->color = RED;
insert_case(p->grandparent());
}
else {
if (p->parent->rightTree == p && p->grandparent()->leftTree == p->parent) {
rotate_left(p);
rotate_right(p);
p->color = BLACK;
p->leftTree->color = p->rightTree->color = RED;
}
else if (p->parent->leftTree == p && p->grandparent()->rightTree == p->parent) {
rotate_right(p);
rotate_left(p);
p->color = BLACK;
p->leftTree->color = p->rightTree->color = RED;
}
else if (p->parent->leftTree == p && p->grandparent()->leftTree == p->parent) {
p->parent->color = BLACK;
p->grandparent()->color = RED;
rotate_right(p->parent);
}
else if (p->parent->rightTree == p && p->grandparent()->rightTree == p->parent) {
p->parent->color = BLACK;
p->grandparent()->color = RED;
rotate_left(p->parent);
}
}
}
}
void DeleteTree(Node *p) {
if (!p || p == NIL) {
return;
}
DeleteTree(p->leftTree);
DeleteTree(p->rightTree);
delete p;
}
public:
bst() {
NIL = new Node();
NIL->color = BLACK;
root = NULL;
}
~bst() {
if (root)
DeleteTree(root);
delete NIL;
}
void inorder() {
if (root == NULL)
return;
inorder(root);
cout << endl;
}
void insert(int x) {
if (root == NULL) {
root = new Node();
root->color = BLACK;
root->leftTree = root->rightTree = NIL;
root->value = x;
}
else {
insert(root x);
}
}
bool delete_value(int data) {
return delete_child(root data);
}
private:
Node *root *NIL;
};
int main()
{
cout << "---【红黑树】---" << endl;
// 创建红黑树
bst tree;
// 插入元素
tree.insert(2);
tree.insert(9);
tree.insert(-10);
tree.insert(0);
tree.insert(33);
tree.insert(-19);
// 顺序打印红黑树
cout << "插入元素后的红黑树：" << endl;
tree.inorder();
// 删除元素
tree.delete_value(2);
// 顺序打印红黑树
cout << "删除元素 2 后的红黑树：" << endl;
tree.inorder();
// 析构
tree.~bst();
getchar();
return 0;
}
红黑树的特征是什么？
（1）节点是红色或黑色。
（2）根是黑色。
（3）所有叶子都是黑色（叶子是 NIL 节点）。
（4）每个红色节点必须有两个黑色的子节点。（从每个叶子到根的所有路径上不能有两个连续的红色节点。）（新增节点的父节点必须相同）
（5）从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。（新增节点必须为红）
调整
（1）变色
（2）左旋
（3）右旋
应用
关联数组：如 STL 中的 map、set
红黑树、B 树、B 树的区别？
（1）红黑树的深度比较大，而 B 树和 B 树的深度则相对要小一些
（2）B 树则将数据都保存在叶子节点，同时通过链表的形式将他们连接在一起。
B 树（B-tree）、B 树（B -tree）
特点
一般化的二叉查找树（binary search tree）
“矮胖”，内部（非叶子）节点可以拥有可变数量的子节点（数量范围预先定义好）
应用
大部分文件系统、数据库系统都采用B树、B 树作为索引结构
区别
B 树中只有叶子节点会带有指向记录的指针（ROWID），而B树则所有节点都带有，在内部节点出现的索引项不会再出现在叶子节点中。
B 树中所有叶子节点都是通过指针连接在一起，而B树不会。
B树的优点
对于在内部节点的数据，可直接得到，不必根据叶子节点来定位。
B 树的优点
非叶子节点不会带上 ROWID，这样，一个块中可以容纳更多的索引项，一是可以降低树的高度。二是一个内部节点可以定位更多的叶子节点。
叶子节点之间通过指针来连接，范围扫描将十分简单，而对于B树来说，则需要在叶子节点和内部节点不停的往返移动。
B 树、B 树区别来自：differences-between-b-trees-and-b-trees、B树和B 树的区别
八叉树八叉树图片
八叉树（octree），或称八元树，是一种用于描述三维空间（划分空间）的树状数据结构。八叉树的每个节点表示一个正方体的体积元素，每个节点有八个子节点，这八个子节点所表示的体积元素加在一起就等于父节点的体积。一般中心点作为节点的分叉中心。
用途
三维计算机图形
最邻近搜索
今天的分享就到这里了，大家要好好学C 哟~
写在最后：对于准备学习C/C 编程的小伙伴，如果你想更好的提升你的编程核心能力（内功）不妨从现在开始！
编程学习书籍分享：
编程学习视频分享：
整理分享（多年学习的源码、项目实战视频、项目笔记，基础入门教程）
欢迎转行和学习编程的伙伴，利用更多的资料学习成长比自己琢磨更快哦！
对于C/C 感兴趣可以关注小编在后台私信我：【编程交流】一起来学习哦！可以领取一些C/C 的项目学习视频资料哦！已经设置好了关键词自动回复，自动领取就好了！
