二叉树（第一章）

一.树概念及结构

1.1树的概念

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。

有一个特殊的结点，称为根结点，根节点没有前驱结点

除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i<= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继。

因此，树是递归定义的。每棵树（包括子树）都是由1个根节点和n个子树构成（n>=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的祖先）（Q也是Q的祖先）

子孙：

    以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是A的子孙

森林：

    由m（m>0）棵互不相交的树的集合称为森林，并查集相关内容。

1.3树的表示

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

一些表示方法：

#define  N  5 //知道度的情况下

struct  TreeNode

{

    int  val;

    struct  TreeNode* subs[N];

}; //这样空间浪费比较严重

struct  TreeNode

{

    int  val;

    SeqList  _sl; //由顺序表来完成对子节点的链接

};

但这些都不够好，介绍一下孩子兄弟表示法。这是存储树最优秀的方法

typedef int DataType;

struct Node

{

    struct Node* _firstChild1;           // 第一个孩子结点

    struct Node* _pNextBrother;     // 指向其下一个兄弟结点

    DataType _data;                         // 结点中的数据域

};

一个节点有多少孩子都无所谓，父亲指向第一个孩子，剩下的孩子用兄弟（指的是亲兄弟）链接起来。

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

这些结构了解一下就可以了，不是重点。

二.二叉树的概念及结构

2.1概念

二叉树就是度为2的树。

从上图可以看出：

1. 二叉树不存在度大于2的结点

2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

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

二叉树中有两种特殊的二叉树，分别是：

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

2. 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树

后面会通过完全二叉树实现堆的数据结构（同样和操作系统中的堆没有关系）。

下面介绍一下堆的简单特性（假设储存的是字符ABCEDFGHIJ，数字是数组中的下标）：

堆的逻辑结构是一个完全二叉树，物理结构则是一个数组。可以通过如下公式推导出父亲节点的左子树右子树。

父子间下标关系计算公式：

leftchild = parent*2 + 1;

rightchild = parent*2 + 2;

parent = (child-1)/2; //右孩子必定是偶数

2.2二叉树的性质

1. 若规定根节点的层数为1，则一棵非空二叉树的 第 i 层上最多有2^(i-1)个结点.

2. 若规定根节点的层数为1，则 深度为 h 的二叉树的最大结点数是2^h-1。（ 假设它为一个满四叉树，高度为h，则这个数的节点个数为(4^h - 1) / 3）

3. 对任何一棵非空二叉树, 如果度为 0 其叶结点个数为n0 , 度为 2 的分支结点个数为n2  , 则有 n0＝n2＋ 1（这点比较重要）

4. 若规定根节点的层数为1，具有 n 个结点的满二叉树的深度， h= log(n+1). (ps： 是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的树中，度为3的结点有2个，度为2的结点有1个，度为1的结点有2个，则叶子结点有（6）个

设度为i的节点个数为ni, 该树总共有n个节点,则n=n0+n1+n2+n3. 

有n个节点的树的总边数为n-1条.

根据度的定义,总边数与度之间的关系为：n-1=0*n0+1*n1+2*n2+3*n3.

联立两个方程求解,可以得到n0 = n2 + 2n3 + 1,  n0=6

2.3二叉树的存储 

二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构。一般是顺序结构更优，链式结构要每个节点要使用额外的空间来建立指向子节点的指针。孩子兄弟表示法是多叉树的情况。

1. 顺序存储

顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。实际上硬要表示非完全二叉树也是可以的。二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。

2. 链式存储

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

三.二叉树的顺序结构和实现

3.1 二叉树的顺序结构

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

3.2 堆的概念及结构

堆的性质：

    堆中某个节点的值总是不大于或不小于其父节点的值；

    堆总是一棵完全二叉树。

大堆/大根堆：所以父亲节点都大于等于孩子节点

小堆/小根堆：所以父亲节点都小于等于孩子节点

通常用来解决堆排序，topk。堆的数据不一定有序，有序一定是堆。

3.3堆的实现

完成基本的准备后，先定义堆的基本结构

typedef  int  HeapDateType;

typedef  struct  Heap

{

    HeapDateType*  a;

    size_t  size;

    size_t  capacity;

}Heap;

基本结构和顺序表是一样的。

然后是一些基本函数

void  HeapInit(heap*  php);

void  HeapDestroy(heap*  php);

void  HeapPush(heap*  php, HeapDateType  x);

void  HeapPop(heap*  php);

其中初始化和销毁是很熟悉的了

void  HeapInit(Heap* php)

{

        assert(php);

        php->a = NULL;

        php->size = php->capacity = 0;

}

void  HeapDestroy(Heap* php)

{

        assert(php);

        free(php->a);

        php->a = NULL;

        php->size = php->capacity = 0;

}

重点是push。当push不同的值时会有不同的变化，比如下图的情况

当插入的数据是10时，结构就不是堆了，需要通过堆的向上调整算法（和他的祖先比较，如果一直小于就不断调整位置，直到符合堆的性质），重新调整为小堆，当插入数据为30时，仍然符合堆的性质。就不用进行调整了。还有，要考虑空间不够，需要扩容的情况。

push函数代码如下：

void  HeapPush(Heap* php, HeapDateType x)

{

        assert(php);

        if (php->size == php->capacity) //增容情况

        {

               int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;

               HeapDateType* tmp = (HeapDateType*)realloc(php->a, sizeof(HeapDateType) * newcapacity);

               if (tmp == NULL)

               {

                       printf("realloc fail\n");

                       exit(-1);

               }

               else

               {

                       php->a = tmp;

                       php->capacity = newcapacity;

               }

        }

        php->a[php->size] = x;

        size_t child = php->size;

        php->size++;

        while ((child - 1) / 2 >= 0 && php->a[child] < php->a[(child-1)/2]) //向上调整算法

        {

               HeapDateType tmp = php->a[(child - 1) / 2];

               php->a[(child - 1) / 2] = php->a[child];

               php->a[child] = tmp;

               child = (child - 1) / 2;

        }

}

堆的数据插入并没有明确要求，只是要保证在插入后还要是堆，并且尽量选择效率高的方式。所以堆的插入一般都选择在最后位置。头插和中间插会导致堆的结构混乱。而尾插只会影响当前叶节点的祖先。综合考虑是尾插的效率更高。

向上调整函数在其他地方也会用到，化为函数形式。

void AdjustUp(Heap* php, size_t child)

{

        while ((child - 1) / 2 >= 0 && php->a[child] < php->a[(child - 1) / 2]) //小堆尽量使用小于号

//这里其实是有问题的， child是无符号类型， ( child - 1) / 2 的值是21亿多，造成了非法访问，测试没有问题1.是还没有释放空间，没有检查是否越界。2.是 php ->a[( child - 1) / 2]对应的随机值刚好为负。

//所以要避免这类问题就要使代码形式尽量简单，比如Adjust函数可以传 HeapDateType类型的指针，就不要传结构体了，当代码简单后要避免类型转换产生的问题就比较简单了。

        {

               HeapDateType tmp = php->a[(child - 1) / 2];

               php->a[(child - 1) / 2] = php->a[child];

               php->a[child] = tmp;

               child = (child - 1) / 2;

        }

}

交换也会不止一次使用，所以也化为函数形式。

修改后的代码如下：

void Swap(HeapDateType* a, HeapDateType* b)

{

        HeapDateType tmp = *a;

        *a = *b;

        *b = tmp;

}

void AdjustUp(HeapDateType* a, size_t child)

{

        size_t 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* php, HeapDateType x)

{

        assert(php);

        if (php->size == php->capacity)

        {

               int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;

               HeapDateType* tmp = (HeapDateType*)realloc(php->a, sizeof(HeapDateType) * newcapacity);

               if (tmp == NULL)

               {

                       printf("realloc fail\n");

                       exit(-1);

               }

               else

               {

                       php->a = tmp;

                       php->capacity = newcapacity;

               }

        }

        php->a[php->size] = x;

        php->size++;

        AdjustUp(php->a, php->size-1);

}

然后是HeapPop函数，Pop函数要进行的操作是删除堆顶的数据，也就是说要删除根节点。

由前面的情况已知，直接挪动数据进行删除会导致堆的结构被破坏，而且挪动数据的时间复杂度为O(N)。不适合这样删除根节点。

合适的方法是：将根节点和尾节点互换，原堆的左子树和右子树还是堆。然后进行向下调整操作。向下调整最多需要进行h(高度)次，时间复杂度为logN。

向下调整操作：

1.找出孩子节点中小的哪一个

2.和父亲节点比较，如果比父亲节点小（小堆），就交换

3.再从交换孩子的位置继续向下调整。

如图所示，完成调整后，结构还是堆。而且还要考虑右孩子不存在的情况。

代码如下：

void AdjustDown(HeapDateType* a, size_t size, size_t root)

{

        assert(a);

        if (size == 0)

               return 0;

        size_t parent = root;

        while (parent*2+1 < size)

        {

               size_t child = parent * 2 + 1;

               if (child+1 < size && a[child + 1] < a[child]) //特殊情况

               {

                       child++;

               }

               if (a[child] < a[parent])

               {

                       swap(&a[child], &a[parent]);

                       parent = child;

               }

               else

               {

                       break;

               }

        }

}

然后要实现的就是：

bool HeapEmpty(Heap* php);

HeapDateType HeapTop(Heap* php);

size_t HeapSize(Heap* php);

这部分很简单，代码如下：

bool HeapEmpty(Heap* php)

{

        assert(php);

        if (php->size == 0)

               return true;

        else

               return false;

}

HeapDateType HeapTop(Heap* php)

{

        assert(php);

        return php->a[0];

}

size_t HeapSize(Heap* php)

{

        assert(php);

        return php->size;

}

至此，数据结构堆完成。

下面实现一个堆排序

void HeapSort(int* a, size_t size)

{

        Heap hp;

        HeapInit(&hp);

        size_t i = 0;

        for (i = 0; i < size; i++) //时间复杂度为O(N)

        {

               HeapPush(&hp, a[i]); //时间复杂度为O(logN)

        }

        size_t j = 0;

        for (j = 0; j < size; j++) //时间复杂度为O(N)

        {

               a[j] = HeapTop(&hp);

               HeapPop(&hp); //时间复杂度为O(logN)

        }

        for (i = 0; i < size; i++)

        {

               printf("%d ", a[i]);

        }

}

int main()

{

        int a[] = { 1,5,4,2,10,9,6,8 };

        HeapSort(a, sizeof(a) / sizeof(a[0]));

        return 0;

}

所以堆排序的时间复杂度为O(N*logN)。和qsort的时间复杂度是一样的。与冒泡排序的O(N*N)相比，提升了一个档次。

如果要实现大堆，只需要将adjustup和adjustdown中几个关键的‘<’改为‘>’就可以了。

但此时堆排序还有缺陷，因为需要O(N)的空间复杂度。

如何优化为O(1)的空间复杂度？

直接在原数组上建堆。

在数组上建堆的方式有两种：

1.向上调整建堆。

2.向下调整建堆。

向上调整建堆：

void HeapSort(int* a, size_t n) //a是整型指针，指向一个数组；n为数组的长度。

{

    int i = 1; //第一个位置不需要调整

    for(i = 1； i < n; i++)

    {

        AdjustUp(a, i); //在原有数组的基础上建立堆，第一次比较数组中的第1,2个元素，不为堆就调整为堆，第二次在堆的基础上，比较第三个元素，不为堆，就调整为堆。

    }

}

向下调整建堆：

向下调整有一个要求，左子树是堆，右子树是和左子树同一类型的堆。

所以先完成对子树的建堆，叶子节点不需要调整，从倒数第一个非叶子节点开始调整。最后一个非叶子节点是最后一个节点的父节点，即(n-1-1)/2

先调整节点8，节点8的子树只有6，,完成调节后，位置--，就可以调整下一个节点，节点7的子树1和0，完成调节后，再位置--，调节节点2，2的子树一个是节点5，另一个是一个堆。最后调节的是根节点，此时根节点的子树已经全部是堆了。

代码很简单。

void HeapSort(int* a, size_t n) //a是整型指针，指向一个数组；n为数组的长度。

{

    for(int i = (n-1-1)/2; i>=0; i--)

    {

        AdjustDown(a, n, i);

    }

}

由结果得到一个意思的发现，对同一个数组，使用向上建堆和向下建堆的结果是不一样的

下面来比较一下区别（主要是时间复杂度方面）

以满二叉树为例：

假设有N个节点，log(N+1) = h，2^(h) - 1 = N

1.对向上调节来说第一层不用调，第二层有2个节点，每个节点最多调1次，第三层有2^(3-1)个节点，每个节点最多调节2次，第h层有2^(h-1)个节点，每个节点最多调h-1次

T(n)=2*1+4*2+8*3+……2^(h-1)*(h-1)，求T(n)，怎么求？有没有觉得眼熟？

错位相减法：

2T(n)=2^(2)*1+2^(3)*2+2^(4)*3+……2^(h)*(h-1)

T(n) 

= 2T(n)-T(n) 

= -(2^(1) + 2^(2) + 2^(3) + …… + 2^(h-1)) + 2^(h)*(h-1) 

= -2^(h) + 2 + 2^(h)*(h-1) 

= 2^(h)*(h-2)+2

= （N+1）*（log(N+1) + 2）+2

= O(N*logN)

不理解2^(h)到O(N)的转换可以试试这样理解，节点数*调节次数=执行次数=时间复杂度，（2^(h) - 1）个调节1次= N个调节1次=O(N)

2.对向下调节来说

T(n) = 2^(h-1)*1+2^(h-2)*2+2^(h-3)*3+……+2^(1)*(h-2)+2^(0)*(h-1)，求T(n)。

2T(n) = 2^(h)*1 + 2^(h-1)*2 + 2^(h-2)*3+……+2^(2)*(h-2) + 2^(1)*(h-1)

T(n)

= 2^(h) + 2^(h-1) + 2^(h-2) + …… + 2^(1) - h+1

= 2^(h+1) - 1- h

=2N + 1 - log(N+1)

= O(N)

将数组中的值排列为升序，可以通过建小堆来实现吗？

不可以，每次都要建堆来选出最小值，时间复杂度为O(N^2)，还不如使用冒泡排序。

所以升序要通过建大堆来实现。

先记录数组要排序的长度n，每次建堆后，将最后一个节点与根节点互换，n自减1，然后再次建堆，互换后的左子树和右子树还是堆，只需要向下调整就可以重新建立堆。

代码如下：

for(i = (n-1-1)/2); i >= 0; i++) //a是整型指针，指向一个数组；n为数组的长度。

{

    AdjustDown(a, n, i);

}

size_t  end = n-1;

while(end > 0)

{

    swap(&a[0], &a[end]);

    AdjustDown(a,end,0);

    end--;

}

这个方法的好处在于不需要写堆了，只需要写一个向下调整算法就可以，而且空间复杂度为O(1)。

3.4 TOP-K问题

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

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

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

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

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

2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素，然后向下调整。