数据结构-二叉树

**节点的度：**一个节点含有的子树的个数称为该节点的度；如上图：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）棵互不相交的树的集合称为森林；

树的表示

树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，既然保存值域，也要保存结点和结点之间的关系，实际中树有很多种表示方式如：双亲表示法，孩子表示法、孩子双亲表示法以及孩子兄弟表示法等。我们这里就简单的了解其中最常用的孩子兄弟表示法。

cpp 复制代码

typedef int DataType;
struct Node
{
 struct Node* _firstChild1; // 第一个孩子结点
 struct Node* _pNextBrother; // 指向其下一个兄弟结点
 DataType _data; // 结点中的数据域
};

树在实际中的运用（表示文件系统的目录树结构）

二叉树概念及结构

概念

一棵二叉树是结点的一个有限集合，该集合:

1. 或者为空

2. 由一个根节点加上两棵别称为左子树和右子树的二叉树组成

从上图可以看出

二叉树不存在度大于2的结点
二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

注意：对于任意的二叉树都是由以下几种情况复合而成的：

现实中的二叉树：

特殊的二叉树：

**1. 满二叉树：**一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是2^k -1 ，则它就是满二叉树。

2. 完全二叉树： 完全二叉树是效率很高的数据结构 ，完全二叉树是由满二叉树而引出来的。

完全二叉树 是一种基于满二叉树定义的结构。想象一棵深度为 K 的满二叉树，把它的所有节点按从上到下、从左到右的顺序编上号 1,2,3,...,2^k−1

现在，如果你只保留前 n个节点（1≤n≤2^k−1），并且这些节点的位置和编号与满二叉树中的前 n个节点完全一致，那么这棵树就是完全二叉树。

简单说：完全二叉树 = 满二叉树从左上角开始，连续地砍掉最后一些节点（不能跳着砍）。

除了最后一层，上面每一层的节点都是满的（就像满二叉树那样）。
最后一层的节点都"靠左对齐"，即从左到右连续排列，中间不能有空缺。

注意：满二叉树是完全二叉树的一种特殊情况（当 n=2^k−1时）。

二叉树的性质

编号	性质描述	公式 / 说明
1	根节点层数为1时，第 i 层最多有多少个结点	最多 2(i−1)2(i−1) 个
2	根节点层数为1时，深度为 h 的二叉树的最大结点总数	2h−12h−1
3	任意二叉树中，叶子结点数（度为0）与度为2的结点数的关系	n0=n2+1n0=n2+1
4	具有 n 个结点的满二叉树的深度（根层数=1）	h=log⁡2(n+1)h=log2(n+1)
5	对完全二叉树，按从上到下、从左到右，从 0 开始编号，序号为 i 的结点：	• 左孩子序号：2i+12i+1 （若存在） • 右孩子序号：2i+22i+2 （若存在） • 父结点序号：⌊(i−1)/2⌋⌊(i−1)/2⌋ （若 i ≠ 0） • 结点总数 n 时，最后一个非叶子结点序号为 ⌊n/2⌋−1⌊n/2⌋−1

1. 某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（）

A 不存在这样的二叉树

B 200

C 198

D 199

2. 下列数据结构中，不适合采用顺序存储结构的是（）

A 非完全二叉树

B 堆

C 队列

D 栈

3. 在具有 2n 个结点的完全二叉树中，叶子结点个数为（）

A n

B n+1

C n-1

D n/2

4. 一棵完全二叉树的节点数位为531个，那么这棵树的高度为（）

A 11

B 10

C 8

D 12

5. 一个具有767个节点的完全二叉树，其叶子节点个数为（）

A 383

B 384

C 385

D 386

二叉树的存储结构

二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构。

1. 顺序存储

顺序结构存储就是使用数组来存储 ，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。而现实中使用中只有堆才会使用数组来存储，二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。

2. 链式存储

二叉树的链式存储结构是指，用链表来表示一棵二叉树 ，即用链来指示元素的逻辑关系。通常的方法是 链表中每个结点由三个域组成，数据域和左右指针域 ，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址。链式结构又分为二叉链和三叉链，当前我们学习中一般都是二叉链，学到高阶数据结构如红黑树等会用到三叉链。

cpp 复制代码

typedef int BTDataType;
// 二叉链
struct BinaryTreeNode
{
struct BinTreeNode* _pLeft; // 指向当前节点左孩子
 struct BinTreeNode* _pRight; // 指向当前节点右孩子
 BTDataType _data; // 当前节点值域
}

// 三叉链
struct BinaryTreeNode
{
 struct BinTreeNode* _pParent; // 指向当前节点的双亲
 struct BinTreeNode* _pLeft; // 指向当前节点左孩子
 struct BinTreeNode* _pRight; // 指向当前节点右孩子
 BTDataType _data; // 当前节点值域
}；

二叉树的顺序结构的实现

二叉树的顺序结构

普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储 ，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事 ，一个是数据结构，一个是操作系统中管理内存的一块区域分段。 数据结构里的"堆"不是内存中的堆区（malloc/new 出来的空间）。名字来源于：数据像"堆"起来一样，按大小层级堆叠。

堆的概念及结构

堆的本质：一种特殊的完全二叉树

堆（Heap）首先是一棵 完全二叉树。什么叫完全二叉树？

除了最后一层，其他层节点都填满；
最后一层的节点必须从左到右依次排列，中间不能有空缺。

例如下面这棵树（数字代表节点值，括号里是数组下标）就是完全二叉树：

bash 复制代码

        10 (0)
       /      \
      7 (1)    9 (2)
     / \      /
    5   6    8 
    (3) (4) (5)

用数组顺序存储 就是：[10, 7, 9, 5, 6, 8]。下标 i 的左孩子下标 = 2*i + 1，右孩子下标 = 2*i + 2。

堆的两种规则（大小堆）

在完全二叉树的基础上，再附加一条值的大小关系：

小堆（小根堆 / 最小堆）

规则：每个节点的值 ≤ 它的子节点的值。 即：K[i] ≤ K[2i+1] 且 K[i] ≤ K[2i+2]

根节点是最小值。
任意子树都是小堆。

举例（用小堆存储数据）：

bash 复制代码

        5 (0)
       /    \
      8 (1)  9 (2)
     / \    /
   10 12  11 
  (3) (4) (5)

数组：[5, 8, 9, 10, 12, 11]

检查：5 ≤ 8，5 ≤ 9；8 ≤ 10，8 ≤ 12；9 ≤ 11

2.大堆（大根堆 / 最大堆）

规则：每个节点的值 ≥ 它的子节点的值。 即：K[i] ≥ K[2i+1] 且 K[i] ≥ K[2i+2]

根节点是最大值。
任意子树都是大堆。

举例：

cpp 复制代码

       20 (0)
      /     \
    15 (1)   18 (2)
   /  \     /
  10  12   16 
  (3)  (4) (5)

概念	解释
逻辑结构	完全二叉树
物理存储	一维数组（按层序遍历顺序放）
小堆	父 ≤ 子（根最小）
大堆	父 ≥ 子（根最大）
兄弟之间	没有大小关系约束！比如小堆里左孩子可以大于右孩子，只要都 ≥ 父节点
堆 ≠ 二叉搜索树（BST）	BST: 左<根<右；堆：只保证父子关系，不保证左右大小

1.下列关键字序列为堆的是：（）

A 100,60,70,50,32,65

B 60,70,65,50,32,100

C 65,100,70,32,50,60

D 70,65,100,32,50,60

E 32,50,100,70,65,60

F 50,100,70,65,60,32

2.已知小根堆为8,15,10,21,34,16,12，删除关键字 8 之后需重建堆，在此过程中，关键字之间的比较次

数是（）。

A 1

B 2

C 3

D 4

3.一组记录排序码为(5 11 7 2 3 17),则利用堆排序方法建立的初始堆为

A(11 5 7 2 3 17)

B(11 5 7 2 17 3)

C(17 11 7 2 3 5)

D(17 11 7 5 3 2)

E(17 7 11 3 5 2)

F(17 7 11 3 2 5)

4.最小堆 $0,3,2,5,7,4,6,8$ ,在删除堆顶元素0之后，其结果是（）

A $3，2，5，7，4，6，8$

B $2，3，5，7，4，6，8$

C $2，3，4，5，7，8，6$

D $2，3，4，5，6，7，8$

堆的实现

堆结构定义：

cpp 复制代码

typedef int HPDataType;

typedef struct Heap
{
    HPDataType* _a;      // 动态数组
    int _size;           // 有效元素个数
    int _capacity;       // 数组容量
} Heap;

堆接口声明

cpp 复制代码

// 堆结构定义
typedef int HPDataType;

typedef struct Heap
{
    HPDataType* _a;      // 动态数组指针
    int _size;           // 当前元素个数
    int _capacity;       // 数组容量
} Heap;

// 堆的构建：用数组a中的n个元素建堆
void HeapCreate(Heap* hp, HPDataType* a, int n);

// 堆的销毁
void HeapDestory(Heap* hp);

// 堆的插入
void HeapPush(Heap* hp, HPDataType x);

// 堆的删除（删除堆顶）
void HeapPop(Heap* hp);

// 取堆顶的数据
HPDataType HeapTop(Heap* hp);

// 堆的数据个数
int HeapSize(Heap* hp);

// 堆的判空（空返回非0，非空返回0）
int HeapEmpty(Heap* hp);

堆向下调整算法

现在我们给出一个数组，逻辑上看做一颗完全二叉树。我们通过从根节点开始的向下调整算法可以把它调整成一个小堆。向下调整算法有一个前提：左右子树必须是一个堆，才能调整。

cpp 复制代码

int array[] = {27,15,19,18,28,34,65,49,25,37};

堆的创建

下面我们给出一个数组，这个数组逻辑上可以看做一颗完全二叉树，但是还不是一个堆，现在我们通过算法，把它构建成一个堆。根节点左右子树不是堆，我们怎么调整呢？这里我们从倒数的第一个非叶子节点的子树开始调整，一直调整到根节点的树，就可以调整成堆。

cpp 复制代码

int a[] = {1,5,3,8,7,6};

代码实现：

辅助函数：向下调整（小堆）

cpp 复制代码

// 交换两个元素
void Swap(HPDataType* px, HPDataType* py)
{
    HPDataType tmp = *px;
    *px = *py;
    *py = tmp;
}

// 向下调整（小堆）
void AdjustDown(HPDataType* a, int n, int root)
{
    int parent = root;
    int child = parent * 2 + 1;   // 左孩子下标
    while (child < n)
    {
        // 选出左右孩子中较小的一个
        if (child + 1 < n && a[child + 1] < a[child])
            ++child;
        // 如果孩子小于父亲，交换并继续向下
        if (a[child] < a[parent])
        {
            Swap(&a[child], &a[parent]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
            break;
    }
}

使用给定数组直接构建堆（采用向下调整法，时间复杂度 O(N)）

cpp 复制代码

void HeapCreate(Heap* hp, HPDataType* a, int n)
{
    assert(hp);
    hp->_a = (HPDataType*)malloc(sizeof(HPDataType) * n);
    if (hp->_a == NULL)
    {
        perror("malloc fail");
        exit(-1);
    }
    memcpy(hp->_a, a, sizeof(HPDataType) * n);
    hp->_size = n;
    hp->_capacity = n;

    // 从最后一个非叶子节点开始向下调整，建小堆
    for (int i = (n - 1 - 1) / 2; i >= 0; --i)
    {
        AdjustDown(hp->_a, hp->_size, i);
    }
}

建堆时间复杂度

因为堆是完全二叉树，而满二叉树也是完全二叉树，此处为了简化使用满二叉树来证明(时间复杂度本来看的就是近似值，多几个节点不影响最终结果)：

因此：建堆的时间复杂度为O(N)。

堆的插入

先插入一个10到数组的尾上，再进行向上调整算法，直到满足堆。

在尾部插入元素，然后向上调整保持堆结构

cpp 复制代码

// 向上调整（小堆）
void AdjustUp(HPDataType* a, int child)
{
    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(Heap* hp, HPDataType x)
{
    assert(hp);
    // 扩容
    if (hp->_size == hp->_capacity)
    {
        int newCapacity = hp->_capacity == 0 ? 4 : hp->_capacity * 2;
        HPDataType* tmp = (HPDataType*)realloc(hp->_a, sizeof(HPDataType) * newCapacity);
        if (tmp == NULL)
        {
            perror("realloc fail");
            return;
        }
        hp->_a = tmp;
        hp->_capacity = newCapacity;
    }
    hp->_a[hp->_size] = x;
    hp->_size++;
    AdjustUp(hp->_a, hp->_size - 1);
}

堆的删除

删除堆是删除堆顶的数据，将堆顶的数据根最后一个数据一换，然后删除数组最后一个数据，再进行向下调整算法。

交换堆顶与最后一个元素，删除最后一个元素，然后向下调整

cpp 复制代码

void HeapPop(Heap* hp)
{
    assert(hp);
    assert(hp->_size > 0);
    Swap(&hp->_a[0], &hp->_a[hp->_size - 1]);
    hp->_size--;
    AdjustDown(hp->_a, hp->_size, 0);
}

取堆顶的数据

返回数组第一个元素

cpp 复制代码

HPDataType HeapTop(Heap* hp)
{
    assert(hp);
    assert(hp->_size > 0);
    return hp->_a[0];
}

堆的数据个数

返回当前元素个数

cpp 复制代码

int HeapSize(Heap* hp)
{
    assert(hp);
    return hp->_size;
}

堆的判空

判断是否为空，空返回非0，非空返回0

cpp 复制代码

int HeapEmpty(Heap* hp)
{
    assert(hp);
    return hp->_size == 0 ? 1 : 0;
}

代码总

cpp 复制代码

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>

typedef int HPDataType;

typedef struct Heap
{
    HPDataType* _a;
    int _size;
    int _capacity;
} Heap;

// 辅助函数：交换
void Swap(HPDataType* px, HPDataType* py)
{
    HPDataType tmp = *px;
    *px = *py;
    *py = tmp;
}

// 向下调整（小堆）
void AdjustDown(HPDataType* a, int n, int root)
{
    int parent = root;
    int child = parent * 2 + 1;
    while (child < n)
    {
        // 选出左右孩子中较小的一个
        if (child + 1 < n && a[child + 1] < a[child])
            ++child;
        // 如果孩子小于父亲，交换并继续向下
        if (a[child] < a[parent])
        {
            Swap(&a[child], &a[parent]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
            break;
    }
}

// 向上调整（小堆）
void AdjustUp(HPDataType* a, int child)
{
    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;
    }
}

// 1. 堆的构建（向下调整建堆，O(N)）
void HeapCreate(Heap* hp, HPDataType* a, int n)
{
    assert(hp);
    hp->_a = (HPDataType*)malloc(sizeof(HPDataType) * n);
    if (hp->_a == NULL)
    {
        perror("malloc fail");
        exit(-1);
    }
    memcpy(hp->_a, a, sizeof(HPDataType) * n);
    hp->_size = n;
    hp->_capacity = n;

    // 从最后一个非叶子节点开始向下调整
    for (int i = (n - 1 - 1) / 2; i >= 0; --i)
    {
        AdjustDown(hp->_a, hp->_size, i);
    }
}

// 2. 堆的销毁
void HeapDestory(Heap* hp)
{
    assert(hp);
    free(hp->_a);
    hp->_a = NULL;
    hp->_size = 0;
    hp->_capacity = 0;
}

// 3. 堆的插入
void HeapPush(Heap* hp, HPDataType x)
{
    assert(hp);
    if (hp->_size == hp->_capacity)
    {
        int newCapacity = hp->_capacity == 0 ? 4 : hp->_capacity * 2;
        HPDataType* tmp = (HPDataType*)realloc(hp->_a, sizeof(HPDataType) * newCapacity);
        if (tmp == NULL)
        {
            perror("realloc fail");
            return;
        }
        hp->_a = tmp;
        hp->_capacity = newCapacity;
    }
    hp->_a[hp->_size] = x;
    hp->_size++;
    AdjustUp(hp->_a, hp->_size - 1);
}

// 4. 堆的删除（删除堆顶）
void HeapPop(Heap* hp)
{
    assert(hp);
    assert(hp->_size > 0);
    Swap(&hp->_a[0], &hp->_a[hp->_size - 1]);
    hp->_size--;
    AdjustDown(hp->_a, hp->_size, 0);
}

// 5. 取堆顶的数据
HPDataType HeapTop(Heap* hp)
{
    assert(hp);
    assert(hp->_size > 0);
    return hp->_a[0];
}

// 6. 堆的数据个数
int HeapSize(Heap* hp)
{
    assert(hp);
    return hp->_size;
}

// 7. 堆的判空
int HeapEmpty(Heap* hp)
{
    assert(hp);
    return hp->_size == 0 ? 1 : 0;
}

//测试
int main()
{
    Heap hp;
    int arr[] = { 15, 18, 19, 25, 28, 34, 65, 49, 27, 37 };
    int n = sizeof(arr) / sizeof(arr[0]);

    HeapCreate(&hp, arr, n);

    printf("堆顶: %d\n", HeapTop(&hp));          // 15
    printf("堆大小: %d\n", HeapSize(&hp));       // 10

    HeapPush(&hp, 10);
    printf("插入10后堆顶: %d\n", HeapTop(&hp));  // 10

    HeapPop(&hp);
    printf("删除堆顶后堆顶: %d\n", HeapTop(&hp)); // 15

    printf("剩余元素依次出堆: ");
    while (!HeapEmpty(&hp))
    {
        printf("%d ", HeapTop(&hp));
        HeapPop(&hp);
    }
    printf("\n");

    HeapDestory(&hp);
    return 0;
}

堆的应用

堆排序

堆排序即利用堆的思想来进行排序，总共分为两个步骤：

建堆

升序：建大堆

降序：建小堆

利用堆删除思想来进行排序

建堆和堆删除中都用到了向下调整，因此掌握了向下调整，就可以完成堆排序。

TOP-K问题

TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。

比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。

对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决，基本思路如下：

用数据集合中前K个元素来建堆

前k个最大的元素，则建小堆

前k个最小的元素，则建大堆

用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素

将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

求前K个最大的元素：先取前K个元素建小堆，堆顶是最小的候选。遍历剩余元素，若比堆顶大，则替换堆顶并向下调整。最后堆中即为前K个最大元素

求前K个最小的元素：建大堆，堆顶是最大的候选，遍历剩余元素，若比堆顶小则替换

接口声明

cpp 复制代码

// 打印前k个最大元素
void PrintTopK(int* a, int n, int k);

// 测试函数
void TestTopk();

辅助函数（堆操作）

cpp 复制代码

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <assert.h>

// 交换
void Swap(int* px, int* py)
{
    int tmp = *px;
    *px = *py;
    *py = tmp;
}

// 向下调整（小堆）
void AdjustDownSmall(int* a, int n, int root)
{
    int parent = root;
    int child = parent * 2 + 1;
    while (child < n)
    {
        if (child + 1 < n && a[child + 1] < a[child])
            ++child;
        if (a[child] < a[parent])
        {
            Swap(&a[child], &a[parent]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
            break;
    }
}

1 求前K个最大的元素（建小堆）

简单说明：用前K个元素建小堆，堆顶最小。遍历剩余元素，若比堆顶大则替换并向下调整，最后堆中即为前K个最大

cpp 复制代码

void PrintTopK(int* a, int n, int k)
{
    if (k <= 0 || k > n) return;

    // 1. 用前k个元素建小堆
    int* heap = (int*)malloc(sizeof(int) * k);
    if (heap == NULL)
    {
        perror("malloc fail");
        return;
    }
    for (int i = 0; i < k; ++i)
        heap[i] = a[i];

    // 建堆（向下调整）
    for (int i = (k - 1 - 1) / 2; i >= 0; --i)
        AdjustDownSmall(heap, k, i);

    // 2. 遍历剩余元素
    for (int i = k; i < n; ++i)
    {
        if (a[i] > heap[0])   // 比堆顶大
        {
            heap[0] = a[i];
            AdjustDownSmall(heap, k, 0);
        }
    }

    // 3. 输出前k个最大元素
    printf("前%d个最大元素: ", k);
    for (int i = 0; i < k; ++i)
        printf("%d ", heap[i]);
    printf("\n");

    free(heap);
}

2 测试函数

简单说明：构造含10000个随机数的数组，手动设置10个较大值，调用PrintTopK验证

cpp 复制代码

void TestTopk()
{
    int n = 10000;
    int* a = (int*)malloc(sizeof(int) * n);
    if (a == NULL)
    {
        perror("malloc fail");
        return;
    }
    srand((unsigned int)time(NULL));
    for (size_t i = 0; i < n; ++i)
    {
        a[i] = rand() % 1000000;
    }
    // 手动设置10个较大的数
    a[5] = 1000000 + 1;
    a[1231] = 1000000 + 2;
    a[531] = 1000000 + 3;
    a[5121] = 1000000 + 4;
    a[115] = 1000000 + 5;
    a[2335] = 1000000 + 6;
    a[9999] = 1000000 + 7;
    a[76] = 1000000 + 8;
    a[423] = 1000000 + 9;
    a[3144] = 1000000 + 10;

    PrintTopK(a, n, 10);
    free(a);
}

代码总

cpp 复制代码

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <assert.h>

void Swap(int* px, int* py)
{
    int tmp = *px;
    *px = *py;
    *py = tmp;
}

void AdjustDownSmall(int* a, int n, int root)
{
    int parent = root;
    int child = parent * 2 + 1;
    while (child < n)
    {
        if (child + 1 < n && a[child + 1] < a[child])
            ++child;
        if (a[child] < a[parent])
        {
            Swap(&a[child], &a[parent]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
            break;
    }
}

void PrintTopK(int* a, int n, int k)
{
    if (k <= 0 || k > n) return;

    int* heap = (int*)malloc(sizeof(int) * k);
    if (heap == NULL)
    {
        perror("malloc fail");
        return;
    }
    for (int i = 0; i < k; ++i)
        heap[i] = a[i];

    for (int i = (k - 1 - 1) / 2; i >= 0; --i)
        AdjustDownSmall(heap, k, i);

    for (int i = k; i < n; ++i)
    {
        if (a[i] > heap[0])
        {
            heap[0] = a[i];
            AdjustDownSmall(heap, k, 0);
        }
    }

    printf("前%d个最大元素: ", k);
    for (int i = 0; i < k; ++i)
        printf("%d ", heap[i]);
    printf("\n");

    free(heap);
}

void TestTopk()
{
    int n = 10000;
    int* a = (int*)malloc(sizeof(int) * n);
    if (a == NULL)
    {
        perror("malloc fail");
        return;
    }
    srand((unsigned int)time(NULL));
    for (size_t i = 0; i < n; ++i)
    {
        a[i] = rand() % 1000000;
    }
    a[5] = 1000000 + 1;
    a[1231] = 1000000 + 2;
    a[531] = 1000000 + 3;
    a[5121] = 1000000 + 4;
    a[115] = 1000000 + 5;
    a[2335] = 1000000 + 6;
    a[9999] = 1000000 + 7;
    a[76] = 1000000 + 8;
    a[423] = 1000000 + 9;
    a[3144] = 1000000 + 10;

    PrintTopK(a, n, 10);
    free(a);
}

int main()
{
    TestTopk();//1000007 1000006 1000005 1000009 1000008 1000010 1000004 1000003 1000002 1000001
    return 0;
}

二叉树链式结构的实现

在学习二叉树的基本操作前，需先要创建一棵二叉树，然后才能学习其相关的基本操作。此处手动快速创建一棵简单的二叉树，快速进入二叉树操作学习

cpp 复制代码

typedef int BTDataType;
typedef struct BinaryTreeNode
{
 BTDataType _data;
 struct BinaryTreeNode* _left;
 struct BinaryTreeNode* _right;
}BTNode;
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;
}

再看二叉树基本操作前，再回顾下二叉树的概念，二叉树是：

空树
非空：根节点，根节点的左子树、根节点的右子树组成的。

从概念中可以看出，二叉树定义是递归式的，因此后序基本操作中基本都是按照该概念实现的。

二叉树的遍历

前序、中序以及后序遍历

学习二叉树结构，最简单的方式就是遍历。所谓二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉树中的节点进行相应的操作，并且每个节点只操作一次。访问结点所做的操作依赖于具体的应用问题。遍历是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。

按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历：

前序遍历(Preorder Traversal 亦称先序遍历)------访问根结点的操作发生在遍历其左右子树之前。
中序遍历(Inorder Traversal)------访问根结点的操作发生在遍历其左右子树之中（间）。
后序遍历(Postorder Traversal)------访问根结点的操作发生在遍历其左右子树之后

由于被访问的结点必是某子树的根，所以N(Node）、L(Left subtree）和R(Right subtree）又可解释为根、根的左子树和根的右子树。NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。

前序遍历递归图解：

前序遍历结果：1 2 3 4 5 6

中序遍历结果：3 2 1 5 4 6

后序遍历结果：3 2 5 6 4 1

接口实现

cpp 复制代码

typedef int BTDataType;
// 二叉链
struct BinaryTreeNode
{
struct BinTreeNode* _pLeft; // 指向当前节点左孩子
 struct BinTreeNode* _pRight; // 指向当前节点右孩子
 BTDataType _data; // 当前节点值域
}

// 三叉链
struct BinaryTreeNode
{
 struct BinTreeNode* _pParent; // 指向当前节点的双亲
 struct BinTreeNode* _pLeft; // 指向当前节点左孩子
 struct BinTreeNode* _pRight; // 指向当前节点右孩子
 BTDataType _data; // 当前节点值域
}；

二叉树结点结构定义

cpp 复制代码

typedef int BTDataType;

// 二叉链结点
typedef struct BinaryTreeNode
{
    struct BinaryTreeNode* _pLeft;   // 左孩子指针
    struct BinaryTreeNode* _pRight;  // 右孩子指针
    BTDataType _data;                // 结点数据
} BTNode;

1. 创建二叉树结点

动态申请一个结点，将数据存入，左右指针置为 NULL。返回结点指针

cpp 复制代码

BTNode* BuyBTNode(BTDataType x)
{
    BTNode* newNode = (BTNode*)malloc(sizeof(BTNode));
    if (newNode == NULL)
    {
        perror("malloc fail");
        exit(-1);
    }
    newNode->_data = x;
    newNode->_pLeft = NULL;   // 左孩子初始为空
    newNode->_pRight = NULL;  // 右孩子初始为空
    return newNode;
}

2 二叉树前序遍历（根左右）

先访问根结点，再递归遍历左子树，最后递归遍历右子树

cpp 复制代码

void PreOrder(BTNode* root)
{
    if (root == NULL)
    {
        printf("NULL ");
        return;
    }
    printf("%d ", root->_data);
    PreOrder(root->_pLeft);
    PreOrder(root->_pRight);
}

3 二叉树中序遍历（左根右）

先递归遍历左子树，再访问根结点，最后递归遍历右子树

cpp 复制代码

void InOrder(BTNode* root)
{
    if (root == NULL)
    {
        printf("NULL ");
        return;
    }
    InOrder(root->_pLeft);
    printf("%d ", root->_data);
    InOrder(root->_pRight);
}

4 二叉树后序遍历（左右根）

先递归遍历左子树，再递归遍历右子树，最后访问根结点

cpp 复制代码

void PostOrder(BTNode* root)
{
    if (root == NULL)
    {
        printf("NULL ");
        return;
    }
    PostOrder(root->_pLeft);
    PostOrder(root->_pRight);
    printf("%d ", root->_data);
}

5 二叉树层序遍历（广度优先）

层序遍历：除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。

使用队列辅助，先将根结点入队，然后循环：出队一个结点，访问它，再将其左右孩子（非空）入队，直到队列为空

cpp 复制代码

#include <queue>   // C++ 使用 queue，C 需要自己实现队列，此处演示使用 C++ 标准库

void LevelOrder(BTNode* root)
{
    if (root == NULL) return;
    queue<BTNode*> q;
    q.push(root);
    while (!q.empty())
    {
        BTNode* front = q.front();
        q.pop();
        printf("%d ", front->_data);
        if (front->_pLeft) q.push(front->_pLeft);
        if (front->_pRight) q.push(front->_pRight);
    }
}

6 求二叉树结点个数

递归：结点个数 = 左子树结点数 + 右子树结点数 + 1（根结点），空树返回 0

cpp 复制代码

int BinaryTreeSize(BTNode* root)
{
    if (root == NULL)
        return 0;
    return BinaryTreeSize(root->_pLeft) + BinaryTreeSize(root->_pRight) + 1;
}

7 求二叉树叶子结点个数

叶子结点：左右孩子均为空，递归：叶子数 = 左子树叶子数 + 右子树叶子数，空树返回 0，遇到叶子返回 1

cpp 复制代码

int BinaryTreeLeafSize(BTNode* root)
{
    if (root == NULL)
        return 0;
    if (root->_pLeft == NULL && root->_pRight == NULL)
        return 1;
    return BinaryTreeLeafSize(root->_pLeft) + BinaryTreeLeafSize(root->_pRight);
}

8 求二叉树第 k 层结点个数

k=1 时返回 1（当前层有一个根结点），否则返回左子树第 k-1 层 + 右子树第 k-1 层结点数

cpp 复制代码

int BinaryTreeLevelKSize(BTNode* root, int k)
{
    if (root == NULL)
        return 0;
    if (k == 1)
        return 1;
    return BinaryTreeLevelKSize(root->_pLeft, k - 1) +
           BinaryTreeLevelKSize(root->_pRight, k - 1);
}

9 查找二叉树中值为 x 的结点

先检查根，若根的值等于 x 则返回根指针，否则在左子树中找，找到则返回，找不到再在右子树中找

cpp 复制代码

BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
    if (root == NULL)
        return NULL;
    if (root->_data == x)
        return root;
    BTNode* leftRet = BinaryTreeFind(root->_pLeft, x);
    if (leftRet)
        return leftRet;
    return BinaryTreeFind(root->_pRight, x);
}

10 求二叉树的高度（最大深度）

高度 = max(左子树高度, 右子树高度) + 1，空树高度为 0

cpp 复制代码

int BinaryTreeHeight(BTNode* root)
{
    if (root == NULL)
        return 0;
    int leftH = BinaryTreeHeight(root->_pLeft);
    int rightH = BinaryTreeHeight(root->_pRight);
    return (leftH > rightH ? leftH : rightH) + 1;
}

11 销毁二叉树

后序遍历释放结点：先释放左子树，再释放右子树，最后释放根，并将根指针置空

cpp 复制代码

void BinaryTreeDestroy(BTNode** root)
{
    if (*root == NULL)
        return;
    BinaryTreeDestroy(&((*root)->_pLeft));
    BinaryTreeDestroy(&((*root)->_pRight));
    free(*root);
    *root = NULL;
}

代码总

cpp 复制代码

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef int BTDataType;

typedef struct BinaryTreeNode
{
    struct BinaryTreeNode* _pLeft;
    struct BinaryTreeNode* _pRight;
    BTDataType _data;
} BTNode;

// 队列结构（用于层序遍历）
typedef struct QueueNode
{
    BTNode* _node;
    struct QueueNode* _next;
} QueueNode;

typedef struct Queue
{
    QueueNode* _front;
    QueueNode* _rear;
    int _size;
} Queue;

void QueueInit(Queue* q)
{
    assert(q);
    q->_front = q->_rear = NULL;
    q->_size = 0;
}

void QueuePush(Queue* q, BTNode* node)
{
    QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
    newNode->_node = node;
    newNode->_next = NULL;
    if (q->_front == NULL)
        q->_front = q->_rear = newNode;
    else
    {
        q->_rear->_next = newNode;
        q->_rear = newNode;
    }
    q->_size++;
}

void QueuePop(Queue* q)
{
    assert(q && q->_front);
    QueueNode* del = q->_front;
    q->_front = q->_front->_next;
    if (q->_front == NULL)
        q->_rear = NULL;
    free(del);
    q->_size--;
}

BTNode* QueueFront(Queue* q)
{
    assert(q && q->_front);
    return q->_front->_node;
}

int QueueEmpty(Queue* q)
{
    return q->_front == NULL;
}

void QueueDestroy(Queue* q)
{
    while (!QueueEmpty(q))
        QueuePop(q);
    q->_front = q->_rear = NULL;
    q->_size = 0;
}
//队列结构结束 

BTNode* BuyBTNode(BTDataType x)
{
    BTNode* newNode = (BTNode*)malloc(sizeof(BTNode));
    if (newNode == NULL)
    {
        perror("malloc fail");
        exit(-1);
    }
    newNode->_data = x;
    newNode->_pLeft = NULL;
    newNode->_pRight = NULL;
    return newNode;
}

void PreOrder(BTNode* root)
{
    if (root == NULL)
    {
        printf("NULL ");
        return;
    }
    printf("%d ", root->_data);
    PreOrder(root->_pLeft);
    PreOrder(root->_pRight);
}

void InOrder(BTNode* root)
{
    if (root == NULL)
    {
        printf("NULL ");
        return;
    }
    InOrder(root->_pLeft);
    printf("%d ", root->_data);
    InOrder(root->_pRight);
}

void PostOrder(BTNode* root)
{
    if (root == NULL)
    {
        printf("NULL ");
        return;
    }
    PostOrder(root->_pLeft);
    PostOrder(root->_pRight);
    printf("%d ", root->_data);
}

void LevelOrder(BTNode* root)
{
    if (root == NULL) return;
    Queue q;
    QueueInit(&q);
    QueuePush(&q, root);
    while (!QueueEmpty(&q))
    {
        BTNode* front = QueueFront(&q);
        QueuePop(&q);
        printf("%d ", front->_data);
        if (front->_pLeft) QueuePush(&q, front->_pLeft);
        if (front->_pRight) QueuePush(&q, front->_pRight);
    }
    QueueDestroy(&q);
}

int BinaryTreeSize(BTNode* root)
{
    if (root == NULL) return 0;
    return BinaryTreeSize(root->_pLeft) + BinaryTreeSize(root->_pRight) + 1;
}

int BinaryTreeLeafSize(BTNode* root)
{
    if (root == NULL) return 0;
    if (root->_pLeft == NULL && root->_pRight == NULL) return 1;
    return BinaryTreeLeafSize(root->_pLeft) + BinaryTreeLeafSize(root->_pRight);
}

int BinaryTreeLevelKSize(BTNode* root, int k)
{
    if (root == NULL) return 0;
    if (k == 1) return 1;
    return BinaryTreeLevelKSize(root->_pLeft, k - 1) +
           BinaryTreeLevelKSize(root->_pRight, k - 1);
}

BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
    if (root == NULL) return NULL;
    if (root->_data == x) return root;
    BTNode* leftRet = BinaryTreeFind(root->_pLeft, x);
    if (leftRet) return leftRet;
    return BinaryTreeFind(root->_pRight, x);
}

int BinaryTreeHeight(BTNode* root)
{
    if (root == NULL) return 0;
    int leftH = BinaryTreeHeight(root->_pLeft);
    int rightH = BinaryTreeHeight(root->_pRight);
    return (leftH > rightH ? leftH : rightH) + 1;
}

void BinaryTreeDestroy(BTNode** root)
{
    if (*root == NULL) return;
    BinaryTreeDestroy(&((*root)->_pLeft));
    BinaryTreeDestroy(&((*root)->_pRight));
    free(*root);
    *root = NULL;
}

int main()
{
    // 手动构建二叉树
    BTNode* n1 = BuyBTNode(1);
    BTNode* n2 = BuyBTNode(2);
    BTNode* n3 = BuyBTNode(3);
    BTNode* n4 = BuyBTNode(4);
    BTNode* n5 = BuyBTNode(5);
    BTNode* n6 = BuyBTNode(6);

    n1->_pLeft = n2;
    n1->_pRight = n3;
    n2->_pLeft = n4;
    n2->_pRight = n5;
    n3->_pLeft = n6;

    printf("前序遍历: ");
    PreOrder(n1);               // 1 2 4 NULL NULL 5 NULL NULL 3 6 NULL NULL NULL
    printf("\n");

    printf("中序遍历: ");
    InOrder(n1);                // NULL 4 NULL 2 NULL 5 NULL 1 NULL 6 NULL 3 NULL
    printf("\n");

    printf("后序遍历: ");
    PostOrder(n1);              // NULL NULL 4 NULL NULL 5 2 NULL NULL 6 NULL 3 1
    printf("\n");

    printf("层序遍历: ");
    LevelOrder(n1);             // 1 2 3 4 5 6
    printf("\n");

    printf("结点个数: %d\n", BinaryTreeSize(n1));          // 6
    printf("叶子结点个数: %d\n", BinaryTreeLeafSize(n1));  // 3
    printf("第3层结点个数: %d\n", BinaryTreeLevelKSize(n1, 3)); // 3
    printf("查找值为5的结点: %p\n", (void*)BinaryTreeFind(n1, 5)); // 0x7f8a3c2b1e00
    printf("二叉树高度: %d\n", BinaryTreeHeight(n1));      // 3

    BinaryTreeDestroy(&n1);
    return 0;
}

二叉树基础oj练习

8 . 二叉树的构建及遍历。二叉树遍历_牛客题霸_牛客网