数据结构——树与二叉树

树与二叉树

1. 树的根本概念

1.1 树的界说

树(tree)是                                   n                         (                         n                         ≥                         0                         )                              n(n\geq 0)                  n(n≥0)个结点的有限集T。当n为0时时空树，恣意一棵非空树应该满足：

• 有且仅有一个特定的结点，称为树的根(root)
  
• 当                                        n                            >                            1                                  n>1                     n>1时，其余结点可分为                                        m                            (                            m                            >                            0                            )                                  m(m>0)                     m(m>0)个互不相交的有限集                                                   T                               1                                      ,                                       T                               2                                      .                            .                            .                                       T                               m                                            T_1,T_2...T_m                     T1​,T2​...Tm​，其中每一个聚集自己又是一棵树，称为根的子树(subtree)
  

树的递归界说方式表现了树的一种固有的特性：

• 树中至少有一个结点——根
  
• 树中各子树是互不相交的聚集
  

1.2 树的根本术语

结点的度*：*一个结点含有的子树的个数称为该结点的度； 如上图：A的为6
叶结点或终端结点：度为0的结点称为叶结点； 如上图：B、C、H、I…等结点为叶结点
非终端结点或分支结点：度不为0的结点； 如上图：D、E、F、G…等结点为分支结点
双亲结点或父结点：若一个结点含有子结点，则这个结点称为其子结点的父结点； 如上图：A是B的父结点
孩子结点或子结点：一个结点含有的子树的根结点称为该结点的子结点； 如上图：B是A的孩子结点
兄弟结点：具有类似父结点的结点互称为兄弟结点； 如上图：B、C是兄弟结点
树的度：一棵树中，最大的结点的度称为树的度； 如上图：树的度为6 。二叉树的度为2
结点的层次：从根开始界说起，根为第1层，根的子结点为第2层，以此类推
树的高度或深度：树中结点的最大层次； 如上图：树的高度为4
堂兄弟结点：双亲在同一层的结点互为堂兄弟；如上图：H、I互为兄弟结点
结点的祖先：从根到该结点所经分支上的全部结点；如上图：A是全部结点的祖先
子孙：以某结点为根的子树中任一结点都称为该结点的子孙。如上图：全部结点都是A的子孙
森林：由m（m>0）棵互不相交的树的聚集称为森林
有序树(ordered tree)、无序树：树中结点的各子树从左到右是有序次的不能互换，则称树为有序树，否则为无序树，下图为有序树
路径和路径长度：从一个祖先结点到其子孙结点的一系列边称为树中一条路径。显然，从树根到树中任一个结点都有路径，且路径唯一 路径中边的条数称为路径长度，以为每个结点到自身有长0 的路径

1.3 树的表现方法

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

1. typedef int DataType;
2. struct Node
3. {
4. struct Node* _firstChild1; // 第一个孩子结点
5. struct Node* _pNextBrother; // 指向其下一个兄弟结点
6. DataType _data; // 结点中的数据域
7. };

复制代码

2. 二叉树

2.1 二叉树的界说

二叉树是一种特殊的树形结构，其特点是每个结点至多只有两棵子树(即二叉树中不存在度大于2的结点)，而且二叉树的子树有左右之分，其序次不能恣意颠倒。
与树相似，二叉树也以递归的形式界说。二叉树是                                   n                         (                         n                         >                         0                         )                              n(n>0)                  n(n>0)个结点的有限聚集：
① 或者为空二叉树，即                                   n                         =                         0                              n=0                  n=0。
② 或者由一个根结点和两个互不相交的被称为根的左子树和右子树组成。左子树和右子树又分别是一棵二叉树。
二叉树是有序树，若将其左、右子树颠倒，则成为另一棵差别的二叉树。
几种特殊的二叉树：

• 满二叉树
  一个二叉树，假如每一个层的结点数都到达最大值，则这个二叉树就是满二叉树。也就是说，假如一个二叉树的层数为                                             h                                      h                        h，且结点总数是                                                         2                                  h                                          −                               1                                      2^h-1                        2h−1 ，则它就是满二叉树。满二叉树的叶结点在二叉树的最下面一层，除叶结点之外每个结点的度数为2.
  
• 完全二叉树
  完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于高度为                                             h                                      h                        h的，有                                             n                                      n                        n个结点的二叉树，当且仅当其每一个结点都与深度为                                             h                                      h                        h的满二叉树中编号从1至                                             n                                      n                        n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。
  

需要注意的是满二叉树的叶结点位于同一层，且是最后一层，而完全二叉树的位于最下层和次下层。
2.2 二叉树的性子

• 性子1：非空二叉树上的叶结点数即是度为2的结点数加1，即
                                                                  n                                     0                                              =                                               n                                     2                                              +                                  1                                          n_0=n_2+1                           n0​=n2​+1
  
  
  
  
• 性子2：非空二叉树的第                                                  k                                          k                           k层最多有                                                               2                                                   k                                        −                                        1                                                                   2^{k-1}                           2k−1个结点                                                  (                                  k                                  ≥                                  1                                  )                                          (k\geq 1)                           (k≥1)
  
• 性子3：高度为                                                  h                                          h                           h的二叉树至多有                                                               2                                     h                                              −                                  1                                          2^h-1                           2h−1个结点                                                  (                                  h                                  ≥                                  1                                  )                                          (h\geq 1)                           (h≥1)
  
• 性子4：
  
  
  
  
• 性子5：具有                                                  n                                          n                           n个结点的完全二叉树的深度为                                                  l                                  o                                               g                                     2                                              (                                  n                                  +                                  1                                  )                                          log_2(n+1)                           log2​(n+1)或                                                  l                                  o                                               g                                     2                                              n                                  +                                  1                                          log_2n+1                           log2​n+1
  

2.3 二叉树的存储结构

2.3.1 次序存储

二叉树的次序存储是指用一组连续的存储单元依次自上而下、自左至右存储完全二叉树上的结点元素，即将完全二叉树上编号为                                   i                              i                  i的结点元素存储在一维数组下标为                                   i                         −                         1                              i-1                  i−1的分量中。
依据二叉树的性子，完全二叉树和满二叉树接纳次序存储比较符合，树中结点的序号可以唯一地反映结点之间的逻辑关系，如许既能最大可能地节流存储空间，又能使用数组元素的下标值确定结点在二叉树中的位置，以及结点之间的关系。

2.3.2 链式存储

由于次序存储的空间使用率较低，因此二叉树一般都接纳链式存储结构，用链表结点来存储二叉树中的每个结点。在二叉树中，结点结构通常包罗若干数据域和若干指针域，二叉链表至少包罗3个域：数据域 data、左指针域 lchild 和右指针域 rchild。

1. typedef int BTDataType;
2. typedef struct BinaryTreeNode
3. {
4. BTDataType _data;
5. struct BinaryTreeNode* _left;
6. struct BinaryTreeNode* _right;
7. }BTNode;

复制代码

2.4 二叉树的遍历

二叉树的遍历除了层序遍历有递归与非递归的写法，具体如下。
若想要清晰的理解遍历，不要一味的只去看遍历的结果是多少，而是要看清楚每一步是怎么走的，包罗走到空。

前序遍历结果：1 2 3 4 5 6
中序遍历结果：3 2 1 5 4 6
后序遍历结果：3 2 5 6 4 1
层序遍历结果：1 2 4 3 5 6
2.4.1 前序遍历

https://leetcode.cn/problems/binary-tree-preorder-traversal/

递归版本：

1. void PreOrder(Node *root)
2. {
3.     if (root==nullptr)
4.         return ;
5.     std::cout<<root->val<<" ";
6.     PreOrder(root->left);
7.     PreOrder(root->right);
8. }

复制代码

1. // 带返回值的版本
2. void preOrder(struct TreeNode* root, int* res, int* returnSize) {
3.     if (root == NULL)
4.         return;
5.     res[(*returnSize)++] = root->val;
6.     preOrder(root->left, res, returnSize);
7.     preOrder(root->right, res, returnSize);
8. }
9. int* preorderTraversal(struct TreeNode* root, int* returnSize) {
10.     int* res = (int*)malloc(sizeof(int) * 2000);
11.     *returnSize = 0;
12.     preOrder(root, res, returnSize);
13.     return res;
14. }

复制代码

非递归版本：
非递归是使用栈，由于递归的本质就是栈帧，故用栈来模拟。

1. class Solution {
2. public:
3.     vector<int> preorderTraversal(TreeNode* root) {
4.         vector<int> res;
5.         if(root == nullptr)
6.             return res;
7.         stack<TreeNode*> st;
8.         TreeNode *cur=root;
9.         while(!st.empty()||cur!=nullptr)
10.         {
11.             while(cur!=nullptr)
12.             {
13.                 res.push_back(cur->val);
14.                 st.push(cur);
15.                 cur=cur->left;
16.             }
17.             cur=st.top();
18.             st.pop();
19.             cur=cur->right;
20.         }
21.         return res;
22.     }
23. };

复制代码

1. int* preorderTraversal(struct TreeNode* root, int* returnSize) {
2.     int *res=(int*)malloc(sizeof(int)*200);
3.     *returnSize=0;
4.     if(root==NULL)
5.         return res;
6.     struct TreeNode *st[200];
7.     int top=0;
8.     struct TreeNode *cur=root;
9.     while(top>0||cur!=NULL)
10.     {
11.         while(cur!=NULL)
12.         {
13.             res[(*returnSize)++]=cur->val;
14.             st[top++]=cur;
15.             cur=cur->left;
16.         }
17.         cur=st[--top];
18.         cur=cur->right;
19.     }
20.     return res;
21. }

复制代码

2.4.2 中序遍历

https://leetcode.cn/problems/binary-tree-inorder-traversal/

递归版本：

1. void InOrder(Node *root)
2. {
3.     if (root==nullptr)
4.         return ;
5.     InOrder(root->left);
6.     std::cout<<root->val<<" ";
7.     InOrder(root->right);
8. }

复制代码

1. void inOrder(struct TreeNode* root,int *res,int *resSize)
2. {
3.     if(root==NULL)
4.         return;
5.     inOrder(root->left,res,resSize);
6.     res[(*resSize)++]=root->val;
7.     inOrder(root->right,res,resSize);
8. }
9. int* inorderTraversal(struct TreeNode* root, int* returnSize) {
10.     int *res=(int*)malloc(sizeof(int)*200);
11.     *returnSize=0;
12.     inOrder(root,res,returnSize);
13.     return res;
14. }

复制代码

非递归版本：

1. class Solution {
2. public:
3.     vector<int> inorderTraversal(TreeNode* root) {
4.         vector<int> res;
5.         if (root == nullptr)
6.             return res;
7.         stack<TreeNode*> st;
8.         TreeNode* cur = root;
9.         while (!st.empty() || cur != nullptr) {
10.             while (cur != nullptr) {
11.                 st.push(cur);
12.                 cur = cur->left;
13.             }
14.             cur = st.top();
15.             st.pop();
16.             res.push_back(cur->val);
17.             cur = cur->right;
18.         }
19.         return res;
20.     }
21. };

复制代码

2.4.3 后序遍历

https://leetcode.cn/problems/binary-tree-postorder-traversal/

递归版本：

1. void PostOrder(Node *root)
2. {
3.     if(root==nullptr)
4.         return ;
5.     PostOrder(root->left);
6.     PostOrder(root->right);
7.     std::cout<<root->val<<" ";
8. }

复制代码

非递归版本：
后序遍历的非递归版本相对复杂，需要注意右子树是否为空的问题。

1. class Solution {
2. public:
3.     vector<int> postorderTraversal(TreeNode* root) {
4.         vector<int> res;
5.         if (root == nullptr)
6.             return res;
7.         stack<TreeNode*> st;
8.         TreeNode* cur = root,*prev=nullptr;
9.         while (!st.empty() || cur != nullptr) {
10.             while (cur != nullptr) {
11.                 st.push(cur);
12.                 cur = cur->left;
13.             }
14.             cur = st.top();
15.             st.pop();
16.             if(cur->right==nullptr||cur->right==prev)
17.             {
18.                 res.push_back(cur->val);
19.                 prev=cur;
20.                 cur=nullptr;
21.             }
22.             else
23.             {
24.                 st.push(cur);
25.                 cur=cur->right;
26.             }
27.         }
28.         return res;
29.     }
30. };

复制代码

2.4.4 层序遍历

https://leetcode.cn/problems/binary-tree-level-order-traversal/description/

1. void LevelOrder(Node *root)
2. {   
3.     if(root==nullptr)
4.         return ;
5.     std::queue<Node*> q;
6.     q.push(root);
7.     while(!q.empty())
8.     {
9.         std::cout<<q.front()->val<<" ";
10.         if(q.front()->left)
11.         {
12.             q.push(q.front()->left);
13.         }
14.         if(q.front()->right)
15.         {
16.             q.push(q.front()->right);
17.         }
18.         q.pop();
19.     }
20. }

复制代码

1. // 返回值为二维数组形式
2. class Solution {
3. public:
4.     vector<vector<int>> levelOrder(TreeNode* root) {
5.         vector<vector<int>> res;
6.         if(root==nullptr)
7.             return res;
8.         queue<TreeNode*> q;
9.         q.push(root);
10.         while (!q.empty()) {
11.             int levelSize = q.size();
12.             res.push_back(vector<int>());
13.             for (int i = 0; i < levelSize; i++) {
14.                 TreeNode* temp = q.front();
15.                 q.pop();
16.                 res.back().push_back(temp->val);
17.                 if (temp->left)
18.                     q.push(temp->left);
19.                 if (temp->right)
20.                     q.push(temp->right);
21.             }
22.         }
23.         return res;
24.     }
25. };

复制代码

2.5 遍历构造二叉树

对于一棵给定的二叉树，其先序序列、中序序列、后序序列和层序序列都是确定的。然而，只给出四种遍历序列中的恣意一种，却无法唯一地确定一棵二叉树。若已知中序序列，再给出其他三种遍历序列中的恣意一种，就可以唯一地确定一棵二叉树。
2.5.1 先序序列和中序序列

在先序序列中，第一个结点一定是二叉树的根结点；而在中序遍历中，根结点必然将中序序列分割成两个子序列，前一个子序列是根的左子树的中序序列，后一个子序列是根的右子树的中序序列。左子树的中序序列和先序序列的长度是相等的，右子树的中序序列和先序序列的长度是相等的。根据这两个子序列，可以在先序序列中找到左子树的先序序列和右子树的先序序列，如下图所示。如此递归地分解下去，便能唯一地确定这棵二叉树。

例如，求先序序列(ABCDEFGHI)和中序序列(BCAEDGHFI)所确定的二叉树。首先，由先序序列可知 A为二叉树的根结点。中序序列中A之前的 BC为左子树的中序序列，EDGHFI为右子树的中序序列。然后，由先序序列可知B是左子树的根结点，D是右子树的根结点。以此类推，就能将剩下的结点继续分解下去。

https://leetcode.cn/problems/construct-binary-tree-from-preorder-and-inorder-traversal/description/

1. struct TreeNode* createNode(int x) {
2.     struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
3.     node->val = x;
4.     node->left = node->right = NULL;
5.     return node;
6. }
7. struct TreeNode* buildTree(int* preorder, int preorderSize, int* inorder,
8.                            int inorderSize) {
9.     if (preorderSize == 0 || inorderSize == 0)
10.         return NULL;
11.     int index;
12.     struct TreeNode* root = createNode(preorder[0]);
13.     // 确定目前子树的左右子树的长度
14.     for (index = 0; index < inorderSize; index++) {
15.         if (inorder[index] == preorder[0])
16.             break;
17.     }
18.     root->left = buildTree(preorder + 1, index, inorder, index);
19.     root->right = buildTree(preorder + index + 1, preorderSize - index - 1,
20.                             inorder + index + 1, preorderSize - index - 1);
21.     return root;
22. }

复制代码

2.5.2 中序序列和后序序列

同理，由二叉树的后序序列和中序序列也可以唯一地确定一棵二叉树。由于后序序列的最后一个结点就犹如先序序列的第一个结点，可以将中序序列分割成两个子序列，如下图所示，然后接纳类似的方法递归地举行分解，进而唯一地确定这棵二叉树。

https://leetcode.cn/problems/construct-binary-tree-from-inorder-and-postorder-traversal/description/

1. struct TreeNode* createNode(int x) {
2.     struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
3.     node->val = x;
4.     node->left = node->right = NULL;
5.     return node;
6. }
8. struct TreeNode* buildTreeFromInorderAndPostorder(int* inorder, int inorderSize, int* postorder, int postorderSize) {
9.     if (inorderSize == 0 || postorderSize == 0)
10.         return NULL;
11.     int index;
12.     struct TreeNode* root = createNode(postorder[postorderSize - 1]);
13.     // 确定目前子树的左右子树的长度
14.     for (index = 0; index < inorderSize; index++) {
15.         if (inorder[index] == postorder[postorderSize - 1])
16.             break;
17.     }
18.     root->left = buildTreeFromInorderAndPostorder(inorder, index, postorder, index);
19.     root->right = buildTreeFromInorderAndPostorder(inorder + index + 1, inorderSize - index - 1, postorder + index, postorderSize - index - 1);
20.     return root;
21. }

复制代码

1. // 从右向左构建
2. struct TreeNode* createNode(int x) {
3.     struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
4.     node->val = x;
5.     node->left = node->right = NULL;
6.     return node;
7. }
8. struct TreeNode* buildTree(int* inorder, int inorderSize, int* postorder,
9.                            int postorderSize) {
10.     if (inorderSize == 0 || postorderSize == 0)
11.         return NULL;
12.     int index;
13.     struct TreeNode* root = createNode(postorder[postorderSize - 1]);
14.     for (index = inorderSize - 1; index >= 0; index--) {
15.         if (inorder[index] == postorder[postorderSize - 1])
16.             break;
17.     }
18.     root->right = buildTree(inorder + index + 1, inorderSize - index - 1,
19.                             postorder + index, inorderSize - index - 1);
20.     root->left = buildTree(inorder, index, postorder, index);
21.     return root;
22. }

复制代码

好的，我们来详细模拟一下从右向左构建二叉树的过程。
输入：

• inorder = [9, 3, 15, 20, 7]
  
• postorder = [9, 15, 7, 20, 3]
  

步骤1

• postorder的最后一个元素是3，它是根节点。
  
• 在inorder中找到3的位置，索引为1。
  

构建根节点：

1.     3

复制代码

步骤2

• 右子树的inorder范围是[15, 20, 7]，长度为3。
  
• 右子树的postorder范围是[15, 7, 20]。
  

步骤3

• postorder的最后一个元素是20，它是右子树的根节点。
  
• 在inorder中找到20的位置，索引为3。
  

构建右子树：

1.     3
2.      \     20

复制代码

步骤4

• 右子树的右子树的inorder范围是[7]，长度为1。
  
• 右子树的右子树的postorder范围是[7]。
  

步骤5

• postorder的最后一个元素是7，它是右子树的右子树的根节点。
  
• 在inorder中找到7的位置，索引为4。
  

构建右子树的右子树：

1.     3
2.      \     20       \        7

复制代码

步骤6

• 右子树的左子树的inorder范围是[15]，长度为1。
  
• 右子树的左子树的postorder范围是[15]。
  

步骤7

• postorder的最后一个元素是15，它是右子树的左子树的根节点。
  
• 在inorder中找到15的位置，索引为2。
  

构建右子树的左子树：

1.     3
2.      \     20    /  \   15   7

复制代码

步骤8

• 左子树的inorder范围是[9]，长度为1。
  
• 左子树的postorder范围是[9]。
  

步骤9

• postorder的最后一个元素是9，它是左子树的根节点。
  
• 在inorder中找到9的位置，索引为0。
  

构建左子树：

1.     3
2.    / \  9  20    /  \   15   7

复制代码

最终构建的二叉树为：

1.     3
2.    / \  9  20    /  \   15   7

复制代码

总结一下，着实不管是那种方法，最重要的一点就是划分左右子树，每一次都在更新数组区间，本质就是在更新当前结点的左右子树，由于任何一个结点都可以看作是一个根结点。
2.6 二叉树的应用

二叉树的许多应用于题目根本上都是使用递归，这一点非常紧张。
2.6.1 二叉树结点个数

1. int TreeSize(Node *root) // 树的大小吧（结点）
2. {
3.                 // 左右递归遍历相加
4.     return root == nullptr ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
5. }

复制代码

2.6.2 二叉树的高度

二叉树的高度就是左右子树高度的最大值。

1. int TreeHeight(Node *root)
2. {
3.     if (root == nullptr)
4.         return 0;
5.     int left = TreeHeight(root->left);
6.     int right = TreeHeight(root->right);
7.     return left > right ? left + 1 : right + 1;
8. }

复制代码

2.6.3 销毁二叉树

使用后序遍历来销毁二叉树。

1. bool DestroyTree(Node *root)
2. {
3.     if (root == nullptr)
4.         return false;
5.     DestroyTree(root->left);
6.     DestroyTree(root->right);
7.     free(root);
8.     root = nullptr;
9.     return true;
10. }

复制代码

3. 树与二叉树的应用

3.1 二叉搜索树

二叉搜索树（BST，Binary Search Tree），也称二叉排序树或二叉查找树。
二叉搜索树：一棵二叉搜索树，可以为空；假如不为空，满足以下性子：

• 非空左子树的全部键值小于其根结点的键值。
  
• 非空右子树的全部键值大于其根结点的键值。
  
• 左、右子树都是二叉搜索树。
  

按照这个性子二叉搜索树的中序遍历一定是递增序列。
二叉搜索树的具体实现在这里先不讲解，重要是说明其建立过程和原理，在查找中会详细讲解。
下面是一个二叉搜索树的建立过程：

3.2 哈夫曼树

3.2.1 哈夫曼树的界说

在介绍哈夫曼树之前，先介绍几个相关的概念：
从树中一个结点到另一个结点之间的分支构成这两个结点之间的路径。
路径上的分支数量称为路径长度。
在许多应用中，树中结点经常被赋予一个表现某种意义的数值，称为该结点的权。
从树的根到一个结点的路径长度与该结点上权值的乘积，称为该结点的带权路径长度。
树中全部叶结点的带权路径长度之和称为该树的带权路径长度，记为
                                         W                            P                            L                            =                                       ∑                                           i                                  =                                  1                                          n                                                 w                               i                                                 l                               i                                            WPL=\sum_{i=1}^nw_il_i                     WPL=i=1∑n​wi​li​
在式子中                                             w                            i                                       w_i                  wi​是第                                   i                              i                  i个结点的权值，                                             l                            i                                       l_i                  li​是该结点到叶结点（度为0的结点）的路径长度。

盘算上图的WPL：

• WPL=72+52+22+42=36
  
• WPL=73+53+42+21=46
  
• WPL=71+52+23+43=35
  

3.2.2 哈夫曼树的构造过程

对于给定的有各自权值的 n 个结点

• 在 n 个权值中选出两个最小的权值，对应的两个结点组成一个新的二叉树，且新二叉树的根结点的权值为左右孩子权值的和；
  
• 在原有的 n 个权值中删除那两个最小的权值，同时将新的权值加入到 n–2 个权值的行列中，以此类推；
  
• 重复 1 和 2 ，直到以是的结点构建成了一棵二叉树为止，这棵树就是哈夫曼树/最优二叉树。
  

从上述构造过程中可以看出哈夫曼树具有如下特点:

• 每个初始结点最终都成为叶结点，且权值越小的结点到根结点的路径长度越大。
  
• 构造过程中共新建了n-1个结点(双分支结点)，因此哈夫曼树的结点总数为2n-1。
  
• 每次构造都选择2棵树作为新结点的孩子，因此哈夫曼树中不存在度为1的结点。
  例如，权值{17.5.2.4}的哈夫曼树的构造过程如下图所示。
  

3.2.3 哈夫曼编码

在数据通信中,若对每个字符用相等长度的二进制位表现,称这种编码方式为固定长度编码。若答应对差别字符用不等长的二进制位表现，则这种编码方式称为可变长度编码。可变长度编码比固定长度编码要好得多，其特点是对频率高的字符赋以短编码，而对频率较低的字符则赋以较长一些的编码，从而可以使字符的均匀编码长度减短，起到压缩数据的结果。
可以使用二叉树来设计二进制前缀编码。假设为A.B,C,D四个字符设计前缀编码，可以用下图所示的二叉树来表现，4个叶结点分别表现4个字符，且约定左分支表现 0，右分支表现1，从根到叶结点的路径上用分支标志组成的序列作为该叶结点字符的编码，可以证明如此得到的必为前缀编码。由下图得到字符 A,B,C,D的前缀编码分别为 0,10,110.111。

哈夫曼编码是一种非常有效的数据压缩编码。由哈夫曼树得到哈夫曼编码是很自然的过程。首先，将每个字符当作一个独立的结点，其权值为它出现的频度(或次数)，构造出对应的哈夫曼树。然后，将从根到叶结点的路径上分支标志的字符串作为该字符的编码。下图所示为一个由哈夫曼树构造哈夫曼编码的示例，矩形方块表现字符及其出现的次数。

这棵哈夫曼树的 WPL为：WPL=1x45+3x(13+12+16)+4x(5 +9)=224
此处的 WPL 可视为最终编码得到二进制编码的长度，共 224 位。若接纳3位固定长度编码，则得到的二进制编码长度为 300 位，因此哈夫曼编码共压缩了 25%的数据。使用哈夫曼树可以设计出总长度最短的二进制前缀编码。
左分支和右分支毕竟是表现0照旧表现1没有明确规定，因此构造出的哈夫曼树并不唯一，但各哈夫曼树的带权路径长度 WPL 类似且为最优。此外，如有若干权值类似的结点，则构造出的哈夫曼树更可能差别，但 WPL 必然类似且为最优。
注意假如是加权均匀WPL还需要除以出现次数的总数。
4. 堆

4.1 堆的界说

假如有一个关键码的聚集                                   K                         =                         {                                   k                            0                                  ,                                   k                            1                                  ,                                   k                            2                                  ,                         .                         .                         .                         ,                                   k                                       n                               −                               1                                            }                              K=\{k_0, k_1, k_2, ..., k_{n-1}\}                  K={k0​,k1​,k2​,...,kn−1​} ，把它的全部元素按完全二叉树的次序存储方式存储在一个一维数组中，并满足：                                             K                            i                                  <                         =                                   K                                       2                               ∗                               i                               +                               1                                                 K_i<=K_{2 * i+1}                  Ki​<=K2∗i+1​ 且                                              K                            i                                  <                         =                                   K                                       2                               ∗                               i                               +                               2                                                      (                                       K                               i                                      >                            =                                       K                                           2                                  ∗                                  i                                  +                                  1                                                            K_i<=K_{2 * i+2}\left(K_i>=K_{2 * i+1}\right.                  Ki​<=K2∗i+2​(Ki​>=K2∗i+1​ 且                                                         K                               i                                      >                            =                                       K                                           2                                  ∗                                  i                                  +                                  2                                                 )                                  i                         =                         0                         ,                         1                         ,                         2                              \left.K_i>=K_{2 * i+2}\right) \mathrm{i}=0,1,2                  Ki​>=K2∗i+2​)i=0,1,2。则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。
堆满足以下性子：

• 堆中某个节点的值总是不大于或不小于其父节点的值
  
• 堆一定是一颗完全二叉树
  

4.2 堆的实现

4.2.1 堆的向下调整

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

1. typedef int HPDataType;
2. //交换函数
3. void Swap(int* x, int* y)
4. {
5.         int tmp = *x;
6.         *x = *y;
7.         *y = tmp;
8. }
10. // 堆的向下调整（小堆）
11. // 大堆只需要把比较的<改为>
12. void AdjustDown(HPDataType* a, int n, int parent)
13. {
14.         //child记录左右孩子中值较小的孩子的下标
15.         int child = 2 * parent + 1;//先默认其左孩子的值较小
16.         while (child < n)
17.         {
18.                 if (child + 1 < n&&a[child + 1] < a[child])//右孩子存在并且右孩子比左孩子还小
19.                 {
20.                         child++;//较小的孩子改为右孩子
21.                 }
22.                 if (a[child] < a[parent])//左右孩子中较小孩子的值比父结点还小
23.                 {
24.                         //将父结点与较小的子结点交换
25.                         Swap(&a[child], &a[parent]);
26.                         //继续向下进行调整
27.                         parent = child;
28.                         child = 2 * parent + 1;
29.                 }
30.                 else//已成堆
31.                 {
32.                         break;
33.                 }
34.         }
35. }

复制代码

其时间复杂度为                                   O                         (                         l                         o                         g                         N                         )                              O(logN)                  O(logN)，最坏走完整棵树。
4.2.2 堆的向上调整

向上调整便是子节点往父节点的位置去调整。

1. //交换函数
2. void Swap(HPDataType* x, HPDataType* y)
3. {
4.         HPDataType tmp = *x;
5.         *x = *y;
6.         *y = tmp;
7. }
9. //堆的向上调整（小堆）
10. void AdjustUp(HPDataType* a, int child)
11. {
12.         int parent = (child - 1) / 2;
13.         while (child > 0)//调整到根结点的位置截止
14.         {
15.                 if (a[child] < a[parent])//孩子结点的值小于父结点的值
16.                 {
17.                         //将父结点与孩子结点交换
18.                         Swap(&a[child], &a[parent]);
19.                         //继续向上进行调整
20.                         child = parent;
21.                         parent = (child - 1) / 2;
22.                 }
23.                 else//已成堆
24.                 {
25.                         break;
26.                 }
27.         }
28. }

复制代码

4.2.3 堆的建立

建立一个堆需要满足其左右子树都是堆，那么我们可以从下面开始调整，最后便可以建成一个堆。这里我们从倒数的第一个非叶子节点的子树开始调整，不停调整到根节点的树，就可以调整成堆。大致过程如下图所示：

1. for (int i = (heapSize - 1 - 1) / 2; i >= 0; i--) // heapSize-1是最后一个元素的位置，再减1除2是为了计算双亲结点的位置
2. {
3.         AdjustDown(heap,heapSize , i);
4. }

复制代码

时间复杂度分析：

结点移动的步数为：
$$
T(n)=2^0 *(h-1)+2^1 *(h-2)+2^2 *(h-3)+2^3 *(h-4)+2^{h-3} * 2+2^{h-2} * 1
$$
上述式子为一个等差乘等比的数列求和，根据高中知识，使用错位相减法。
                                         2                            ∗                            T                            (                            n                            )                            =                                       2                               1                                      ∗                            (                            h                            −                            1                            )                            +                                       2                               2                                      ∗                            (                            h                            −                            2                            )                            +                                       2                               3
                                      ∗                            (                            h                            −                            3
                            )                            +                                       2                               4                                      ∗                            (                            h                            −                            4                            )                            +                            …                            +                                       2                                           h                                  −                                  2                                                 ∗                            2                            +                                       2                                           h                                  −                                  1                                                 ∗                            1                                  2 * T(n)=2^1 *(h-1)+2^2 *(h-2)+2^3 *(h-3)+2^4 *(h-4)+\ldots+2^{h-2} * 2+2^{h-1} * 1                     2∗T(n)=21∗(h−1)+22∗(h−2)+23∗(h−3)+24∗(h−4)+…+2h−2∗2+2h−1∗1
两式相减：
                                         T                            (                            n                            )                            =                            1                            −                            h                            +                                       2                               1                                      +                                       2                               2                                      +                                       2                               3
                                      +                                       2                               4                                      +                            …                            +                                       2                                           h                                  −                                  2                                                 +                                       2                                           h                                  −                                  1                                                       T(n)=1-h+2^1+2^2+2^3+2^4+\ldots+2^{h-2}+2^{h-1}                     T(n)=1−h+21+22+23+24+…+2h−2+2h−1
                                         T                            (                            n                            )                            =                                       2                               0                                      +                                       2                               1                                      +                                       2                               2                                      +                                       2                               3
                                      +                                       2                               4                                      +                            …                            +                                       2                                           h                                  −                                  2                                                 +                                       2                                           h                                  −                                  1                                                 −                            h                                  T(n)=2^0+2^1+2^2+2^3+2^4+\ldots+2^{h-2}+2^{h-1}-h                     T(n)=20+21+22+23+24+…+2h−2+2h−1−h
可以使用等比数列求和公式：
                                         T                            (                            n                            )                            =                                       2                               h                                      −                            1                            −                            h                                  T(n)=2^h-1-h                     T(n)=2h−1−h
由于                                   n                         =                                   2                            h                                  −                         1                         、                         h                         =                                              log                               ⁡                                      2                                  (                         n                         +                         1                         )                              n=2^h-1、h=\log _2(n+1)                  n=2h−1、h=log2​(n+1)，则：
                                         T                            (                            n                            )                            =                            n                            −                                                   log                                  ⁡                                          2                                      (                            n                            +                            1                            )                                  T(n)=n-\log _2(n+1)                     T(n)=n−log2​(n+1)
故向下调整建堆时间复杂度为                                   T                         =                         O                         (                         N                         )                              T=O(N)                  T=O(N)
4.2.4 堆的插入

数据插入时是插入到数组的末端，即树形结构的最后一层的最后一个结点，以是插入数据后我们需要运用堆的向上调整算法对堆举行调整，使其在插入数据后仍然保持堆的结构。

1. void HeapPush(HP* php, HPDataType x)
2. {
3.         assert(php);
5.         if (php->size == php->capacity)
6.         {
7.                 HPDataType* tmp = (HPDataType*)realloc(php->a,
8.                          sizeof(HPDataType) * php->capacity*2);
9.                 if (tmp == NULL)
10.                 {
11.                         perror("realloc fail");
12.                         return;
13.                 }
14.                 php->a = tmp;
15.                 php->capacity *= 2;
16.         }
18.         php->a[php->size] = x;
19.         php->size++;
21.         AdjustUp(php->a, php->size - 1); // 向上调整
22. }

复制代码

4.2.5 堆的删除

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

1. //堆的删除
2. void HeapPop(HP* php)
3. {
4.         assert(php);
5.         assert(!HeapEmpty(php));
7.         Swap(&php->a[0], &php->a[php->size - 1]);//交换堆顶和最后一个结点的位置
8.         php->size--;//删除最后一个结点（也就是删除原来堆顶的元素）
9.         AdjustDown(php->a, php->size, 0);//向下调整
10. }

复制代码

5. 树与二叉树练习题目

题目一：翻转二叉树
226. 翻转二叉树 - 力扣（LeetCode）
给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

1. struct TreeNode* invertTree(struct TreeNode* root) {
2.     if(root==NULL)
3.         return NULL;
4.     struct TreeNode *temp=root->left;
5.     root->left=root->right;
6.     root->right=temp;
7.     invertTree(root->left);
8.     invertTree(root->right);
9.     return root;
10. }
12. //先递归再翻转也是可以的，道理是一样的
13. struct TreeNode* invertTree(struct TreeNode* root) {
14.     if(root==NULL)
15.         return NULL;
16.     struct TreeNode*left= invertTree(root->left);
17.     struct TreeNode*right= invertTree(root->right);
18.     root->left=right;
19.     root->right=left;
20.     return root;
21. }

复制代码

题目二：判断二叉树是否相等
100. 类似的树 - 力扣（LeetCode）
给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否类似。
假如两个树在结构上类似，而且节点具有类似的值，则以为它们是类似的。

1. bool isSameTree(struct TreeNode* p, struct TreeNode* q) {
2.     if (p == NULL && q == NULL) // 两个都为空则相同
3.         return true;
4.     else if (p == NULL || q == NULL)  //只有一个为空不相同
5.         return false;
6.     else if (p->val != q->val)  // 判断值是否相等
7.         return false;
8.     bool l = isSameTree(p->left, q->left);
9.     bool r = isSameTree(p->right, q->right);
10.     return l && r;
11. }

复制代码

题目三：对称二叉树
101. 对称二叉树 - 力扣（LeetCode）
给你一个二叉树的根节点 root ， 查抄它是否轴对称。
该题目思路与判断二叉树相等几乎是一模一样，这里只不外变成了左子树的值是否即是右子树的值，两边同时递归下去即可。

1. bool isSymmetricHelper(struct TreeNode *l, struct TreeNode *r)
2. {
3.     if(l==NULL&&r==NULL)
4.         return true;
5.     else if(l==NULL||r==NULL)
6.         return false;
7.     else if(l->val!=r->val)
8.         return false;
9.    
10.     return isSymmetricHelper(l->left,r->right)&&isSymmetricHelper(l->right,r->left);
12. }
14. bool isSymmetric(struct TreeNode* root) {  // 仅仅使用此函数无法完成需要额外的函数来帮助
15.     if(root==NULL)
16.         return true;
17.    
18.     return isSymmetricHelper(root->left,root->right);
19. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。