哈夫曼树;二叉树;二叉排序树(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.哈夫曼树(九度)

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

 

#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 = 1;i <= n;i ++) { //输入n个叶子结点权值
            int x;
            scanf ("%d",&x);
            Q.push(x); //将权值放入堆中
        }
        int ans = 0; //保存答案
        while(Q.size() > 1) { //当堆中元素大于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 0;
}

 

32.二叉树遍历(jiu du)

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

 

 

#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[50]; //静态内存分配数组
int loc; //静态数组中已经分配的结点个数
Node *creat() { //申请一个结点空间,返回指向其的指针
    Tree[loc].lchild = Tree[loc].rchild = NULL; cout << loc << ' ';//初始化左右儿子为空
    return &Tree[loc ++]; //返回指针,且loc累加
}
char str1[30] , str2[30]; //保存前序和中序遍历结果字符串
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 + 1,s1 + (rootIdx - s2),s2,rootIdx - 1); //递归还原其左子树
    }
    if (rootIdx != e2) { //若右子树不为空
        ret -> rchild = build(s1 + (rootIdx - s2) + 1,e1,rootIdx + 1,e2); //递归还原其右子树
    }
    return ret; //返回根节点指针
}
int main () {
    while (scanf ("%s",str1) != EOF) {
        scanf ("%s",str2); //输入
        loc = 0; //初始化静态内存空间中已经使用结点个数为0
        int L1 = strlen(str1);
        int L2 = strlen(str2); //计算两个字符串长度
        Node *T = build(0,L1 - 1,0,L2 - 1); //还原整棵树,其根结点指针保存在T中
        postOrder(T); //后序遍历
        printf("\n"); //输出换行
    }
    return 0;
}

 

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

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

 

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

 

#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[110]; //静态数组
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 = 0;
        Node *T = NULL; //二叉排序树树根结点为空
        for (int i = 0;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 0;
}

 

 

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

 

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