哈夫曼树;二叉树;二叉排序树(BST)

优先队列:priority_queue<Type, Container, Functional>
Type 为数据类型， Container 为保存数据的容器，Functional 为元素比较方式。
Container 必须是用数组实现的容器，比如 vector, deque 但不能用 list.
STL里面默认用的是 vector. 比较方式默认用 operator< , 所以如果你把后面俩个
参数缺省的话，优先队列就是大顶堆，队头元素最大。

而在求哈夫曼树中,我
们恰恰需要取得堆中最小的元素,于是我们使用如下语句定义一个小顶堆:
priority_queue<int , vector<int> , greater<int> > Q;
关于堆的有关操作如下:
Q.push(x);
将元素 x 放入堆 Q 中。
int a = Q.top();
取出堆顶元素,即最小的元素保存在 a 中。
Q.pop();

弹出堆顶元素,取出后堆会自动调整为一个新的小顶堆。
它的定义与之前我们使用过的队列一样在标准模板库 queue 中,所以在使用
它之前我们必须做相应预处理。
#include <queue>

30.哈夫曼树(九度)

 .哈夫曼树
 时间限制: 秒
 内存限制: 兆
 特殊判题:否
 题目描述:
 哈夫曼树,第一行输入一个数 n,表示叶结点的个数。需要用这些叶结点生
 成哈夫曼树,根据哈夫曼树的概念,这些结点有权值,即 weight,题目需要输出
 所有结点的值与权值的乘积之和。
 输入:
 输入有多组数据。
 每组第一行输入一个数 n,接着输入 n 个叶节点(叶节点权值不超过 ,
 <=n<=)。
 输出:
 输出权值。
 样例输入:

 样例输出:
 

 #include <algorithm>
 #include <functional>
 #include <array>
 #include <iostream>
 #include <limits.h>
 #include <queue>
 using namespace std;

 priority_queue<int , vector<int> , greater<int> > Q; //建立一个小顶堆
 int main () {
     int n;
     while (scanf ("%d",&n) != EOF) {
         while(Q.empty() == false) Q.pop(); //清空堆中元素
         for (int i = ;i <= n;i ++) { //输入n个叶子结点权值
             int x;
             scanf ("%d",&x);
             Q.push(x); //将权值放入堆中
         }
         int ans = ; //保存答案
         while(Q.size() > ) { //当堆中元素大于1个
             int a = Q.top();
             Q.pop();
             int b = Q.top();
             Q.pop(); //取出堆中两个最小元素,他们为同一个结点的左右儿子,且该双亲结点的权值为它们的和
                     ans += a + b; //该父亲结点必为非叶子结点,固累加其权值
             Q.push(a + b); //将该双亲结点的权值放回堆中
         }
         printf("%d\n",ans); //输出答案
     }
     return ;
 }

32.二叉树遍历(jiu du)

 二叉树遍历(九度教程第  题)
 时间限制: 秒
 内存限制: 兆
 特殊判题:否题目描述:
 二叉树的前序、中序、后序遍历的定义:
 前序遍历:对任一子树,先访问跟,然后遍历其左子树,最后遍历其右子树;
 中序遍历:对任一子树,先遍历其左子树,然后访问根,最后遍历其右子树;
 后序遍历:对任一子树,先遍历其左子树,然后遍历其右子树,最后访问根。
 给定一棵二叉树的前序遍历和中序遍历,求其后序遍历(提示:给定前序遍
 历与中序遍历能够唯一确定后序遍历)。
 输入:
 两个字符串,其长度 n 均小于等于 。
 第一行为前序遍历,第二行为中序遍历。二叉树中的结点名称以大写字母表
 示:A,B,C....最多  个结点。
 输出:
 输入样例可能有多组,对于每组测试样例,输出一行,为后序遍历的字符串。
 样例输入:
 ABC
 BAC
 FDXEAG
 XDEFAG
 样例输出:
 BCA
 XEDGAF

Problem

 #include <algorithm>
 #include <functional>
 #include <array>
 #include <iostream>
 #include <limits.h>
 #include <queue>
 #include <stdio.h>
 #include <string.h>
 using namespace std;
 struct Node { //树结点结构体
     Node *lchild; //左儿子指针
     Node *rchild; //右儿子指针
     char c; //结点字符信息
 }Tree[]; //静态内存分配数组
 int loc; //静态数组中已经分配的结点个数
 Node *creat() { //申请一个结点空间,返回指向其的指针
     Tree[loc].lchild = Tree[loc].rchild = NULL; cout << loc << ' ';//初始化左右儿子为空
     return &Tree[loc ++]; //返回指针,且loc累加
 }
 char str1[] , str2[]; //保存前序和中序遍历结果字符串
 void postOrder(Node *T) { //后序遍历
     if (T -> lchild != NULL) { //若左子树不为空
         postOrder(T -> lchild); //递归遍历其左子树
     }
     if (T -> rchild != NULL) { //若右子树不为空
         postOrder(T -> rchild); //递归遍历其右子树
     }
     printf("%c",T -> c); //遍历该结点,输出其字符信息
 }
 Node *build(int s1,int e1,int s2,int e2) { //由字符串的前序遍历和中序遍历还原树,并返回其根节点,其中前序遍历结果为由str1[s1]到str1[e1],中序遍历结果为str2[s2]到str2[e2]
     Node* ret = creat(); //为该树根节点申请空间
     ret -> c = str1[s1]; //该结点字符为前序遍历中第一个字符
     int rootIdx;
     for (int i = s2;i <= e2;i ++) {//查找该根节点字符在中序遍历中的位置
         if (str2[i] == str1[s1]) {
             rootIdx = i;
             break;
         }
     }
     if (rootIdx != s2) { //若左子树不为空
         ret -> lchild = build(s1 + ,s1 + (rootIdx - s2),s2,rootIdx - ); //递归还原其左子树
     }
     if (rootIdx != e2) { //若右子树不为空
         ret -> rchild = build(s1 + (rootIdx - s2) + ,e1,rootIdx + ,e2); //递归还原其右子树
     }
     return ret; //返回根节点指针
 }
 int main () {
     while (scanf ("%s",str1) != EOF) {
         scanf ("%s",str2); //输入
         loc = ; //初始化静态内存空间中已经使用结点个数为0
         int L1 = strlen(str1);
         int L2 = strlen(str2); //计算两个字符串长度
         Node *T = build(,L1 - ,,L2 - ); //还原整棵树,其根结点指针保存在T中
         postOrder(T); //后序遍历
         printf("\n"); //输出换行
     }
     return ;
 }

35.二叉排序树 （Binary Search Tree），（又：二叉搜索树，二叉查找树）

由于各个数字插入的顺序不同,所得到的二叉排序树的形态也很可能不同,
所以不同的插入顺序对二叉排序树的形态有重要的影响。但是,所有的二叉排序
树都有一个共同的特点:若对二叉排序树进行中序遍历,那么其遍历结果必然是
一个递增序列,这也是二叉排序树名字的来由,通过建立二叉排序树就能对原无
序序列进行排序,并实现动态维护。

 例 3.5 二叉排序树 (九度教程第   题)
 时间限制: 秒
 内存限制: 兆
 特殊判题:否
 题目描述:
 输入一系列整数,建立二叉排序数,并进行前序,中序,后序遍历。
 输入:
 输入第一行包括一个整数 n(<=n<=)。接下来的一行包括 n 个整数。
 输出:
 可能有多组测试数据,对于每组数据,将题目所给数据建立一个二叉排序树,
 并对二叉排序树进行前序、中序和后序遍历。每种遍历结果输出一行。每行最后
 一个数据之后有一个空格。
 样例输入:

 样例输出:

 提示:
 输入中可能有重复元素,但是输出的二叉树遍历序列中重复元素不用输出。

problem

 #include <algorithm>
 #include <functional>
 #include <array>
 #include <iostream>
 #include <limits.h>
 #include <queue>
 #include <stdio.h>
 #include <string.h>
 using namespace std;
 struct Node { //二叉树结构体
     Node *lchild; //左儿子指针
     Node *rchild; //右儿子指针
     int c;//保存数字
 }Tree[]; //静态数组
 int loc; //静态数组中被使用元素个数
 Node *creat() { //申请未使用的结点
     Tree[loc].lchild = Tree[loc].rchild = NULL;
     return &Tree[loc ++];
 }
 void postOrder(Node *T) { //后序遍历
     if (T -> lchild != NULL) {
         postOrder(T -> lchild);
     }
     if (T -> rchild != NULL) {
         postOrder(T -> rchild);
     }
     printf("%d ",T -> c);
 }
 void inOrder(Node *T) { //中序遍历
     if (T -> lchild != NULL) {
         inOrder(T -> lchild);
     }
     printf("%d ",T -> c);
     if (T -> rchild != NULL) {
         inOrder(T -> rchild);
     }
 }
 void preOrder(Node *T) { //前序遍历
     printf("%d ",T -> c);
     if (T -> lchild != NULL) {
         preOrder(T -> lchild);
     }
     if (T -> rchild != NULL) {
         preOrder(T -> rchild);
     }
 }
 Node *Insert(Node *T,int x) { //插入数字
     if (T == NULL) { //若当前树为空
         T = creat(); //建立结点
         T -> c = x; //数字直接插入其根结点
         return T; //返回根结点指针
     }
     else if (x < T->c) //若x小于根结点数值
         T -> lchild = Insert(T -> lchild,x); //插入到左子树上
     else if (x > T->c) //若x大于根结点数值
         T -> rchild = Insert(T -> rchild,x); //插入到右子树上.若根结点数值与x一样,根据题目要求直接忽略
     return T; //返回根节点指针
 }
 int main () {
     int n;
     while (scanf ("%d",&n) != EOF) {
         loc = ;
         Node *T = NULL; //二叉排序树树根结点为空
         for (int i = ;i < n;i ++) { //依次输入n个数字
             int x;
             scanf ("%d",&x);
             T = Insert(T,x); //插入到排序树中
         }
         preOrder(T); //前序遍历
         printf("\n"); //输出空行
         inOrder(T); //中序遍历
         printf("\n");
         postOrder(T); //后序遍历
         printf("\n");
     }
     return ;
 }

 例 3.6 二叉搜索树(九度教程第  题)
 时间限制: 秒
 内存限制: 兆
 特殊判题:否
 题目描述:
 判断两序列是否为同一二叉搜索树序列
 输入:
 开始一个数 n,(<=n<=) 表示有 n 个需要判断,n=  的时候输入结束。
 接下去一行是一个序列,序列长度小于 ,包含(~)的数字,没有重复数字,
 根据这个序列可以构造出一颗二叉搜索树。
 接下去的 n 行有 n 个序列,每个序列格式跟第一个序列一样,请判断这两个
 序列是否能组成同一颗二叉搜索树。
 输出:
 如果序列相同则输出 YES,否则输出 NO
 样例输入:

 样例输出:
 YES
 NO

problem

 #include <algorithm>
 #include <functional>
 #include <array>
 #include <iostream>
 #include <limits.h>
 #include <queue>
 #include <stdio.h>
 #include <string.h>
 using namespace std;

 struct Node { //树节点结构体
     Node *lchild;
     Node *rchild;
     int c;
 }Tree[];
 int loc;
 Node *creat() { //申请结点空间
     Tree[loc].lchild = Tree[loc].rchild = NULL;
     return &Tree[loc ++];
 }
 char str1[] , str2[]; //保存二叉排序树的遍历结果,将每一棵树的前序遍历得到的字符串与中序遍历得到的字符串连接,得到遍历结果字符串
 int size1 , size2; //保存在字符数组中的遍历得到字符个数
 char *str; //当前正在保存字符串
 int *size; //当前正在保存字符串中字符个数
 void postOrder(Node *T) { //前序遍历
     if (T -> lchild != NULL) {
         postOrder(T -> lchild);
     }
     if (T -> rchild != NULL) {
         postOrder(T -> rchild);
     }
     str[ (*size) ++ ] = T -> c + ''; //将结点中的字符放入正在保存的字符串中
 }
 void inOrder(Node *T) { //中序遍历
     if (T -> lchild != NULL) {
         inOrder(T -> lchild);
     }
     str[ (*size) ++ ] = T -> c + '';
     if (T -> rchild != NULL) {
         inOrder(T -> rchild);
     }
 }
 Node *Insert(Node *T,int x) { //将数字插入二叉树
     if (T == NULL) {
         T = creat();
         T -> c = x;
         return T;
     }
     else if (x < T->c)
         T -> lchild = Insert(T -> lchild,x);
     else if (x > T->c)
         T -> rchild = Insert(T -> rchild,x);
     return T;
 }
 int main () {
     int n;
     char tmp[];
     while (scanf ("%d",&n) != EOF && n != ) {
         loc = ; //初始化静态空间为未使用
         Node *T = NULL;
         scanf ("%s",tmp); //输入字符串
         for (int i = ;tmp[i] != ;i ++) {
             T = Insert(T,tmp[i] - ''); //按顺序将数字插入二叉排序树
         }
         size1 = ; //保存在第一个字符串中的字符初始化为0
         str = str1; //将正在保存字符串设定为第一个字符串
         size = &size1; //将正在保存字符串中的字符个数指针指向size1
         postOrder(T); //前序遍历
         inOrder(T); //中序遍历
         str1[ size1 ] = ; //向第一个字符串的最后一个字符后添加空字符,方便使用字符串函数
         while(n -- != ) { //输入n个其它字符串
             scanf ("%s",tmp); //输入
             Node *T2 = NULL;
             for (int i = ;tmp[i] != ;i ++) { //建立二叉排序树
                 T2 = Insert(T2,tmp[i] - '');
             }
             size2 = ; //第二个字符串保存字符初始化为0
             str = str2; //将正在保存字符串设定为第二个字符串
             size = &size2; //正在保存字符串中字符数量指针指向size2
             postOrder(T2); //前序遍历
             inOrder(T2); //中序遍历
             str2[ size2 ] = ; //字符串最后添加空字符
             puts (strcmp(str1,str2) ==  ? "YES" : "NO"); //比较两个遍历字符串,若相同则输出YES,否则输出NO
         }
     }
     return ;
 }