目录
1.树的解释
结点的度:一个结点含有的子树的个数称为该结点的度; 如上图:A的为6.
叶结点或终端结点:度为0的结点称为叶结点; 如上图:B、C、H、I...等结点为叶结点
非终端结点或分支结点:度不为0的结点; 如上图:D、E、F、G...等结点为分支结点
双亲结点或父结点:若一个结点含有子结点,则这个结点称为其子结点的父结点; 如上图:A是B的父结点
孩子结点或子结点:一个结点含有的子树的根结点称为该结点的子结点; 如上图:B是A的孩子结点
兄弟结点:具有相同父结点的结点互称为兄弟结点; 如上图:B、C是兄弟结点
树的度:一棵树中,最大的结点的度称为树的度; 如上图:树的度为6
结点的层次:从根开始定义起,根为第1层,根的子结点为第2层,以此类推;
树的高度或深度:树中结点的最大层次; 如上图:树的高度为4
堂兄弟结点:双亲在同一层的结点互为堂兄弟;如上图:H、I互为兄弟结点
结点的祖先:从根到该结点所经分支上的所有结点;如上图:A是所有结点的祖先
子孙:以某结点为根的子树中任一结点都称为该结点的子孙。如上图:所有结点都是A的子孙
森林:由m(m>0)棵互不相交的树的集合称为森林;
typedef int DataType;
struct Node
{
struct Node* Child1; // 孩子
struct Node* Brother; // 兄弟
DataType data; // 结点中的数据
};
树的结构例子:
2.二叉树(一种特殊的树)
1.满二叉树:一个二叉树,如果每一个层的结点数都达到最大值,则这个二叉树就是满二叉树。也就是说,如果一个二叉树的层数为K,且结点总数是 ,则它就是满二叉树。
2. 完全二叉树:完全二叉树是效率很高的数据结构,完全二叉树是由满二叉树而引出来的。对于深度为K的,有n个结点的二叉树,当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。
1.二叉树的性质:
1. 若规定根结点的层数为1,则一棵非空二叉树的第h层上最多有 2^(h-1)个结点.
2. 若规定根结点的层数为1,则深度为h的二叉树的最大结点数是 s^h - 1.
3. 对任何一棵二叉树, 如果度为0其叶结点个数为 X , 度为2的分支结点个数为 Y ,则有 X= Y+1
4. 若规定根结点的层数为1,具有n个结点的满二叉树的深度,h= log(2) (n+1). ( )
5. 对于具有n个结点的完全二叉树,如果按照从上至下从左至右的数组顺序对所有结点从0开始编号,则对于序号为i的结点有:
1. 若i>0,i位置结点的双亲序号:(i-1)/2;i=0,i为根结点编号,无双亲结点
2. 若2i+1<n,左孩子序号:2i+1,2i+1>=n否则无左孩子
3. 若2i+2<n,右孩子序号:2i+2,2i+2>=n否则无右孩子
3.堆(完全二叉树的特别情况)
1.堆的性质:
1.堆中某个结点的值 总是 不大于或不小于其父结点的值;
2.堆总是一棵完全二叉树。
小堆:大堆:
2. 堆的应用
2.1 堆排序
1. 建堆
升序:建大堆
降序:建小堆
2. 利用堆删除思想来进行排序
建堆和堆删除中都用到了向下调整,因此掌握了向下调整,就可以完成堆排序
4.二叉树链式结构(二叉树是树的一种形式)
两种二叉树:
1. 空树
2. 非空:根结点,根结点的左子树、根结点的右子树组成的。
1.二叉树的遍历
1. 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
2. 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中(间)。
3. 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。
例子一.
2. 层序遍历
层序遍历:首先访问第一层的树根结点,然后从左到右访问第2层上的结点,接着是第三层的结点,以此类推,自上而下,自左至右逐层访问树的结点的过程就是层序遍历。
比如
下面为实现代码:
5.实现二叉树的代码:
typedef int BTDataType;
//树结构
typedef struct BinaryTreeNode
{
BTDataType _data;
struct BinaryTreeNode* _left;
struct BinaryTreeNode* _right;
}BTNode;
//建立一个节点
BTNode* BuyNode(int k)
{
BTNode* cur = (BTNode*)malloc(sizeof(BTNode));
if (cur == NULL)
{
perror("malloc fail");
exit(0);
}
cur->_data = k;
cur->_left = cur->_right = NULL;
}
// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* arr, int sz, int* i)
{
if (arr[*i] == '#')
{
(*i)++;
return NULL;
}
BTNode* cur = (BTNode*)malloc(sizeof(BTNode));
cur->_data = arr[(*i)++];
cur->_left = BinaryTreeCreate(arr, sz,i);
cur->_right = BinaryTreeCreate(arr, sz,i);
return cur;
}
//也可以自己手动弄一颗树,
BTNode* CreatBinaryTree()
{
BTNode* node1 = BuyNode(1);
BTNode* node2 = BuyNode(2);
BTNode* node3 = BuyNode(3);
BTNode* node4 = BuyNode(4);
BTNode* node5 = BuyNode(5);
BTNode* node6 = BuyNode(6);
node1->_left = node2;
node1->_right = node4;
node2->_left = node3;
node4->_left = node5;
node4->_right = node6;
return node1;
}
// 二叉树前序遍历
void BinaryTreePrevOrder(BTNode* root)
{
if (root == NULL)
{
//printf("NULL ");
return;
}
printf("%c ", root->_data);
BinaryTreePrevOrder(root->_left);
BinaryTreePrevOrder(root->_right);
}
// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root)
{
if (root == NULL)
{
//printf("NULL ");
return;
}
BinaryTreePrevOrder(root->_left);
printf("%c ", root->_data);
BinaryTreePrevOrder(root->_right);
}
// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root)
{
if (root == NULL)
{
//printf("NULL ");
return;
}
BinaryTreePrevOrder(root->_left);
BinaryTreePrevOrder(root->_right);
printf("%c ", root->_data);
}
// 二叉树销毁
void BinaryTreeDestory2(BTNode* root)
{
if (root == NULL)
return;
BinaryTreeDestory2((root)->_left);
BinaryTreeDestory2((root)->_right);
free(root);
root = NULL;
}
// 二叉树节点个数
int BinaryTreeSize(BTNode* root)
{
if (root == NULL)
{
return 0;
}
return BinaryTreeSize(root->_left) + BinaryTreeSize(root->_right) + 1;
}
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root)
{
if (root == NULL)
return 0;
if (root->_left == NULL && root->_right == NULL)
return 1;
int size = BinaryTreeLeafSize(root->_left) + BinaryTreeLeafSize(root->_right);
return size;
}
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
if (k == 1)
return 1;
int cur = BinaryTreeLevelKSize(root->_left, k - 1) + BinaryTreeLevelKSize(root->_right, k - 1);
return cur;
}
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
if (root == NULL)
return NULL;
if (root->_data == x)
return root;
BTNode* cur = BinaryTreeFind(root->_left,x);
if (cur != NULL)
return cur;
BTNode* cur2 = BinaryTreeFind(root->_right, x);
if (cur2 != NULL)
return cur2;
return NULL;
}
// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)
{
Queue q1;
QueueInit(&q1);
if(root)
QueuePush(&q1, root);
while (!QueueEmpty(&q1))
{
BTNode* node = QueueFront(&q1);
QueuePop(&q1);
printf("%d ", node->_data);
if(node->_left)
QueuePush(&q1, node->_left);
if(node->_right)
QueuePush(&q1, node->_right);
}
QueueDestroy(&q1);
}
// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root)
{
if (root == NULL)
{
return 0;
}
Queue q1;
QueueInit(&q1);
if(root)
QueuePush(&q1, root);
while (!QueueEmpty(&q1))
{
BTNode* node = QueueFront(&q1);
QueuePop(&q1);
if (node == NULL)
{
break;
}
//printf("%d ", node->_data);
QueuePush(&q1, node->_left);
QueuePush(&q1, node->_right);
}
while (!QueueEmpty(&q1))
{
BTNode* node = QueueFront(&q1);
if (node != NULL)
return false;
QueuePop(&q1);
}
QueueDestroy(&q1);
return true;
}
6.堆的实现:
//写一个交换数的代码
void swap(HPDataType* a, HPDataType* b)
{
HPDataType tmp = *a;
*a = *b;
*b = tmp;
}
//向上调整法
void adjustup(HPDataType*a , int size)
{
int son = size-1;
int father = (son - 1) / 2;
while (father >= 0)
{
if (a[father] > a[son])
{
swap(&a[father], &a[son]);
son = father;
father = (son - 1) / 2;
}
else {
break;
}
}
}
//向下调整法 把大的往上调
void adjustdown(HPDataType* a,int size,int parent)
int child = 2 * parent + 1;
while (child < size)
{
if (a[child + 1] > a[child] && child +1 < size)//child +1 < size 没考虑
{
++child;
}
if (a[child] > a[parent])
{
swap(&a[child], &a[parent]);
parent = child;
child = 2 * parent + 1;
}
else {
break;
}
}
}
//向下调整法 把小的往上调
void adjustdown2(HPDataType* a, int size, int parent)
{
int child = 2 * parent + 1;
while (child < size)
{
if (a[child + 1] < a[child] && child + 1 < size)//child +1 < size 没考虑
{
++child;//选小的
}
if (a[child] < a[parent])
{
swap(&a[child], &a[parent]);
parent = child;
child = 2 * parent + 1;
}
else {
break;
}
}
}
//初始化
void HeapInit(Heap* hp)
{
hp->_a = NULL;
hp->_capacity = hp->_size = 0;
}
// 堆的销毁
void HeapDestory(Heap* hp)
{
assert(hp);
free(hp->_a);
}
// 堆的数据个数
int HeapSize(Heap* hp)
{
return hp->_size;
}
// 堆的判空
int HeapEmpty(Heap* hp)
{
if (HeapSize(hp) == 0)
{
return 1;
}
else
{
return 0;
}
}
// 取堆顶的数据
HPDataType HeapTop(Heap* hp)
{
assert(hp->_size);
return hp->_a[0];
}
// 堆的插入
void HeapPush(Heap* hp, HPDataType x)
{
if (hp->_size == hp->_capacity)
{
int newcapacity = hp->_capacity == 0 ? 4 : 2 * sizeof(hp->_capacity);
HPDataType* tmp = (HPDataType*)realloc(hp->_a,sizeof(HPDataType) * newcapacity);
if (tmp == NULL)
{
perror("realloc fail");
exit(-1);
}
hp->_a = tmp;
hp->_capacity = newcapacity;
}
hp->_a[hp->_size] = x;
hp->_size++;
adjustup(hp->_a, hp->_size);
}
// 堆的删除
void HeapPop(Heap* hp)
{
swap(&hp->_a[0], &hp->_a[hp->_size-1]);
hp->_size--;
adjustdown2(hp->_a, hp->_size,0);
}
//下面为 堆的排序
//降序: 小堆
void HeapSort1(int* a, int sz)
{
for (int i = 1; i <= sz; i++)// 建小堆的方法
{
adjustup(a, i);//把小的往上调,建小堆
}
//把最小的放后面
int end = sz - 1;
while (end > 0)
{
swap(&a[0], &a[end]);
adjustdown2(a, end, 0);
end--;
}
}
//升序: 大堆
void HeapSort2(int* a, int sz)
{
for (int i = (sz - 2) / 2; i >= 0; i--)//建大堆的方法
{
adjustdown(a, sz, i); //把大的往上调,建大堆
}
//把最大的放到最后面
int end = sz - 1;
while (end > 0)
{
swap(&a[0], &a[end]);
adjustdown(a, end, 0);
end--;
}
}