第二弹数据结构初步的主要内容有以下几部分：二叉搜索树、队列与优先队列、堆栈Stack、完全二叉树与满二叉树、哈希表。

一、二叉搜索树

1、 二叉查找树（BinarySearch Tree，也叫二叉搜索树，或称二叉排序树Binary Sort Tree）或者是一棵空树，或者是具有下列性质的二叉树：

    （1）、若它的左子树不为空，则左子树上所有结点的值均小于它的根结点的值；

    （2）、若它的右子树不为空，则右子树上所有结点的值均大于它的根结点的值；

    （3）、它的左、右子树也分别为二叉查找树。

2、二叉查找树的基本运算 

[cpp]  view plain  copy
  1. /* bst - binary search/sort tree  
  2.  * by Richard Tang <tanglinux@gmail.com>  
  3.  */  
  4. #include <stdio.h>  
  5. #include <stdlib.h>  
  6.   
  7. typedef int data_type;  
  8.   
  9. typedef struct bst_node {  
  10.     data_type data;  
  11.     struct bst_node *lchild, *rchild;  
  12. }bst_t, *bst_p;  

    （1）、插入

    在二叉查找树中插入新结点，要保证插入新结点后仍能满足二叉查找树的性质。例子中的插入过程如下：

    a、若二叉查找树root为空，则使新结点为根；

    b、若二叉查找树root不为空，则通过search_bst_for_insert函数寻找插入点并返回它的地址（若新结点中的关键字已经存在，则返回空指针）；

    c、若新结点的关键字小于插入点的关键字，则将新结点插入到插入点的左子树中，大于则插入到插入点的右子树中。 

[cpp]  view plain  copy
  1. static bst_p search_bst_for_insert(bst_p *root, data_type key)  
  2. {  
  3.     bst_p s, p = *root;  
  4.   
  5.     while (p) {  
  6.     s = p;  
  7.   
  8.     if (p->data == key)  
  9.         return NULL;  
  10.   
  11.     p = (key < p->data) ? p->lchild : p->rchild;  
  12.     }  
  13.   
  14.     return s;  
  15. }  
  16.   
  17. void insert_bst_node(bst_p *root, data_type data)  
  18. {  
  19.     bst_p s, p;  
  20.   
  21.     s = malloc(sizeof(struct bst_node));  
  22.     if (!s)  
  23.     perror("Allocate dynamic memory");  
  24.   
  25.     s -> data = data;  
  26.     s -> lchild = s -> rchild = NULL;  
  27.   
  28.     if (*root == NULL)  
  29.     *root = s;  
  30.     else {  
  31.     p = search_bst_for_insert(root, data);  
  32.     if (p == NULL) {  
  33.         fprintf(stderr, "The %d already exists.\n", data);  
  34.         free(s);  
  35.         return;  
  36.     }  
  37.   
  38.     if (data < p->data)  
  39.         p->lchild = s;  
  40.     else  
  41.         p->rchild = s;  
  42.     }  
  43. }  

    （2）、遍历 

[cpp]  view plain  copy
  1. static int print(data_type data)  
  2. {  
  3.     printf("%d ", data);  
  4.   
  5.     return 1;  
  6. }  
  7.   
  8. int pre_order_traverse(bst_p root, int (*visit)(data_type data))   
  9. {  
  10.     if (root) {  
  11.     if (visit(root->data))  
  12.         if (pre_order_traverse(root->lchild, visit))  
  13.             if (pre_order_traverse(root->rchild, visit))  
  14.                 return 1;  
  15.     return 0;  
  16.     }  
  17.     else  
  18.     return 1;  
  19. }  
  20.   
  21. int post_order_traverse(bst_p root, int (*visit)(data_type data))  
  22. {  
  23.     if (root) {  
  24.     if (post_order_traverse(root->lchild, visit))  
  25.         if (visit(root->data))  
  26.         if (post_order_traverse(root->rchild, visit))  
  27.             return 1;  
  28.     return 0;  
  29.     }  
  30.     else  
  31.     return 1;  
  32. }  

    中序遍历二叉查找树可得到一个关键字的有序序列。

    （3）、删除

    删除某个结点后依然要保持二叉查找树的特性。例子中的删除过程如下：

    a、若删除点是叶子结点，则设置其双亲结点的指针为空。

    b、若删除点只有左子树，或只有右子树，则设置其双亲结点的指针指向左子树或右子树。

    c、若删除点的左右子树均不为空，则：

    1）、查询删除点的右子树的左子树是否为空，若为空，则把删除点的左子树设为删除点的右子树的左子树。

 

    2）、若不为空，则继续查询左子树，直到找到最底层的左子树为止。

 

[cpp]  view plain  copy
  1. void delete_bst_node(bst_p *root, data_type data)  
  2. {  
  3.     bst_p p = *root, parent, s;  
  4.   
  5.     if (!p) {  
  6.     fprintf(stderr, "Not found %d.\n", data);  
  7.     return;  
  8.     }  
  9.   
  10.     if (p->data == data) {  
  11.     /* It's a leaf node */  
  12.     if (!p->rchild && !p->lchild) {  
  13.         *root = NULL;  
  14.         free(p);  
  15.     }  
  16.     /* the right child is NULL */  
  17.     else if (!p->rchild) {  
  18.         *root = p->lchild;  
  19.         free(p);  
  20.     }  
  21.     /* the left child is NULL */  
  22.     else if (!p->lchild) {  
  23.         *root = p->rchild;  
  24.         free(p);  
  25.     }  
  26.     /* the node has both children */  
  27.     else {  
  28.         s = p->rchild;  
  29.         /* the s without left child */  
  30.         if (!s->lchild)  
  31.         s->lchild = p->lchild;  
  32.         /* the s have left child */  
  33.         else {  
  34.         /* find the smallest node in the left subtree of s */  
  35.         while (s->lchild) {  
  36.             /* record the parent node of s */  
  37.             parent = s;  
  38.             s = s->lchild;  
  39.         }  
  40.         parent->lchild = s->rchild;  
  41.         s->lchild = p->lchild;  
  42.         s->rchild = p->rchild;  
  43.         }  
  44.         *root = s;  
  45.         free(p);  
  46.     }  
  47.     }   
  48.     else if (data > p->data) {  
  49.     delete_bst_node(&(p->rchild), data);  
  50.     }   
  51.     else if (data < p->data) {  
  52.     delete_bst_node(&(p->lchild), data);  
  53.     }  
  54. }  

    4、二叉查找树的查找分析

    同样的关键字，以不同的插入顺序，会产生不同形态的二叉查找树。 

[cpp]  view plain  copy
  1. int main(int argc, char *argv[])  
  2. {  
  3.     int i, num;  
  4.     bst_p root = NULL;  
  5.   
  6.     if (argc < 2) {  
  7.     fprintf(stderr, "Usage: %s num\n", argv[0]);  
  8.     exit(-1);  
  9.     }  
  10.   
  11.     num = atoi(argv[1]);  
  12.     data_type arr[num];  
  13.     printf("Please enter %d integers:\n", num);  
  14.     for (i = 0; i < num; i++) {  
  15.     scanf("%d", &arr[i]);  
  16.     insert_bst_node(&root, arr[i]);  
  17.     }  
  18.   
  19.     printf("\npre order traverse: ");  
  20.     pre_order_traverse(root, print);  
  21.     printf("\npost order traverse: ");  
  22.     post_order_traverse(root, print);  
  23.     printf("\n");  
  24.   
  25.     delete_bst_node(&root, 45);  
  26.   
  27.     printf("\npre order traverse: ");  
  28.     pre_order_traverse(root, print);  
  29.     printf("\npost order traverse: ");  
  30.     post_order_traverse(root, print);  
  31.     printf("\n");  
  32.       
  33.     return 0;  
  34. }  

    运行两次，以不同的顺序输入相同的六个关键字：

     

    根据前序遍历的结果可得到两次运行所产生的二叉查找树的形态并不相同，如下图：

 




二、队列与优先队列

队列：

队列特性：先进先出（FIFO)——先进队列的元素先出队列。来源于我们生活中的队列（先排队的先办完事）。

队列有下面几个操作：

  • InitQueue（）　　 ——初始化队列
  • EnQueue（）        ——进队列
  • DeQueue（）        ——出队列
  • IsQueueEmpty（）——判断队列是否为空
  • IsQueueFull（）    ——判断队列是否已满

队列可以由数组和链表两种形式实现队列操作（c语言），下面仅以数组为例：

数组实现：

队列数据结构

复制代码 
typedef struct queue
{
        int queuesize;   //数组的大小
        int head, tail;  //队列的头和尾下标
        int *q;          //数组头指针
}Queue;
复制代码

InitQueue（）　　 ——初始化队列

复制代码 
void InitQueue(Queue *Q)
{
        Q->queuesize = 8;
        Q->q = (int *)malloc(sizeof(int) * Q->queuesize); //分配内存
        Q->tail = 0;
        Q->head = 0;
}
复制代码

这样有个缺陷，空间利用率不高。采用循环队列：

 

EnQueue（）        ——进队列

复制代码 
void EnQueue(Queue *Q, int key)
{
        int tail = (Q->tail+1) % Q->queuesize; //取余保证，当quil=queuesize-1时，再转回0
        if (tail == Q->head)                   //此时队列没有空间
        {
            printf("the queue has been filled full!");
        }
        else
        {
            Q->q[Q->tail] = key;
            Q->tail = tail;
        }
}
复制代码

DeQueue（）        ——出队列

复制代码 
int DeQueue(Queue *Q)
{
        int tmp;
        if(Q->tail == Q->head)     //判断队列不为空
        {
            printf("the queue is NULL\n");
        }
        else
        {
            tmp = Q->q[q->head];
            Q->head = (Q->head+1) % Q->queuesize;
        }
        return tmp;
}
复制代码

IsQueueEmpty（）——判断队列是否为空

复制代码 
int IsQueueEmpty(Queue *Q)
{
        if(Q->head == Q->tail)
        {
            return 1;
        }
        else
        {
            return 0;
        }
}
复制代码

IsQueueFull（）——判断队列是否已满

复制代码 
int IsQueueFull(Queue *Q)
{
    if((Q->tail+1)% Q->queuesize == Q->head)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

优先队列：

队列(queue)维护了一组对象，进入队列的对象被放置在尾部，下一个被取出的元素则取自队列的首部。priority_queue特别之处在于，允许用户为队列中存储的元素设置优先级。这种队列不是直接将新元素放置在队列尾部，而是放在比它优先级低的元素前面。标准库默认使用<操作符来确定对象之间的优先级关系，所以如果要使用自定义对象，需要重载 < 操作符。

优先队列有两种，一种是最大优先队列；一种是最小优先队列；每次取自队列的第一个元素分别是优先级最大和优先级最小的元素。

1) 优先队列的定义

包含头文件："queue.h", "functional.h"

可以使用具有默认优先级的已有数据结构；也可以再定义优先队列的时候传入自定义的优先级比较对象；或者使用自定义对象(数据结构)，但是必须重载好< 操作符。 

2) 优先队列的常用操作

优先级队列支持的操作

q.empty()         如果队列为空，则返回true，否则返回false

q.size()            返回队列中元素的个数

q.pop()             删除队首元素，但不返回其值

q.top()             返回具有最高优先级的元素值，但不删除该元素

q.push(item)     在基于优先级的适当位置插入新元素

其中q.top()为查找操作，在最小优先队列中搜索优先权最小的元素，在最大优先队列中搜索优先权最大的元素。q.pop()为删除该元素。优先队列插入和删除元素的复杂度都是O(lgn)，所以很快

在优先队列中，优先级高的元素先出队列。标准库默认使用元素类型的<操作符来确定它们之间的优先级关系。

优先队列的第一种用法，也是最常用的用法：

[cpp]  view plain  copy
  1. priority_queue<int> qi;  

通过<操作符可知在整数中元素大的优先级高。

故示例1中输出结果为：9 6 5 3 2

第二种方法：

在示例1中，如果我们要把元素从小到大输出怎么办呢？

这时我们可以传入一个比较函数，使用functional.h函数对象作为比较函数。

[cpp]  view plain  copy
  1. priority_queue<int, vector<int>, greater<int> > qi2;  

其中

第二个参数为容器类型。

第三个参数为比较函数。

故示例2中输出结果为：2 3 5 6 9

第三种方法：自定义优先级。

[cpp]  view plain  copy
  1. struct node  
  2. {  
  3.     friend bool operator< (node n1, node n2)  
  4.     {  
  5.         return n1.priority < n2.priority;  
  6.     }  
  7.     int priority;  
  8.     int value;  
  9. };  

在该结构中，value为值，priority为优先级。

通过自定义operator<操作符来比较元素中的优先级。

在示例3中输出结果为：

优先级  值

9          5

8          2

6          1

2          3

1          4

但如果结构定义如下：

[cpp]  view plain  copy
  1. struct node  
  2. {  
  3.     friend bool operator> (node n1, node n2)  
  4.     {  
  5.         return n1.priority > n2.priority;  
  6.     }  
  7.     int priority;  
  8.     int value;  
  9. };  


则会编译不过（G++编译器）因为标准库默认使用元素类型的<操作符来确定它们之间的优先级关系。而且自定义类型的<操作符与>操作符并无直接联系，故会编译不过。

//代码清单

[cpp]  view plain  copy
  1. #include<iostream>  
  2. #include<functional>  
  3. #include<queue>  
  4. using namespace std;  
  5. struct node  
  6. {  
  7.     friend bool operator< (node n1, node n2)  
  8.     {  
  9.         return n1.priority < n2.priority;  
  10.     }  
  11.     int priority;  
  12.     int value;  
  13. };  
  14. int main()  
  15. {  
  16.     const int len = 5;  
  17.     int i;  
  18.     int a[len] = {3,5,9,6,2};  
  19.     //示例1  
  20.     priority_queue<int> qi;  
  21.     for(i = 0; i < len; i++)  
  22.         qi.push(a[i]);  
  23.     for(i = 0; i < len; i++)  
  24.     {  
  25.         cout<<qi.top()<<" ";  
  26.         qi.pop();  
  27.     }  
  28.     cout<<endl;  
  29.     //示例2  
  30.     priority_queue<int, vector<int>, greater<int> >qi2;  
  31.     for(i = 0; i < len; i++)  
  32.         qi2.push(a[i]);  
  33.     for(i = 0; i < len; i++)  
  34.     {  
  35.         cout<<qi2.top()<<" ";  
  36.         qi2.pop();  
  37.     }  
  38.     cout<<endl;  
  39.     //示例3  
  40.     priority_queue<node> qn;  
  41.     node b[len];  
  42.     b[0].priority = 6; b[0].value = 1;   
  43.     b[1].priority = 9; b[1].value = 5;   
  44.     b[2].priority = 2; b[2].value = 3;   
  45.     b[3].priority = 8; b[3].value = 2;   
  46.     b[4].priority = 1; b[4].value = 4;   
  47.       
  48.     for(i = 0; i < len; i++)  
  49.         qn.push(b[i]);  
  50.     cout<<"优先级"<<'\t'<<"值"<<endl;  
  51.     for(i = 0; i < len; i++)  
  52.     {  
  53.         cout<<qn.top().priority<<'\t'<<qn.top().value<<endl;  
  54.         qn.pop();  
  55.     }  
  56.     return 0;  
  57. }  


 另外贴一段优先队列使用的代码：

[cpp]  view plain  copy
  1. #include<iostream>  
  2. #include<functional>  
  3. #include<queue>  
  4. #include<vector>  
  5. using namespace std;  
  6.   
  7.   
  8. struct cmp1  
  9. {  
  10.     bool operator () (int &a, int &b)  
  11.     {  
  12.         return a > b ;              // 从小到大排序，值 小的 优先级别高  
  13.     }  
  14. };  
  15.   
  16. struct cmp2  
  17. {  
  18.     bool operator () (int &a, int &b)  
  19.     {  
  20.         return a < b;             // 从大到小  
  21.     }  
  22. };  
  23.   
  24. struct number1  
  25. {  
  26.     int x;  
  27.     bool operator < (const number1 &a)const   
  28.     {  
  29.         return x > a.x;         // 从小到大  ，x 小的 优先级别高  
  30.     }  
  31. };  
  32.   
  33. struct number2  
  34. {  
  35.     int x;  
  36.     bool operator < (const number2 &a)const  
  37.     {  
  38.         return x < a.x;            // 从大到小  ，x 大的优先级别高  
  39.     }  
  40. };  
  41.   
  42. int a[] = {14,10,56,7,83,22,36,91,3,47,72,0};  
  43. number1 num1[] ={14,10,56,7,83,22,36,91,3,47,72,0};  
  44. number2 num2[] ={14,10,56,7,83,22,36,91,3,47,72,0};  
  45.   
  46. int main()  
  47. {  
  48.     priority_queue<int>que;  // 采用默认优先级构造队列  从大到小。   
  49.   
  50.     priority_queue<int, vector<int>, cmp1 >que1;  
  51.     priority_queue<int, vector<int>, cmp2 >que2;  
  52.   
  53.     priority_queue<int, vector<int>, greater<int> > que3;  //functional 头文件自带的   
  54.     priority_queue<int, vector<int>, less<int> > que4;      //functional 头文件自带的   
  55.   
  56.     priority_queue<number1> que5;  
  57.     priority_queue<number2> que6;  
  58.   
  59.   
  60.     int i;  
  61.     for(i=0;a[i];i++)  
  62.     {  
  63.         que.push(a[i]);  
  64.         que1.push(a[i]);  
  65.         que2.push(a[i]);  
  66.         que3.push(a[i]);  
  67.         que4.push(a[i]);  
  68.   
  69.     }  
  70.   
  71.      for(i=0;num1[i].x;i++)  
  72.          que5.push(num1[i]);  
  73.      for(i=0;num2[i].x;i++)   
  74.          que6.push(num2[i]);  
  75.   
  76.     printf("采用默认优先关系:\n(priority_queue<int>que;)\n");  
  77.     printf("Queue 0:\n");  
  78.         while(!que.empty())  
  79.     {  
  80.         printf("%3d",que.top());  
  81.         que.pop();  
  82.     }  
  83.     puts("");  
  84.     puts("");  
  85.       
  86.     printf("采用结构体自定义优先级方式一:\n(priority_queue<int,vector<int>,cmp>que;)\n");  
  87.     printf("Queue 1:\n");  
  88.     while(!que1.empty())  
  89.     {  
  90.         printf("%3d",que1.top());  
  91.         que1.pop();  
  92.     }  
  93.     puts("");  
  94.   
  95.     printf("Queue 2:\n");  
  96.         while(!que2.empty())  
  97.     {  
  98.         printf("%3d",que2.top());  
  99.         que2.pop();  
  100.     }  
  101.     puts("");  
  102.     puts("");  
  103.   
  104.     printf("采用头文件\"functional\"内定义优先级：\n(priority_queue<int, vector<int>,greater<int>/less<int> >que;)\n");  
  105.     printf("Queue 3:\n");  
  106.     while(!que3.empty())  
  107.     {  
  108.         printf("%3d",que3.top());  
  109.         que3.pop();  
  110.     }  
  111.     puts("");  
  112.   
  113.     printf("Queue 4 :\n");  
  114.     while(!que4.empty())  
  115.     {  
  116.         printf("%3d",que4.top());  
  117.         que4.pop();  
  118.     }  
  119.     puts("");  
  120.     puts("");  
  121.   
  122.     printf("采用结构体自定义优先级方式二:\n(priority_queue<number>que)\n");  
  123.     printf("Queue 5:\n");  
  124.     while(!que5.empty())  
  125.     {  
  126.         printf("%3d",que5.top());  
  127.         que5.pop();  
  128.     }  
  129.     puts("");  
  130.   
  131.     printf("Queue 6:\n");  
  132.     while(!que6.empty())  
  133.     {  
  134.         printf("%3d",que6.top());  
  135.         que6.pop();  
  136.     }  
  137.   
  138.     return 0;  
  139. }  


执行结果：


三、栈(Stack)

栈（statck）这种数据结构在计算机中是相当出名的。栈中的数据是先进后出的（First In Last Out, FILO）。栈只有一个出口，允许新增元素（只能在栈顶上增加）、移出元素（只能移出栈顶元素）、取得栈顶元素等操作。在STL中，栈是以别的容器作为底部结构，再将接口改变，使之符合栈的特性就可以了。因此实现非常的方便。下面就给出栈的函数列表和VS2008中栈的源代码，在STL中栈一共就5个常用操作函数（top()、push()、pop()、 size()、empty() ），很好记的。

堆栈是一个线性表，插入和删除只在表的一端进行。这一端称为栈顶(Stack Top)，另一端则为栈底(Stack Bottom)。堆栈的元素插入称为入栈，元素的删除称为出栈。由于元素的入栈和出栈总在栈顶进行，因此，堆栈是一个后进先出(Last In First Out)表，即 LIFO 表。
    C++ STL 的堆栈泛化是直接通过现有的序列容器来实现的，默认使用双端队列deque的数据结构，当然，可以采用其他线性结构（vector 或 list等），只要提供堆栈的入栈、出栈、栈顶元素访问和判断是否为空的操作即可。由于堆栈的底层使用的是其他容器，因此，堆栈可看做是一种适配器，将一种容器转换为另一种容器(堆栈容器)。
    为了严格遵循堆栈的数据后进先出原则，stack 不提供元素的任何迭代器操作，因此，stack 容器也就不会向外部提供可用的前向或反向迭代器类型。
    stack堆栈容器的C++标准头文件为 stack ，必须用宏语句 "#include <stack>" 包含进来，才可对 stack 堆栈的程序进行编译。

 

VS2008栈的源代码

友情提示：初次阅读时请注意其实现思想，不要在细节上浪费过多的时间。

[cpp]  view plain  copy
  1. //VS2008中 stack的定义 MoreWindows整理(http://blog.csdn.net/MoreWindows)  
  2. template<class _Ty, class _Container = deque<_Ty> >  
  3. class stack  
  4. {   // LIFO queue implemented with a container  
  5. public:  
  6.     typedef _Container container_type;  
  7.     typedef typename _Container::value_type value_type;  
  8.     typedef typename _Container::size_type size_type;  
  9.     typedef typename _Container::reference reference;  
  10.     typedef typename _Container::const_reference const_reference;  
  11.   
  12.     stack() : c()  
  13.     {   // construct with empty container  
  14.     }  
  15.   
  16.     explicit stack(const _Container& _Cont) : c(_Cont)  
  17.     {   // construct by copying specified container  
  18.     }  
  19.   
  20.     bool empty() const  
  21.     {   // test if stack is empty  
  22.         return (c.empty());  
  23.     }  
  24.   
  25.     size_type size() const  
  26.     {   // test length of stack  
  27.         return (c.size());  
  28.     }  
  29.   
  30.     reference top()  
  31.     {   // return last element of mutable stack  
  32.         return (c.back());  
  33.     }  
  34.   
  35.     const_reference top() const  
  36.     {   // return last element of nonmutable stack  
  37.         return (c.back());  
  38.     }  
  39.   
  40.     void push(const value_type& _Val)  
  41.     {   // insert element at end  
  42.         c.push_back(_Val);  
  43.     }  
  44.   
  45.     void pop()  
  46.     {   // erase last element  
  47.         c.pop_back();  
  48.     }  
  49.   
  50.     const _Container& _Get_container() const  
  51.     {   // get reference to container  
  52.         return (c);  
  53.     }  
  54.   
  55. protected:  
  56.     _Container c;   // the underlying container  
  57. };  

可以看出，由于栈只是进一步封装别的数据结构，并提供自己的接口，所以代码非常简洁，如果不指定容器，默认是用deque来作为其底层数据结构的（对deque不是很了解？可以参阅《STL系列之一 deque双向队列》）。下面给出栈的使用范例：

[cpp]  view plain  copy
  1. //栈 stack支持 empty() size() top() push() pop()  
  2. // by MoreWindows(http://blog.csdn.net/MoreWindows)  
  3. #include <stack>  
  4. #include <vector>  
  5. #include <list>  
  6. #include <cstdio>  
  7. using namespace std;  
  8. int main()  
  9. {  
  10.     //可以使用list或vector作为栈的容器，默认是使用deque的。  
  11.     stack<int, list<int>>      a;  
  12.     stack<int, vector<int>>   b;  
  13.     int i;  
  14.       
  15.     //压入数据  
  16.     for (i = 0; i < 10; i++)  
  17.     {  
  18.         a.push(i);  
  19.         b.push(i);  
  20.     }  
  21.   
  22.     //栈的大小  
  23.     printf("%d %d\n", a.size(), b.size());  
  24.   
  25.     //取栈项数据并将数据弹出栈  
  26.     while (!a.empty())  
  27.     {  
  28.         printf("%d ", a.top());  
  29.         a.pop();  
  30.     }  
  31.     putchar('\n');  
  32.   
  33.     while (!b.empty())  
  34.     {  
  35.         printf("%d ", b.top());  
  36.         b.pop();  
  37.     }  
  38.     putchar('\n');  
  39.     return 0;  
  40. }  



四、完全二叉树与满二叉树


满二叉树(Full Binary Tree)：

  


除最后一层无任何子节点外，每一层上的所有结点都有两个子结点（最后一层上的无子结点的结点为叶子结点）。也可以这样理解，除叶子结点外的所有结点均有两个子结点。节点数达到最大值。所有叶子结点必须在同一层上.

一颗树深度为h，最大层数为k，深度与最大层数相同，k=h;

　　它的叶子数是： 2^(h-1)
　　第k层的结点数是： 2^(k-1)
　　总结点数是： 2^k-1 (2的k次方减一)
　　总节点数一定是奇数。


完全二叉树(Complete Binary Tree)

　　然而由于满二叉树的节点数必须是一个确定的数，而非任意数，他的使用受到了某些限制，为了打破另一个限制，我们定义一种特殊的满二叉树——完全二叉树。 若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。
　　完全二叉树是由满二叉树而引出来的。对于深度为K的，有N个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。
　　若一棵二叉树至多只有最下面的两层上的结点的度数可以小于2，并且最下层上的结点都集中在该层最左边的若干位置上，则此二叉树成为完全二叉树。

      完全二叉树的节点个数是任意的，从形式上来说他是一个可能有缺失的三角形，但所缺部分肯定是右下角的某个连续部分。这样说不玩整，更准确来说，我们可以说他和满二叉树的区别是，他的最后一行可能不是完整的，但绝对是右方的连续部分缺失。可能听起来有点乱，用数学公式讲，对于K层的完全二叉树，其节点数的范围是2^(k-1)-1<N<2^k-1。


               1                                 1
            /     \                          /      \
          1        1                        1         1
       /    \    /    \                  /     \
       1    1    1     1               1         1
         满二叉树                          完全二叉树


一棵深度为k且有2的k次方减1个结点的二叉树是满二叉树。
深度为k的，有n个结点的二叉树，当且仅当其每一个结点都与深度为k的满二叉树中编号从1至n的结点一一对应时，称为完全二叉树。

霍夫曼树：每个节点要么没有子节点，要么有两个子节点。


五、哈希表

一、哈希表法简介

哈希表（Hash table，也叫散列表），是根据关键字（Key Value）而直接访问在内存存储位置的数据结构。也就是说，它通过计算一个关于键值的函数，将所需查询的数据映射到表中一个位置来访问记录，这加快了查找速度。这个映射函数称做散列函数，存放记录的数组称做散列表。

若关键字为k，则其值存放在f(k)的存储位置上。由此，不需比较便可直接取得所查记录。称这个对应关系f为散列函数，按这个思想建立的表为哈希表。


二、哈希冲突

对不同的关键字可能得到同一散列地址，即k1≠k2，而f(k1)=f(k2)，这种现象称为冲突。具有相同函数值的关键字对该散列函数来说称做同义词。


三、构造哈希函数的方法

（1）直接定址法

思想：取关键字或关键字的某个线性函数值为散列地址。即hash(k)=k或hash(k)=ak + b，其中a，b为常数 。

特点：对于不同的关键字不会产生冲突，缺点是由于关键字集合很少是连续的，会造成空间的大量浪费。


（2）除留余数法

思想：取关键字被某个不大于散列表表长m的数p除后所得的余数为散列地址。即hash(k)=k mod p， p≤m。不仅可以对关键字直接取模，也可在折叠法、平方取中法等运算之后取模。

特点：对p的选择很重要，一般取小于m的最大素数，若p选择不好，容易产生冲突。


（3）数字分析法

思想：假设关键字是以r为基的数，并且哈希表中可能出现的关键字都是事先知道的，则可选取关键字的若干数位组成哈希地址。 

特点：需要对关键字进行分析。


（4）平方取中法

思想：取关键字平方后的中间几位为哈希地址。通常在选定哈希函数时不一定能知道关键字的全部情况，取其中的哪几位也不一定合适，而一个数平方后的中间几位数和数的每一位都相关，由此使随机分布的关键字得到的哈希地址也是随机的。取的位数由表长决定。 


（5）折叠法

思想：将关键字分割成位数相同的几部分（最后一部分的位数可以不同），然后取这几部分的叠加和（舍去进位）作为哈希地址。 


四、解决哈希冲突的方法

（1）开放地址法

开放地址的基本思想是在发生冲突时，按照某种方法继续探测基本表中的其他存储单元，直到找到空位置为止。

增量di可以有不同的取法：

1、di = 1, 2, 3, ... , m-1； 线性探测再散列

2、di = 1^2, -1^2, 2^2, -2^2, 3^2，…，±（k)^2，(k<=m/2）；二次探测再散列；

3、di = 伪随机数 ；    伪随机再散列


（2）链地址法

将所有具有相同哈希地址的记录放在同一单链表中，哈希表的第i个元素存放哈希地址为i的记录组成的单链表的头指针。

（3）建立一个公共溢出区

一旦产生冲突，均把当前记录放入公共溢出区的当前表尾。


再贴几个哈希表详解的网站：

1、详解哈希表及分析HashMap的实现

2、哈希表详解

3、理解哈希表