树概念及结构
1.1树的概念
树是一种非线性结构，它是由n(n>=0)个有限节点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一颗倒挂的树。
- 有一个特殊的节点，称为根节点，他是没有前驱节点。
- 除根节点外，其余结点都被分为M个互不相交的集合，其中每一个集合又是另外一颗结构与树类似的子树，每颗子树的节点有且只有一个前驱节点，可以有0或多个后继。
- 树形结构中，子树之间不能有交集，否则就不是树形结构
1.2树的相关基础知识
节点的度：一个结点含有的子树的个数称为该节点的度；如上图：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）棵互不相交的树的集合称为森林；
1.3树的表示
树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，既然保存值域，也要保存结点和结点之间的关系，实际中树有很多种表示方式如：双亲表示法，孩子表示法、孩子双亲表示法以及孩子兄弟表示法等。我们这里就简单的了解其中最常用的孩子兄弟表示法。
struct Node{
struct Node* firstChild;
struct Node* brother;
int val;
};
1.4树在实际中的运用
最为典型的运用是：电脑的目录结构
2.二叉树的概念及结构
2.1概念
一颗二叉树是节点的一个有限集合，该集合:
1.为空
2.由由一个根节点加上两颗别称为左子树和右子树的二叉树组成
由上图可以看出：
二叉树不存在度大于2的结点
二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树
2.2特殊的二叉树
1.满二叉树：一个二叉树，如果每一层的结点都达到最大值，那么这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为k，且结点的总数总是2k-1,则它就是满二叉树。
2.完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对
应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。完全二叉树度为1的结点最多只有1，且满二叉树从左到右是要连续的
2.3二叉树的性质
1.若二叉树结点的层数为1，则一颗非空二叉树的第i层上最多只有2(i-1)个结点
2.若根节点的层数为1，则深度为h的二叉树的最多结点数为2h-1;
3.对于一个二叉树，如果度为0的结点有n0个,度为2的结点有n2个，则有n0=n2+1
4.若规定根节点层数为1，具有n个结点的满二叉树的深度，h=log2(n+1)
5. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对于序号为i的结点有：
1.若i>0,i位置结点的双亲序号为(i-1)/2,若i==0,i为根节点，无双亲结点
若2i+1<n,则左孩子序号为2i+1,2i+1>=n否则无左孩子
若2i+2<n,则有孩子序号为2i+2,2i+2>=n否则无孩子
练习题
1.某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（ ）
A 不存在这样的二叉树
B. 200
C 198
D 199
根据结论：在二叉树中度为0的结点比度为2的结点多1，so 叶子结点为200个，故选B
2.在具有 2n 个结点的完全二叉树中，叶子结点个数为（ ）
A n
B n+1
C n-1
D n/2
此树是完全二叉树，且总的结点是2n个,求度为0的个数，根据结论完全二叉树中度为1的结点最多只有一个，且度为0的结点比度为2的结点还多一个，由此可以列一个式子：
n0+n1+n2=2n,且n0=n2+1
2n0-1+n1=2n,由于n1的最大取值为1
推出n0=n,故选B
3.一棵完全二叉树的节点数位为531个，那么这棵树的高度为（ ）
A 11
B 10
C 8
D 12
此树为完全二叉树，可以假设此树的结点位于两颗相差高度为1的满二叉树直接故可以直接带2h-1检测一下，此树树的结点在那一层，B
4.一个具有767个节点的完全二叉树，其叶子节点个数为（）
A 383
B 384
C 385
D 386
树为完全二叉树，根据t2的思路可以直接得到2n0-1+n1=767，所以得到n0=384，故选B
3二叉树的顺序结构
3.1二叉树的顺序结构
普通的二叉树是不适合用数组来储存的，因为有可能存在空间浪费。而完全二叉树更适合使用顺序结构来存储，现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。
3.2堆的概念及结构
如果有一个关键码的集合K = { ， ， ，…， }，把它的所有元素按完全二叉树的顺序存储方式存储，在一个一维数组中，并满足： <= 且 <= ( >= 且 >= ) i = 0，1，2…，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。
堆的性质：
堆中某个节点的值总是不大于或不小于其父节点的值；
堆总是一棵完全二叉树。
3.3堆的存储
堆的物理结构是以数组的方式进行储存，逻辑结构是一个完全二叉树。
堆中，父与子的位置一个计算公式
计算左孩子：leftchild=parent2+1；
计算有孩子：rightchild=parent2+2；
通过孩子计算父亲的：parent=（child-1）/2
堆排序
堆向下调整
若想将其调整为小堆，那个根节点的左右子树都必须是小堆。
若想将其调整为大堆，那么根结点的左右子树必须都为大堆。
//建小堆
void AdjustDown(int* a, int n, int parent)
{
int child = parent * 2 + 1;
while (child <n)//下标
{
//符号规范？？？ 大堆用》,小堆用《
if (a[child + 1] < a[child]&&(child+1)<n)//防止出现没有右孩子，越界？？
{
++child;
}
//如果小的孩子小于父亲，则交换，并继续向下调
if (a[parent] < a[child])
{
swap(&a[parent], &a[child]);//交换函数，交换两个结点的值
parent = child;
child = parent * 2 + 1;
}
else {
break;
}
}
}
堆向上调整算法
void AdjustUp(int* a, int child)
{
assert(a);
int parent = (child - 1) / 2;
while (child>0)
{
if (a[child] > a[parent])
{
swap(&a[child], &a[parent]);
child = parent;
parent = (child - 1) / 2;
}
else {
break;
}
}
}
堆排序
数组升序，建立大堆
数组降序，建立小堆
void SortHeap(int* a,int n)
{
for (int i = (n - 1 - 1) / 2; i >= 0; i--)
{
AdjustDown(arr, n, i);
}
//堆排
int end = n - 1;
while (end > 0)
{
Swap(&arr[end], &arr[0]);
AdjustDown(arr, end, 0);
end--;
}
}
堆的接口
void SortHeap(int* a,int n)
{
for (int i = (n - 1 - 1) / 2; i >= 0; i--)
{
AdjustDown(arr, n, i);
}
//堆排
int end = n - 1;
while (end > 0)
{
Swap(&arr[end], &arr[0]);
AdjustDown(arr, end, 0);
end--;
}
}
void swap(HPDataType* px, HPDataType* py)
{
HPDataType tmp = *px;
*px = *py;
*py = tmp;
}
void HeapPrint(HP* hp)
{
int i = 0;
for (i = 0; i < hp->size; ++i)
{
printf("%d ", hp->a[i]);
}
printf("\n");
}
void HeapInit(HP* hp)
{
assert(hp);
hp->a = NULL;
hp->size = hp->capacity = 0;
}
void HeapDestory(HP* hp)
{
assert(hp);
free(hp->a);
hp->capacity = hp->size = 0;
}
void AdjustUp(int* a, int child)
{
assert(a);
int parent = (child - 1) / 2;
while (child>0)
{
if (a[child] > a[parent])
{
swap(&a[child], &a[parent]);
child = parent;
parent = (child - 1) / 2;
}
else {
break;
}
}
}
void HeapPush(HP* hp, HPDataType x)
{
assert(hp);
if(hp->capacity == hp->size)
{
size_t newCapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
HPDataType* tmp = realloc(hp->a, newCapacity*sizeof(HPDataType));
if (tmp == NULL)
exit(-1);
hp->a = tmp;
hp->capacity = newCapacity;
}
hp->a[hp->size] = x;
hp->size++;
AdjustUp(hp->a, hp->size - 1);//数组间的变化
}
void AdjustDown(int* a, int n, int parent)
{
int child = parent * 2 + 1;
while (child <n)//下标
{
//符号规范？？？ 大堆用》,小堆用《
if ((child+1)<na[child + 1] > a[child])
{
++child;
}
//如果相对较小的孩子小于父亲，则交换，并继续向下调
if (a[parent] > a[child])
{
swap(&a[parent], &a[child]);//交换函数，交换两个结点的值
parent = child;
child = parent * 2 + 1;
}
else {
break;
}
}
}
void HeapPop(HP* hp)
{
assert(hp);
assert(!HeapEmpty(hp));
swap(&hp->a[0],&hp->a[hp->size-1]);
hp->size--;
AdjustDown(hp->a, hp->size, 0);
}
bool HeapEmpty(HP* hp)
{
return hp->size == 0;
}
int HeapSize(HP* hp)
{
assert(hp);
assert(hp->size > 0);
return hp->size-1;
}
HPDataType HeapTop(HP* hp)
{
assert(hp);
assert(hp->size > 0);
return hp->a[0];
}
topk的题目
最大的k个数，建一个小堆。堆顶放最小值，与最小值相比，比最小值大，就与最小值交换，并且使用向下调整算法
最小的k个数，建立一个大堆，堆顶放最大值，与最大值相比，比最大值小，就与最大值交换，并且使用向下调整算法
/**
* Note: The returned array must be malloced, assume caller calls free().
*/
typedef int HPDataType;
typedef struct Heap
{
HPDataType* a;
int size;
int capacity;
}HP;
void HeapPrint(HP* hp)
{
for (int i = 0; i < hp->size; ++i)
{
printf("%d ", hp->a[i]);
}
}
void HeapInit(HP* hp)
{
hp->a = NULL;
hp->size = hp->capacity = 0;
}
void swap(HPDataType* px, HPDataType* py)
{
HPDataType tmp = *px;
*px = *py;
*py = tmp;
}
void AdjustUp(int* a, int child)
{
assert(a);
int parent = (child - 1) / 2;
while (child > 0)
{
if (a[parent] < a[child])
{
swap(&a[parent], &a[child]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
void AdjustDown(int* a, int n, int parent)
{
int child = parent * 2 + 1;
while (child < n)
{
if (child + 1 < n&&a[child + 1] > a[child] )//数组越界问题？？？
{
++child;
}
if (a[parent] < a[child])
{
swap(&a[parent], &a[child]);
parent = child;
child = parent * 2 + 1;
}
else {
break;
}
}
}
void HeapPush(HP* hp, HPDataType x)
{
assert(hp);
if (hp->size == hp->capacity)
{
size_t newcapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
HPDataType* tmp = (HPDataType*)realloc(hp->a, sizeof(HPDataType) * newcapacity);
if (tmp == NULL)
exit(-1);
hp->capacity = newcapacity;
hp->a = tmp;
}
hp->a[hp->size] = x;
hp->size++;
AdjustUp(hp->a, hp->size - 1);
}
bool HeapEmpty(HP* hp)
{
return hp->size == 0;
}
HPDataType HeapTop(HP* hp)
{
assert(hp);
assert(!HeapEmpty(hp));
return hp->a[0];
}
void HeapDestory(HP* hp) {
free(hp->a);
hp->size = hp->capacity = 0;
}
int* smallestK(int* arr, int arrSize, int k, int* returnSize) {
*returnSize = k;
if (arrSize == 0 || k == 0)
return NULL;
int* retu = (int*)malloc(sizeof(int) * k);
HP hp;//建堆
HeapInit(&hp);//初始化堆
for (int i = 0; i < k; ++i)
{
HeapPush(&hp, arr[i]);//建大堆
}
for (int i = k; i < arrSize; i++)
{
if (arr[i] < HeapTop(&hp))
{
hp.a[0]=arr[i];
AdjustDown(hp.a, hp.size, 0);
}
}
HeapPrint(&hp);
for (int i = 0; i < k; ++i)
{
retu[i] = hp.a[i];
}
HeapDestory(&hp);
return retu;
}
仅供参考
1489
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
