二叉树由浅至深（上）

1.数概念及结构

1.1树的概念

• 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。
• 树具有以下的特点:

每个结点有零个或多个子结点；
没有父结点的结点称为根结点；
每一个非根结点有且只有一个父结点;
除了根结点外，每个子结点可以分为多个不相交的子树

• 树相关概念：
  
  • 节点的度：一个节点含有的子树的个数称为该节点的度； 如上图：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.2树的表示

树有很多种表示方式，如：双亲表示法，孩子表示法、孩子兄弟表示法等等。这里简单了解其中最常用的孩子兄弟表示法。

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

1.3树在实际中的运用

2.二叉树概念及结构

2.1概念

• 一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。
• 二叉树的特点：

1. 每个结点最多有两棵子树，即二叉树不存在度大于2的结点。
2. 二叉树的子树有左右之分，其子树的次序不能颠倒。

2.2特殊的二叉树：

1. 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。
2. 完全二叉树：对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。

2.3 二叉树的存储结构

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

2.3.1 顺序存储：

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

2.5.2 链式存储：

二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址 。链式结构又分为二叉链和三叉链。

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

3.二叉树的顺序结构及实现

3.1 二叉树的顺序结构

普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆使用顺序结构的数组来存储。

3.2 堆的概念及结构

如果有一个关键码的集合K = {k0，k1， k2，…，kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki <= K2i+1 且 Ki<= K2i+2 (Ki >= K2i+1 且 Ki >= K2i+2) i = 0，1，2…，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

• 堆的性质：
  ①堆中某个节点的值总是不大于或不小于其父节点的值；
  ②堆总是一棵完全二叉树。
  

3.2 堆的实现

3.2.1 堆向下调整算法

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

int a[] = {5,16，3,20，17,4};

3.2.2堆的创建

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

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

3.2.3 堆的插入

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

3.2.4 堆的删除

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

3.2.5 堆排序

3.2.6 堆的代码实现

#include<stdio.h>
#include<assert.h>
#include<malloc.h>
#include<time.h>
#include<memory>
typedef int HPDataType;
typedef struct Heap
{
	HPDataType* _array;
	int _size;
	int _capacity;
}Heap;

void Swap(HPDataType* a, HPDataType* b)
{
	assert(a);
	assert(b);
	HPDataType temp = *a;
	*a = *b;
	*b = temp;
}

void AdjustDown(HPDataType* a, int n, int root)//向下调整
{
	assert(a);
	int parent = root;
	int child = 2 * parent + 1;//左孩子

	while (child < n)//只要孩子不是叶子结点，就继续调整
	{
		if (child + 1 < n && a[child + 1] < a[child])//保证a[child]里面是最小的孩子
		{
			++child;
		}

		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);//保证a[parent]比两个孩子都小

			//重新更新parent、child,即继续判断被交换后的结点
			parent = child;
			child = 2 * parent + 1;
		}
		else//当前结点<最小孩子
		{
			break;
		}
	}
}

void AdjustUp(HPDataType* a, int n, 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 HeapInit(Heap* hp, HPDataType* a, int n)//创建堆(用数组初始化数组，并创建堆)
{
	assert(hp && a);
	//先将数组内容拷贝到堆里的数组
	hp->_array = (HPDataType*)malloc(n*sizeof(HPDataType));
	hp->_size = hp->_capacity = n;
	memcpy(hp->_array, a, n*sizeof(HPDataType));

	//建堆(我们以小堆为例)
	//从最后一个节点的父结点开始向下调整，因为叶子结点不用调整，而最后一个
	//非叶子结点就是最后一个节点的父结点。这样从下->上调整，保证每个结点都是小堆。
	//向下调整的思想是：若当前节点不满足小堆性质，即当前结点>它的左右孩子最小的
	//那个，就将该结点与那个孩子交换，然后判断被交换后的结点...直到叶子结点
	int end = hp->_size - 1;//最后一个元素下标
	for (int i = (end - 1) / 2; i >= 0; i--)
	{
		//最后一个节点的父结点开始到根结点，逐个做向下调整
		AdjustDown(hp->_array, hp->_size, i);
	}
}
//注意如果建大堆的话，只需要将向下调整函数AdjustDown()中
//稍作修改即可，找最大孩子，当父结点小于最大孩子，将其交换...

void HeapDeStory(Heap* hp)//销毁
{
	assert(hp);
	free(hp->_array);
	hp->_array = NULL;
	hp->_size = hp->_capacity = 0;
}

void HeapPrint(Heap* hp)//打印堆
{
	assert(hp);
	for (int i = 0; i < hp->_size; i++)
	{
		printf("%d ", hp->_array[i]);
	}
	printf("\n");
}


//插入一个数据后，堆结构不改变(原来是大堆，删除完堆顶元素后，仍然是大堆)
void HeapPush(Heap* hp, HPDataType x)
{
	assert(hp);
	//堆插入一个元素，物理上实际是数组的尾插。要想保证堆结构不变，
	//就需要从该元素开始向上调整，直到它到根结点。
	//向上调整的思想是：只要这个结点<它的父结点，将二者交换，
	//然后再判断交换后的节点...
	if (hp->_size == hp->_capacity)//需要增容
	{
		hp->_capacity *= 2;
		HPDataType* tmp = (HPDataType*)realloc(hp->_array, hp->_capacity * sizeof(HPDataType));
		if (tmp)
		{
			hp->_array = tmp;
		}
		hp->_array[hp->_size] = x;
		hp->_size++;
	}
	//将这个元素向上调整(注意最后一个参数传的是下标)
	AdjustUp(hp->_array, hp->_size, hp->_size - 1);
}
void HeapPop(Heap* hp)//删除堆顶后，堆结构不改变
{
	assert(hp);
	//将堆顶元素与最后一个元素交换，将元素数目减1(删除的是堆顶元素)
	//然后对堆顶做一次向下调整
	Swap(&hp->_array[0], &hp->_array[hp->_size - 1]);
	hp->_size--;

	AdjustDown(hp->_array, hp->_size, 0);
}
HPDataType HeapTop(Heap* hp)//返回堆顶元素
{
	assert(hp);
	return hp->_array[0];
}

int HeapSize(Heap* hp)//返回堆中元素个数
{
	assert(hp);
	return hp->_size;
}
int HeapEmpty(Heap* hp)//判空(空返回0)
{
	assert(hp);
	return hp->_size == 0 ? 0 : 1;
}

void HeapSort(int* a, int n)//堆排序(升序)
{
	assert(a);
	//如果是升序，则建大堆。建好大堆后，将首尾元素交换(最大的交换到最后)，
	//再将首元素位置做一次向下调整...(不过需要注意的是，每将最大的一个值交换
	//到最后时，下一次的向下调整数据长度减1，即排好的数据就不用管了)

	//建大堆
	int end = n - 1;
	for (int i = (end - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}

	while (end > 0)//最后一个元素下标不到第一个元素，就一直交换，调整...
	{
		Swap(&a[0], &a[end]);//交换首尾元素
		AdjustDown(a, end, 0);//首元素向下调整
		end--;
	}
}

void TopK()
{
	//假设再N个数中选取出最大的前K个数.
	//选取N个数的前K个数建一个小堆，然后用N中剩下的数据与堆顶元素相比，
	//如果大于堆顶元素，先将堆顶元素pop掉(pop()函数仍然保证堆结构)，
	//然后将该元素入堆(push()函数仍然保证堆性质)

	const int N = 10000;
	const int K = 100;
	int* a = (int*)malloc(N * sizeof(int));

	srand((unsigned int)time(NULL));
	for (int i = 0; i < N; i++)
	{
		a[i] = rand() % 100000;//将数组元素初始化为0-10万之间的随机值
	}

	//为了好测试，我们赋10个大于100000的值
	for (int j = 5; j < 15; j++)
	{
		a[j] = 100000 + j;
	}

	//用前K个数字建小堆
	Heap h;
	HeapInit(&h, a, K);
	for (int i = K; i < N; ++i)//将剩下的元素依次与堆顶元素比较，大的入堆
	{
		if (a[i] > HeapTop(&h))
		{
			HeapPop(&h);
			HeapPush(&h, a[i]);
		}
	}

	//最后堆中的K个元素，就是最大的前K个数据
	HeapPrint(&h);
}

void Test()
{
	Heap h;
	int a[] = { 2, 7, 8, 0, 0, 7, 5, 3, 7, 9 };
	int sz = sizeof(a) / sizeof(a[0]);
	HeapInit(&h, a, sz);
	HeapPrint(&h);

	//HeapPush(&h, 0);
	//HeapPrint(&h);

	//HeapPop(&h);
	//HeapPrint(&h);
	HeapSort(a, sz);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");

	TopK();
}

4.二叉树链式结构的实现

4.1二叉树链式结构的遍历

所谓遍历是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问题。 遍历是二叉树上最重要的运算之一，是二叉树上进行其它运算之基础。

前序/中序/后序的递归结构遍历：是根据访问结点操作发生位置命名

1. NLR：前序遍历(亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
   实现：

	/////递归实现
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        ProTraversal(root,res);
        return res;
    }
    void ProTraversal(TreeNode* root,vector<int>& ans)
    	{
         if(root==NULL) return ;
       	 ans.emplace_back(root->val);
         ProTraversal(root->left,ans);
         ProTraversal(root->right,ans);
        }
   }
   
   //////迭代实现
   vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> _stk;
        vector<int> ans;
        TreeNode* temp=root;
        while(temp!=NULL||!_stk.empty()){
            while(temp!=NULL){
                ans.push_back(temp->val);
                _stk.push(temp);
                temp=temp->left;
            }
            temp=_stk.top();
            _stk.pop();
            temp=temp->right;
        }
        return ans;
    }

2. LNR：中序遍历——访问根结点的操作发生在遍历其左右子树之中（间）。

	///////递归实现
    void InorderTraversal(TreeNode* root,vector<int>& ans){
        if(root==NULL)
            return;
        InorderTraversal(root->left,ans);
        ans.emplace_back(root->val);
        InorderTraversal(root->right,ans);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> ans;
        InorderTraversal(root,ans);
        return ans;
    }

	/////迭代实现
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> s;
        while(root || s.size() > 0){
            while(root){
                s.push(root);
                root = root->left;
            }
            root = s.top(); 
            s.pop();
            res.push_back(root->val);
            root = root->right;
        }
        return res;
    }

3. LRN：后序遍历——访问根结点的操作发生在遍历其左右子树之后。

	///////迭代实现
vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ans;
        stack<TreeNode*> stk;
        TreeNode* cur = root;
        TreeNode* rightchild = NULL;
        while(cur || !stk.empty()){
            while(cur != NULL){
                stk.push(cur);
                cur = cur -> left;
            }
            cur = stk.top();
            if(!cur -> right|| rightchild == cur -> right){
                ans.push_back(cur -> val);
                stk.pop();
                rightchild = cur;
                cur = NULL;
            }
            else{
                rightchild = NULL;
                cur = cur -> right;
            }
        }
        return ans;
    }
    
///////递归实现
    vector<int> postorderTraversal(TreeNode* root，vector<int> ans) {
        if(!root)   return ans;
        postorderTraversal(root -> left);
        postorderTraversal(root -> right);
        ans.push_back(root -> val);
        return ans;
    }

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

////////递归实现：
vector<vector<int>> res;   
    vector<vector<int>> levelOrder(TreeNode* root) 
    {
        addVector(root,0);      //调用递归函数
        return res;
    }
  
    void addVector(TreeNode* root,int level)
    {
        if(root == NULL)    return;
        if(res.size()==level)       res.resize(level+1);    //level表示层数，也对应二维数组的第一层索引，
        res[level].push_back(root->val);
        addVector(root->left,level+1);
        addVector(root->right,level+1);
    }

////////迭代实现
vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        
        if (root == NULL)   return {};  
        queue<TreeNode*> q;     
        q.push(root);  

        while (!q.empty()) 
        {  
            vector<int>level;                //存放每一层的元素值
            int count=q.size();             //队列大小表示当前层数的元素个数
            while(count--)                  //count--逐个对该层元素进行处理
            {
            TreeNode *t=q.front();             q.pop();     
            level.push_back(t->val);
            if(t->left)     q.push(t->left);
            if(t->right)    q.push(t->right);
            }

            res.push_back(level);           //将当层元素的vector加入res中
        }
        return res;
        }

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

4.3 二叉树的基本补充实现

#include<stdio.h>
#include<assert.h>
#include<stack>
#include<vector>
#include<iostream>
using namespace std;

typedef char DataType;
typedef struct TreeNode
{
	DataType elem;
	struct TreeNode* rchild;
	struct TreeNode* lchild;
}TreeNode;

void InitTree(TreeNode** root)//二叉树的初始化
{
	assert(root);
	if (*root == NULL)
		return;
	*root = NULL;
	return;
}

//二叉树前序遍历递归版本
void PreOrder(TreeNode* root)
{
	if (root == NULL)
		return;
	printf("%c ", root->elem);
	PreOrder(root->lchild);
	PreOrder(root->rchild);
	return;
}
//二叉树前序遍历非递归版本
vector<int> preorderTraversal(TreeNode* root) {
	stack<TreeNode*> _stk;
	vector<int> ans;
	TreeNode* temp = root;
	while (temp != NULL || !_stk.empty()){
		while (temp != NULL){
			ans.push_back(temp->elem);
			_stk.push(temp);
			temp = temp->lchild;
		}
		temp = _stk.top();
		_stk.pop();
		temp = temp->rchild;
	}
	return ans;
}

////中序遍历递归版本
void InOrder(TreeNode* root)
{
	if (root == NULL)
		return;
	InOrder(root->lchild);
	printf("%c ", root->elem);
	InOrder(root->rchild);
	return;
}
/////中序遍历非递归实现
vector<int> inorderTraversal(TreeNode* root) {
	vector<int> res;
	stack<TreeNode*> s;
	while (root || s.size() > 0){
		while (root){
			s.push(root);
			root = root->lchild;
		}
		root = s.top();
		s.pop();
		res.push_back(root->elem);
		root = root->rchild;
	}
	return res;
}

////后序遍历递归版本
void PostOrder(TreeNode* root)
{
	if (root == NULL)
		return;
	PostOrder(root->lchild);
	PostOrder(root->rchild);
	printf("%c ", root->elem);
	return;
}
////后序遍历非递归实现
vector<int> postorderTraversal(TreeNode* root) {
	vector<int> ans;
	stack<TreeNode*> stk;
	TreeNode* cur = root;
	TreeNode* rightchild = NULL;
	while (cur || !stk.empty()){
		while (cur != NULL){
			stk.push(cur);
			cur = cur->lchild;
		}
		cur = stk.top();
		if (!cur->rchild || rightchild == cur->rchild){
			ans.push_back(cur->elem);
			stk.pop();
			rightchild = cur;
			cur = NULL;
		}
		else{
			rightchild = NULL;
			cur = cur->rchild;
		}
	}
	return ans;
}

////二叉树的创建
TreeNode* _CreateTree(DataType array[], size_t size, DataType null_node, size_t* index)
{
	assert(index);
	if (*index >= size)
		return NULL;
	if (array[*index] == null_node)
	{
		++*index;
		return NULL;
	}
	TreeNode* new_node = _CreateTree(array[(*index)++]);
	new_node->lchild = _CreateTree(array, size, null_node, index);
	new_node->rchild = _CreateTree(array, size, null_node, index);
	return new_node;
}
TreeNode* CreateTree(DataType array[], size_t size, DataType null_node)
{
	assert(array);
	size_t index = 0;
	return _CreateTree(array, size, null_node, &index);
}


///二叉树的拷贝
TreeNode* TreeClone(TreeNode* root)
{
	if (root == NULL)
		return NULL;
	TreeNode* new_node = _CreateTree(root->elem);
	new_node->lchild = TreeClone(root->lchild);
	new_node->rchild = TreeClone(root->rchild);
	return new_node;
}

/////二叉树的销毁
void DestroyNode(TreeNode* node)
{
	free(node);
	return;
}
void TreeDestroy(TreeNode** root)
{
	assert(root);
	if (*root == NULL)
		return;
	TreeDestroy(&((*root)->lchild));
	TreeDestroy(&((*root)->rchild));
	DestroyNode(*root);
	*root = NULL;
	return;
}

///////求二叉树的高度
size_t TreeHeight(TreeNode* root)
{
	if (root == NULL)
		return 0;
	size_t lheight = TreeHeight(root->lchild) + 1;
	size_t rheight = TreeHeight(root->rchild) + 1;
	return rheight > lheight ? rheight : lheight;
}


/////求叶子结点个数
size_t TreeLeafSize(TreeNode* root)
{
	if (root == NULL)
		return 0;
	if (root->lchild == NULL && root->rchild == NULL)
		return 1;
	return TreeLeafSize(root->lchild) + TreeLeafSize(root->rchild);
}

////求K层节点的个数
size_t TreeKLevelSize(TreeNode* root, int K)
{
	if (root == NULL)
		return 0;
	if (K == 1)
		return 1;
	return TreeKLevelSize(root->lchild, K - 1) + TreeKLevelSize(root->rchild, K - 1);
}