王道机考系列——数据结构

第三章 数据结构

栈

例1. 括号匹配

例2. 计算简单表达式

哈夫曼树

哈夫曼树的定义

在含有N个带权叶子结点的二叉树中，其中带权路径长度（WPL）最小的二叉树称为哈夫曼树，也成为最优二叉树。

构造哈夫曼树的算法描述如下：
给定N个权值分别为w1, w2, …, Wn的节点。
（1）将这N个结点分别作为N棵树仅含一个结点的二叉树，构成森林F.
（2）构造一个新节点，并从F中选取两棵根结点权值最小的树作为新节点的左、右子树，并且将新节点的权值置为左、右子树上根结点的权值之和。
（3）从F中删除刚才选出的两棵树，同时将新得到的树加入F中。
（4）重复步骤2和3，直至F中只剩下一棵树为止。

在构造哈夫曼树的过程中使用小根堆可以在O(logn)的时间内取得n个元素中最小的数。借助STL中的优先队列，利用如下语句：

    //  定义一个小根堆：
    priority_queue<int, vector<int>, greater<int>> Q;
    //  元素入队
    Q.push(x;)
    //  取堆顶元素
    int a = Q.top();
    //  元素出堆
    Q.pop();

例3：

题目描述：哈夫曼树，第一行输入一个数n，表示叶节点的个数。需要用这些叶节点生成哈夫曼树，根据哈夫曼树的概念，这些节点有权值，即 weight，题目需要计算出所有节点与权值的乘积之和。
输入有多组数据：
第一行数据n；
第二行有n个数据
样例输入：
    5
    1 2 2 5 9
样例输出：
    37

C++实现：

#include 
#include 
#include 

using namespace std;

priority_queue<int, vector<int>, greater<int> > Q;
int main() {
    int n;
    while(scanf("%d", &n) != EOF) {
        while(!Q.empty())
            Q.pop();
        //  排除堆非空对题目的影响
        int m = 0;

        for (int i = 0; i < n; i++) {
            scanf("%d", &m);
            Q.push(m); 
        }

        int ans = 0;
        while(Q.size() > 1) {
            int a = Q.top();
            Q.pop();
            int b = Q.top();
            Q.pop();
            ans += a + b;
            Q.push(a + b);
            //  push这里每一层叠加的时候就把权值也计算进去了 
        }
        printf("%d", ans);
    }
    return 0;
}

二叉树

二叉树节点的数据结构：

struct TNode {
    struct TNode* lchild;  //  左孩子
    struct TNode* rchild;  //  右孩子
    ElemType data;         //  数据域
} TNode, *BiTree;

求二叉树的后序遍历结果

**题目：**已知二叉树的前序遍历和中序遍历， 求二叉树的后序遍历结果，根据前序和中序建立二叉树再输出结果。

cpp编程结果：

#include 
using namespace std;

typedef struct TNode {
    struct TNode* lchild;  //  左孩子
    struct TNode* rchild;  //  右孩子
    char data;         //  数据域
} TNode, *BiTree;

BiTree CreatTree(char Pre[], char In[], int pl, int pr, int il, int ir) {
    BiTree root = NULL;
    root = new TNode();
    root -> data = Pre[pl];
    int index = 0;
    for (index = il; In[index] != Pre[pl]; index++);  
    // 寻找前序第一个节点在中序中的位置
    int lenl = index - il;
    int lenr = ir - index;
    if (lenl) {
        root -> lchild = CreatTree(Pre, In, pl + 1, pl + lenl, il, il + lenl - 1);
    } else {
        root -> lchild = NULL;
    }

    if (lenr ) {
        root -> rchild = CreatTree(Pre, In, pr - lenr + 1, pr, ir - lenr + 1, ir);
    } else {
        root -> rchild = NULL;
    }
    return root;
}

void PostOrder(BiTree T) {
    if (T != NULL) {
        PostOrder(T -> lchild);
        PostOrder(T -> rchild);
        printf("%c", T -> data);
    }
}

void PostDeletTree(BiTree root) {
    if(root != NULL) {
        BiTree(root -> lchild);
        BiTree(root -> rchild);
        delete(root);
    }
}
int main() {
    char pre[26];
    char in[26];
    while(gets(pre) && gets(in)) {
        int len = 0;
        for(len = 0; pre[len] != '\0'; len++);
        //建立二叉树
        BiTree root = CreatTree(pre, in, 0, len - 1, 0, len - 1);
        PostOrder(root);  // 后序遍历二叉树
        printf("\n");
        PostDeletTree(root);  //  释放建立二叉树时动态分配的内存
    }
    return 0;
}

二叉排序树

题目： 输入一系列整数，建立二叉排序树，并对二叉排序树进行前序中序和后序遍历
输入：第一行包括一个整数n(0提示： 输入可能包含重复数字，单输出的时候不用输出重复数字。

#include 
using namespace std;

typedef struct BNode {
    struct BNode* lchild;  //  左孩子
    struct BNode* rchild;  //  右孩子
    int data;         //  数据域
} BNode, *BiTree;

void PreOrder(BiTree T) {
    if (T != NULL) {
        printf("%d ", T -> data);
        PreOrder(T -> lchild);
        PreOrder(T -> rchild);
    }
}

void InOrder(BiTree T) {
    if (T != NULL) {
        InOrder(T -> lchild);
        printf("%d ", T -> data);
        InOrder(T -> rchild);
    }
}

void PostOrder(BiTree T) {
    if (T != NULL) {
        PostOrder(T -> lchild);
        PostOrder(T -> rchild);
        printf("%d ", T -> data);
    }
}

BiTree BiSortTree(BiTree &root, int a) {
    //建立二叉排序树的算法
    if (root) {
        if (a < root -> data)
            root -> lchild = BiSortTree(root -> lchild, a);
        else if(a > root -> data)
            root -> rchild = BiSortTree(root -> rchild, a);
    } else {
        root = new BNode();
        root -> data = a;
    }
    return root;
}

void PostDeletTree(BiTree root) {
    //  后序删除二叉排序树
    if(root != NULL) {
        BiTree(root -> lchild);
        BiTree(root -> rchild);
        delete(root);
    }
}

int main() {
    int n = 0;
    while(scanf("%d", &n) != EOF) {
        BiTree T;
        int x;
        while(n--) {
            scanf("%d", &x);
            T = BiSortTree(T, x);
        }

        printf("前序遍历结果：");
        PreOrder(T);
        printf("\n中序遍历结果: ");
        InOrder(T);
        printf("\n后序遍历结果：");
        PostOrder(T);
        printf("\n");
        PostDeletTree(T);
    }
    return 0;
}

二叉排序树

题目： 开始是一个数n(0

样例输入：
    2
    567432
    543267
    576342
样例输出：
    YES
    NO

思路：比较二叉排序树的遍历结果来判断两棵树是否一样

#include 
#include 
using namespace std;

typedef struct BNode {
    struct BNode* lchild;  //  左孩子
    struct BNode* rchild;  //  右孩子
    char data;         //  数据域
} BNode, *BiTree;

void PreOrder(BiTree T, char po[], int &index) {
    if (T != NULL) {
        po[index] = T -> data;
        index++;
        PreOrder(T -> lchild, po, index);
        PreOrder(T -> rchild, po, index);
    }
}

void InOrder(BiTree T, char po[], int &index) {
    if (T != NULL) {
        InOrder(T -> lchild, po, index);
        po[index] = T -> data;
        index++;
        InOrder(T -> rchild, po, index);
    }
}

BiTree BiSortTree(BiTree &root, int a) {
    //建立二叉排序树的算法
    if (root) {
        if (a < root -> data)
            root -> lchild = BiSortTree(root -> lchild, a);
        else if(a > root -> data)
            root -> rchild = BiSortTree(root -> rchild, a);
    } else {
        root = new BNode();
        root -> data = a;
    }
    return root;
}

void PostDeletTree(BiTree root) {
    //  后序删除二叉排序树
    if(root != NULL) {
        BiTree(root -> lchild);
        BiTree(root -> rchild);
        delete(root);
    }
}

int main() {
    int n = 0;
    while(scanf("%d", &n) != EOF && n != 0) {
        BiTree T = NULL;
        char old[10] = {'\0'};
        char pold[10] = {'\0'};
        char iold[10] = {'\0'};
        char str[10] = {'\0'};
        char pstr[10] = {'\0'};
        char istr[10] = {'\0'};
        int index = 0;
        
        scanf("%s", old);
        int i = 0;
        for (i = 0; old[i] != '\0'; i++)
            T = BiSortTree(T, old[i]);
        
        index = 0;
        PreOrder(T, pold, index);
        index = 0;
        InOrder(T, iold, index);
        PostDeletTree(T);
        
        for (int j = 0; j < n; j++) {
            //  将指针初始化为空很重要 
            BiTree NT = NULL;
            for (int l = 0; l < n; l++) {
                str[l] = '\0';
                pstr[l] = '\0';
                istr[l] = '\0';
            }
            scanf("%s", str);
            for (int k = 0; str[k] != '\0'; k++)
                NT = BiSortTree(NT, str[k]);
            index = 0;
            PreOrder(NT, pstr, index);
            index = 0;
            InOrder(NT, istr, index);
            
            if (strcmp(pold, pstr) == 0 && strcmp(iold, istr) == 0)
                printf("YES\n");
            else
                printf("NO\n");
            PostDeletTree(NT);
        }
        
        printf("please input the number n: ");
    }
    return 0;
}