数据结构，算法与应用（2）

第5章 堆栈
堆栈是一个后进先出(last-in-first-out, LIFO)的数据结构。
1. 数组实现的堆栈
源代码如下：

#include <iostream>
using  namespace std;
template< class T>
class Stack{
     public:
        Stack( int MaxStackSize= 10);
        ~Stack(){
            delete [] stack;
        }
         bool IsEmpty() const{
             return top==- 1;
        }
         bool IsFull() const{
             return top==MaxTop;
        }
        T Top() const;
        Stack<T>& Add( const T& x);
        Stack<T>& Delete(T & x);
     private:
         int top;
         int MaxTop;
        T* stack;
};
template< class T>
Stack<T>::Stack( int MaxStackSize)
{
    MaxTop=MaxStackSize- 1;
    stack= new T[MaxStackSize];
    top=- 1;
}
template< class T>
T Stack<T>::Top() const
{
     if(IsEmpty())
         throw  " Out of Bounds ";
     return stack[top];
}
template< class T>
Stack<T>& Stack<T>::Add( const T& x)
{
     if(IsFull())
         throw  " Not enough Memorry ";
    stack[++top]=x;
cout<< " Success "<<endl;
     return * this;
}
template< class T>
Stack<T>& Stack<T>::Delete(T & x)
{
     if(IsEmpty())
         throw  " Out of Bounds ";
    x=stack[top--];
     return * this;
}
int main( void)                                       
{
     int x;
    Stack< int> S( 3);
     try {
        S.Add( 1).Add( 2).Add( 3).Add( 4);
    }
     catch (...) {
        cout <<  " Could not complete additions " << endl;
    }
    cout <<  " Stack should be 123 " << endl;
    cout <<  " Stack top is  " << S.Top() << endl;
     try {
        S.Delete(x);
        cout <<  " Deleted  " << x << endl;
        S.Delete(x);
        cout <<  " Deleted  " << x << endl;
        S.Delete(x);
        cout <<  " Deleted  " << x << endl;
        S.Delete(x);
        cout <<  " Deleted  " << x << endl;
    }
     catch (...) {
        cout <<  " Last delete failed  " << endl;
    }
}
                                                      

2.链表实现的堆栈
源代码如下：

#include <iostream>
using  namespace std;
template< class T>
class LinkedStack;
template< class T>
class Node{
    friend  class LinkedStack<T>;
     private:
    T data;
    Node<T>* link;
};
template< class T>
class LinkedStack{
     public:
        LinkedStack(){
            top= 0;
        }
        ~LinkedStack();
         bool IsEmpty() const{
             return top== 0;
        }
         bool IsFull() const;
        T Top() const;
        LinkedStack<T>& Add( const T& x);
        LinkedStack<T>& Delete(T& x);
     private:
        Node<T>*top;
};
template< class T>
LinkedStack<T>::~LinkedStack()
{
    Node<T>*next;
     while(top){
        next=top->link;
        delete top;
        top=next;
    }
}
template< class T>
bool LinkedStack<T>::IsFull() const
{
     try{
        Node<T> *p= new Node<T>;
        delete p;
         return  false;
    }
     catch(...){
         return  true;
    }
}
template< class T>
T LinkedStack<T>::Top() const
{
     if(IsEmpty())
         throw  " OutofBounds ";
     return top->data;
}
    template< class T>
LinkedStack<T>& LinkedStack<T>::Add( const T& x)
{
    Node<T> *p= new Node<T>;
    p->data=x;
    p->link=top;
    top=p;
     return * this;
}
    template< class T>
LinkedStack<T>& LinkedStack<T>::Delete(T& x)
{
     if(IsEmpty())
         throw  " Out of Bounds() ";
    x=top->data;
    Node<T> *p;
    p=top->link;
    delete top;
    top=p;
     return * this;
}
int main( void)
{
     int x;
    LinkedStack< int> S;
     try {S.Add( 1).Add( 2).Add( 3).Add( 4);}
     catch (...) {
        cout <<  " Could not complete additions " << endl;
    }
    cout <<  " Stack should be 1234 " << endl;
    cout <<  " Stack top is  " << S.Top() << endl;
     try {
        S.Delete(x);
        cout <<  " Deleted  " << x << endl;
        S.Delete(x);
        cout <<  " Deleted  " << x << endl;
        S.Delete(x);
        cout <<  " Deleted  " << x << endl;
        S.Delete(x);
        cout <<  " Deleted  " << x << endl;
    }
     catch (...) {
        cout <<  " Last delete failed  " << endl;
    }
}

3. 堆栈使用
(1)括号匹配

#include <iostream>
#include <stack>
#include < string>
using  namespace std;
void PrintMatchedPairs( string expr){
    stack< int> s;
     string::iterator it;
     int i= 1;
     for(it=expr.begin();it!=expr.end();++it,++i){
         if(*it== ' ( ')
            s.push(i);
         else  if(*it== ' ) ')
        {
             if(s.empty()){
                cout<< " No match for left parentthesis at  "<<i<<endl;

            }
             else{
                 int t=s.top();
                cout<<t<< "   "<<i<<endl;
                s.pop();
            }
        }
    }
     while(!s.empty()) {
         int t=s.top();
        cout<< " No match for left parentthesis at  "<<t<<endl;
        s.pop();
    }
}
int main( void)                                          
{
     const  int MaxLength= 200;
     char expr[MaxLength];
    cout <<  " Type an expression of length at most  "
        << MaxLength << endl;
    cin.getline(expr, MaxLength);
    cout << " The pairs of matching parentheses in "
        << endl;
    cout<<expr<<endl;
    cout << " are " << endl;
     string expr2(expr);
    PrintMatchedPairs(expr2);
}

（2）汉诺塔

#include <iostream>
#include <stack>
using  namespace std;
void TowersofHanoi( int n, int x, int y, int z){
     if(n> 0){
        TowersofHanoi(n- 1,x,z,y);
        cout<< " move top disk from tower  "<<x<< "  to top of tower  "<<y<<endl;
        TowersofHanoi(n- 1,z,y,x);
    }
}
int main(){
 cout <<  " Moves for a three disk problem are " << endl;
  TowersofHanoi( 3, 1, 2, 3);

}

网上给出的一个很不错的非递归方式的汉诺塔实现，具体见这，下面是代码：

#include <iostream>
using  namespace std; 

// 圆盘的个数最多为64 
const  int MAX =  64; 

// 用来表示每根柱子的信息
struct st{
     int s[MAX];  // 柱子上的圆盘存储情况
     int top;  // 栈顶，用来最上面的圆盘
     char name;  // 柱子的名字，可以是A，B，C中的一个
     int Top() // 取栈顶元素
    {
         return s[top];
    }
     int Pop() // 出栈
    {
         return s[top--];
    }
     void Push( int x) // 入栈
    {
        s[++top] = x;
    }
} ; 

long Pow( int x,  int y);  // 计算x^y
void Creat(st ta[],  int n);  // 给结构数组设置初值
void Hannuota(st ta[],  long max);  // 移动汉诺塔的主要函数 

int main( void)
{
     int n;
    cin >> n;  // 输入圆盘的个数
    st ta[ 3];  // 三根柱子的信息用结构数组存储
    Creat(ta, n);  // 给结构数组设置初值 

     long max = Pow( 2, n) -  1; // 动的次数应等于2^n - 1
    Hannuota(ta, max); // 移动汉诺塔的主要函数 

     return  0;
} 

void Creat(st ta[],  int n)
{
    ta[ 0].name =  ' A ';
    ta[ 0].top = n- 1;
     // 把所有的圆盘按从大到小的顺序放在柱子A上
     for ( int i= 0; i<n; i++)
        ta[ 0].s[i] = n - i;
     // 柱子B，C上开始没有没有圆盘
    ta[ 1].top = ta[ 2].top =  0;
     for ( int i= 0; i<n; i++)
        ta[ 1].s[i] = ta[ 2].s[i] =  0;
     // 若n为偶数，按顺时针方向依次摆放 A B C
     if (n% 2 ==  0)
    {
        ta[ 1].name =  ' B ';
        ta[ 2].name =  ' C ';
    }
     else   // 若n为奇数，按顺时针方向依次摆放 A C B
    {
        ta[ 1].name =  ' C ';
        ta[ 2].name =  ' B ';
    }
} 

long Pow( int x,  int y)
{
     long sum =  1;
     for ( int i= 0; i<y; i++)
        sum *= x; 

     return sum;
} 

void Hannuota(st ta[],  long max)
{
     int k =  0;  // 累计移动的次数
     int i =  0;
     int ch;
     while (k < max)
    {
         // 按顺时针方向把圆盘1从现在的柱子移动到下一根柱子
        ch = ta[i% 3].Pop();
        ta[(i+ 1)% 3].Push(ch);
        cout << ++k <<  " :  " <<
             " Move disk  " << ch <<  "  from  " << ta[i% 3].name <<
             "  to  " << ta[(i+ 1)% 3].name << endl;
        i++;
         // 把另外两根柱子上可以移动的圆盘移动到新的柱子上
         if (k < max)
        {     

             // 把非空柱子上的圆盘移动到空柱子上，当两根柱子都为空时，移动较小的圆盘
             if (ta[(i+ 1)% 3].Top() ==  0 ||
                    ta[(i- 1)% 3].Top() >  0 &&
                    ta[(i+ 1)% 3].Top() > ta[(i- 1)% 3].Top())
            {
                ch =  ta[(i- 1)% 3].Pop();
                ta[(i+ 1)% 3].Push(ch);
                cout << ++k <<  " :  " <<  " Move disk  "
                    << ch <<  "  from  " << ta[(i- 1)% 3].name
                    <<  "  to  " << ta[(i+ 1)% 3].name << endl;
            }
             else
            {
                ch =  ta[(i+ 1)% 3].Pop();
                ta[(i- 1)% 3].Push(ch);
                cout << ++k <<  " :  " <<  " Move disk  "
                    << ch <<  "  from  " << ta[(i+ 1)% 3].name
                    <<  "  to  " << ta[(i- 1)% 3].name << endl;
            }
        }
    }
} 

本人使用STL中的stack对上面的代码进行了一下修改：

class Tower{
     public:
        stack< int> st;
         char name;
};
int Pow( int x, int y){
     int sum= 1;
     for( int i= 0;i<y;i++)
        sum*=x;
     return sum;
}
void Hanoi( int N){
    Tower ta[ 3];
    ta[ 0].name= ' A ';
     for( int i= 0;i<N;i++)
        ta[ 0].st.push(N-i);
     if(N% 2== 0){
        ta[ 1].name= ' B ';
        ta[ 2].name= ' C ';
    }
     else{
        ta[ 1].name= ' C ';
        ta[ 2].name= ' B ';
    }
     int k= 0;
     int i= 0;
     int ch;
     int max=Pow( 2,N)- 1;
     while(k<max){
        ch=ta[i% 3].st.top();
        ta[i% 3].st.pop();
        ta[(i+ 1)% 3].st.push(ch);
        cout<<++k<< " : Move disk  "<<ch<< "  from  "<<ta[i% 3].name<< "  to  "<<ta[(i+ 1)% 3].name<<endl;
        i++;
         if(k<max){
             if(ta[(i+ 1)% 3].st.empty()||!ta[(i- 1)% 3].st.empty()&&ta[(i+ 1)% 3].st.top()>ta[(i- 1)% 3].st.top()){
                ch=ta[(i- 1)% 3].st.top();
                ta[(i- 1)% 3].st.pop();
                ta[(i+ 1)% 3].st.push(ch);
                cout<<++k<< " : Move disk  "<<ch<< "  from  "<<ta[(i- 1)% 3].name<< "  to  "<<ta[(i+ 1)% 3].name<<endl;
            }
             else{
                ch=ta[(i+ 1)% 3].st.top();
                ta[(i+ 1)% 3].st.pop();
                ta[(i- 1)% 3].st.push(ch);
                cout<<++k<< " : Move disk  "<<ch<< "  from  "<<ta[(i+ 1)% 3].name<< "  to  "<<ta[(i- 1)% 3].name<<endl;
            }
        }
    }
}

下图是对两种方法（递归和迭代）的比较：

 

上图给出的是4个盘的情况，对比可以发现，两种方法移动盘的步骤是一样的。  

 

（3）火车车厢重排

// using stack
#include <iostream>
#include <vector>
#include <stack>
using  namespace std;
bool Hold( int c, int &minH, int& minS,vector<stack< int> >& H, int k, int n){
     int BestTrack= 0,BestTop=n+ 1,x;
     for( int i= 1;i<=k;i++){
         if(!H[i].empty()){
            x=H[i].top();
             if(c<x&&x<BestTop){
                BestTop=x;
                BestTrack=i;
            }
        }
         else{
             if(!BestTrack)
                BestTrack=i;
        }
    }
     if(!BestTrack)
         return  false;
    H[BestTrack].push(c);
    cout<< " Move car  "<<c<< "  from input to holding track  "<<BestTrack<<endl;
     if(c<minH) {
        minH=c;
        minS=BestTrack;
    }
     return  true;
}
void Output( int& minH, int& minS,vector<stack< int> >& H, int k, int n){
     int c;
    c=H[minS].top();
    H[minS].pop();
    cout<< " Move car  "<<minH<< "  from holding track  "<<minS<< "  to output "<<endl;
    minH=n+ 2;
     for( int i= 1;i<=k;i++)
    {
         if(!H[i].empty()&&(c=H[i].top())<minH){
            minH=c;
            minS=i;
        }
    }
}
bool Railroad( int p[], int n, int k){
    vector<stack< int> > H(k+ 1);
     int NowOut= 1;
     int minH=n+ 1;
     int minS;
     for( int i= 1;i<=n;i++){
         if(p[i]==NowOut){
            cout<< " Move car  "<<p[i]<< "  from input to output "<<endl;
            NowOut++;
             while(minH==NowOut){
                Output(minH,minS,H,k,n);
                NowOut++;
            }
        }
         else{
             if(!Hold(p[i],minH,minS,H,k,n))
                 return  false;
        }

    }
     return  true;
}
int main(){
     int p[ 10] = { 0,  3,  6,  9,  2,  4,  7,  1,  8,  5};
    cout <<  " Input permutation is 0369247185 " << endl;
    Railroad(p, 9, 3);
}

（4）开关盒布线

#include <iostream>
#include <stack>
using  namespace std;
bool CheckBox( int net[], int n){
    stack< int> s;
     for( int i= 0;i<n;i++){
         if(s.empty()){
            s.push(i);
        }
         else{
             if(net[i]==net[s.top()]){
                cout<< " Wiring from  "<<(i+ 1)<< "  to  "<<(s.top()+ 1)<<endl;
                s.pop();
            }
             else
                s.push(i);
        }
    }
     if(s.empty()) {
        cout<< " Switch box is routbale "<<endl;
         return  true;
    }
     else {
        cout<< " Switch box is not routbale ";
         return  false;
    }
}
int main(){
     int net[]={ 1, 2, 2, 1, 3, 3, 4, 4};
     int n= sizeof(net)/ sizeof(net[ 0]);
    CheckBox(net,n);
}

（5）离线等价类

#include <iostream>
#include <list>
#include <stack>
#include <vector>
using  namespace std;
int main(){
     int n,r;
    cout<< " Enter number of elements "<<endl;
    cin>>n;
     if(n< 2){
        cerr<< " Too few elements "<<endl;
         return  1;
    }
    cout<< " Enter number of relations "<<endl;
    cin>>r;
     if(r< 1){
        cerr<< " Too few relations "<<endl;
         return  1;
    }
    vector<list< int> > chain(n+ 1);
     for( int i= 1;i<=r;i++)
    {
        cout<< " Enter next relation/pair "<<endl;
         int a,b;
        cin>>a>>b;
        chain[a].push_front(b);
        chain[b].push_front(a);
    }
    stack< int> s;
    vector< bool>  out(n+ 1);
     for( int i= 1;i<=n;i++)
         out[i]= false;
     for( int i= 1;i<=n;i++){
         if(! out[i]){
            cout<< " Next class is: "<<i<< '   ';
             out[i]= true;
            s.push(i);
            list< int>::const_iterator it;
             while(!s.empty()){
                 int j=s.top();
                s.pop();
                 for(it=chain[j].begin();it!=chain[j].end();++it)
                     if(! out[*it]){
                        cout<<*it<< '   ';
                         out[*it]= true;
                        s.push(*it);
                    }
            }
            cout<<endl;
        }
    }
    
}

（6）迷宫老鼠

#include <iostream>
#include <fstream>
#include <stack>
#include <cstdio>
using  namespace std;
struct Position{
         int x;
         int y;
};
Position  operator+(Position& a,Position& b){
    Position p;
    p.x=a.x+b.x;
    p.y=a.y+b.y;
     return p;
}

int **maze,m;
bool **flag;
stack<Position> path;
const  char * const red =  " \033[0;40;31m ";
const  char * const normal =  " \033[0m ";

template < class T>
void make2darray(T ** &maze, int w, int h){
    maze= new T*[w];
    T *mem= new T[w*h];
     for( int i= 0;i<w;i++)
        maze[i]=mem+i*h;
}

template < class T>
void free2darray(T** maze){
     if(maze){
         if(*maze)
            delete[] *maze;
        delete[] maze;
    }
}
bool InputMaze( const  char *file)
{ //  Input the maze.
    ifstream inf(file);
    inf >> m;
    cout <<  "  maze size:  "<<m<< endl;
    make2darray(maze, m, m);
     for ( int i= 0; i<m; i++)
         for ( int j= 0; j<m; j++) 
            inf >> maze[i][j];
    cout <<  " the maze: " << endl;
     for ( int i= 0; i<m; i++) {
         for ( int j= 0; j<m; j++) 
            cout<< maze[i][j]<< "   ";
        cout<<endl;
    }
    cout<<endl;
    make2darray(flag, m, m);
     for ( int i= 0; i<m; i++) 
         for ( int j= 0; j<m; j++) 
            flag[i][j]= false;

     return  true;
}                                                        
void OutputPath()                                         
{ //  Output path to exit.
    cout <<  " The path is " << endl;
    Position here;
     while (!path.empty()) {
        here=path.top();
        path.pop();
        cout << here.x <<  '   ' << here.y << endl;
        flag[here.x][here.y]= true;
    }
    cout<< " Another: "<<endl;
     for ( int i= 0; i<m; i++) {
         for ( int j= 0; j<m; j++) 
        {
             if(flag[i][j])
                printf( " %s%d%s  ",red,maze[i][j],normal);
             else
                printf( " %d  ",maze[i][j]);
        }
        printf( " \n ");
    }
    printf( " \n ");
    
}
bool FindPath(){
    Position here={ 0, 0};
    
    Position offset[ 4]={{ 0, 1},{ 1, 0},{ 0,- 1},{- 1, 0}};
    maze[ 0][ 0]= 1;
     int i= 0;
     while(here.x!=m- 1||here.y!=m- 1){
        Position location;
         int lx,ly;
         while(i< 4){
            location=here+offset[i];
            lx=location.x;
            ly=location.y;
             if(!(lx< 0||ly< 0||lx>m- 1||ly>m- 1)){
                 if(maze[lx][ly]== 0)
                     break;
            }
            i++;
        }
         if(i< 4){
            path.push(here);
            here=location;
            maze[lx][ly]= 1;
            i= 0;
        }
         else{
             if(path.empty())
                 return  false;
            Position next;
            next=path.top();
            path.pop();
             if(next.x==here.x)
                i= 2+next.y-here.y;
             else
                i= 3+next.x-here.x;
            here=next;
        }
    }
    path.push(here);
     return  true;
}
int main(){
    InputMaze( " maze.dat ");                       
     if (FindPath()) OutputPath();
     else cout <<  " No path " << endl;
    free2darray(maze);
    free2darray(flag);
}

迷宫数据：

10 
0 1 1 1 1 1 0 0 0 0 
0 0 0 0 0 1 0 1 0 0 
0 0 0 1 0 1 0 0 0 0 
0 1 0 1 0 1 0 1 1 0 
0 1 0 1 0 1 0 1 0 0 
0 1 1 1 0 1 0 1 0 1 
0 1 0 0 0 1 0 1 0 1 
0 1 0 1 1 1 0 1 0 0 
1 0 0 0 0 0 0 1 0 0 
0 0 0 0 1 1 1 1 0 0 

程序输出如下： 

第6章 队列
队列是一个先进先出( first-in-first-out, FIFO)的线性表
1. 公式化实现队列
实现代码：

#include <iostream>
using  namespace std;
template < class T>
class Queue{
     public:
        Queue( int Size= 10);
        ~Queue(){
            delete [] queue;
        }
         bool IsEmpty() const{
             return front==rear;
        }
         bool IsFull() const{
             return ((rear+ 1)%MaxSize==front)? true: false;
        }
        T First() const;
        T Last() const;
        Queue<T>& Add( const T& x);
        Queue<T>& Delete(T& x);
     private:
         int front;
         int rear;
         int MaxSize;
        T *queue;
};
template < class T>
Queue<T>::Queue( int size)
{
    MaxSize=size;
    queue= new T[size];
    front=rear= 0;
}
template < class T>
T Queue<T>::First() const
{
     if(IsEmpty())
         throw  " Out of Bounds ";
     return queue[(front+ 1)%MaxSize];

}
template < class T>
T Queue<T>::Last() const
{
     if(IsEmpty())
         throw  " Out of Bounds ";
     return queue[rear];

}
template < class T>
Queue<T>& Queue<T>::Add( const T& x)
{
     if(IsFull())
         throw  " No memorry ";
    rear=(rear+ 1)%MaxSize;
    queue[rear]=x;
     return * this;
}
template < class T>
Queue<T>& Queue<T>::Delete(T& x)
{
     if(IsEmpty())
         throw  " Out of Bounds ";
    front=(front+ 1)%MaxSize;
    x=queue[front];
     return * this;
}
int main( void)
{
   Queue< int> Q( 3);
    int x;
    try {Q.Add( 1).Add( 2).Add( 3).Add( 4);
        cout <<  " No queue add failed " << endl;}
    catch (...)
      {cout <<  " A queue add failed " << endl;}
   cout <<  " Queue is now 123 " << endl;
   Q.Delete(x);
   cout <<  " Deleted  " << x << endl;
   cout << Q.First() <<  "  is at front " << endl;
   cout << Q.Last() <<  "  is at end " << endl;
    try {
      Q.Delete(x);
      cout <<  " Deleted  " << x << endl;
      Q.Delete(x);
      cout <<  " Deleted  " << x << endl;
      Q.Delete(x);
      cout <<  " Deleted  " << x << endl;
      cout <<  " No queue delete failed  " << endl;
      }
    catch (...)
      {cout <<  " A delete has failed " << endl;}
}
                                                           
                                                           

2. 链表描述
实现代码：

#include <iostream>
using  namespace std;
template < class T>
class LinkedQueue;
template < class T>
class Node{
    friend  class LinkedQueue<T>;
     private:
    T data;
    Node<T> *link;
};
template < class T>
class LinkedQueue{
     public:
        LinkedQueue(){
            front=rear= 0;
        }
        ~LinkedQueue();
         bool IsEmpty() const{
             return (front)? false: true;
        }
         bool IsFull() const;
        T First() const;
        T Last() const;
        LinkedQueue<T>& Add( const T& x);
        LinkedQueue<T>& Delete(T& x);
     private:
        Node<T>*front;
        Node<T>*rear;
};
template < class T>
LinkedQueue<T>::~LinkedQueue()
{
    Node<T>*next;
     while(front){
        next=front->link;
        delete front;
        front=next;
    }
}
template < class T>
bool LinkedQueue<T>::IsFull() const
{
    Node<T>*p;
     try{
        p= new Node<T>;
        delete p;
         return  false;
    }
     catch(...){
         return  true;
    }
}
template < class T>
T LinkedQueue<T>::First() const
{
     if(IsEmpty())
         throw  " Out of Bounds ";
     return front->data;

}
template < class T>
T LinkedQueue<T>::Last() const
{
     if(IsEmpty())
         throw  " Out of Bounds ";
     return rear->data;

}
    template < class T>
LinkedQueue<T>& LinkedQueue<T>::Add( const T& x)
{
    Node<T>*p= new Node<T>;
    p->data=x;
    p->link= 0;
     if(front) rear->link=p;
     else
        front=p;
    rear=p;
     return * this;

}
    template < class T>
LinkedQueue<T>& LinkedQueue<T>::Delete(T& x)
{
     if(IsEmpty())
         throw  " Out of Bounds ";
    x=front->data;
    Node<T>*p;
    p=front->link;
    delete front;
    front=p;
     return * this;
}
int main( void)
{
   LinkedQueue< int> Q;
    int x;
    try {Q.Add( 1).Add( 2).Add( 3).Add( 4);
        cout <<  " No queue add failed " << endl;}
    catch (...)
      {cout <<  " A queue add failed " << endl;}
   cout <<  " Queue is now 1234 " << endl;
   Q.Delete(x);
   cout <<  " Deleted  " << x << endl;
   cout << Q.First() <<  "  is at front " << endl;
   cout << Q.Last() <<  "  is at end " << endl;
    try {
      Q.Delete(x);
      cout <<  " Deleted  " << x << endl;
      Q.Delete(x);
      cout <<  " Deleted  " << x << endl;
      Q.Delete(x);
      cout <<  " Deleted  " << x << endl;
      cout <<  " No queue delete failed  " << endl;
      }
    catch (...)
      {cout <<  " A delete has failed " << endl;}
}
                                                                    

3. 队列的应用
（1）火车重排

// using queue
#include <iostream>
#include <vector>
#include <queue>
using  namespace std;
bool Hold( int c, int &minH, int& minQ,vector<queue< int> >& H, int k){
     int BestTrack= 0,BestLast= 0,x;
     for( int i= 1;i<=k;i++){
         if(!H[i].empty()){
            x=H[i].back();
             if(c>x&&x>BestLast){
                BestLast=x;
                BestTrack=i;
            }
        }
         else{
             if(!BestTrack)
                BestTrack=i;
        }
    }
     if(!BestTrack)
         return  false;
    H[BestTrack].push(c);
    cout<< " Move car  "<<c<< "  from input to holding track  "<<BestTrack<<endl;
     if(c<minH) {
        minH=c;
        minQ=BestTrack;
    }
     return  true;
}
void Output( int& minH, int& minQ,vector<queue< int> >& H, int k, int n){
     int c;
    c=H[minQ].front();
    H[minQ].pop();
    cout<< " Move car  "<<minH<< "  from holding track  "<<minQ<< "  to output "<<endl;
    minH=n+ 2;
     for( int i= 1;i<=k;i++)
    {
         if(!H[i].empty()&&(c=H[i].front())<minH){
            minH=c;
            minQ=i;
        }
    }
}
bool Railroad( int p[], int n, int k){
    vector<queue< int> > H(k);
    k--;
     int NowOut= 1;
     int minH=n+ 1;
     int minQ;
     for( int i= 1;i<=n;i++){
         if(p[i]==NowOut){
            cout<< " Move car  "<<p[i]<< "  from input to output "<<endl;
            NowOut++;
             while(minH==NowOut){
                Output(minH,minQ,H,k,n);
                NowOut++;
            }
        }
         else{
             if(!Hold(p[i],minH,minQ,H,k))
                 return  false;
        }

    }
     return  true;
}
int main(){
     int p[ 10] = { 0,  3,  6,  9,  2,  4,  7,  1,  8,  5};
    cout <<  " Input permutation is 0369247185 " << endl;
    Railroad(p, 9, 3);
}

不使用队列的实现：

// with LIFO tracks
// no explicted queue used
#include <iostream>
#include <vector>
using  namespace std;
bool Hold( int c,vector< int>& last,vector< int>& track, int k){
     int BestTrack= 0,BestLast= 0;
     for( int i= 1;i<=k;i++){
         if(last[i]){
             if(c>last[i]&&last[i]>BestLast){
                BestLast=last[i];
                BestTrack=i;
            }

        }
         else{
             if(!BestTrack)
                BestTrack=i;
        }
    }
     if(!BestTrack)
         return  false;
    track[c]=BestTrack;
    last[BestTrack]=c;
    cout<< " Move car  "<<c<< "  from input to holding track  "<<BestTrack<<endl;
     return  true;
}
void Output( int NowOut, int Track, int& Last){
    cout<< " Move car  "<<NowOut<< "  from holding track  "<<Track<< "  to output "<<endl;
     if(NowOut==Last)
        Last= 0;
}
bool Railroad( int p[], int n, int k){
    vector< int> last(k+ 1);
    vector< int> track(n+ 1);
     for( int i= 1;i<=k;i++)
        last[i]= 0;
     for( int i= 1;i<=n;i++)
        track[i]= 0;
    k--;
     int NowOut= 1;
     for( int i= 1;i<=n;i++){
         if(p[i]==NowOut){
            cout<< " Move car  "<<p[i]<< "  from input to output "<<endl;
            NowOut++;
             while(NowOut<=n&&track[NowOut]){
                Output(NowOut,track[NowOut],last[NowOut]);
                NowOut++;
            }
        }
         else{
             if(!Hold(p[i],last,track,k))
                 return  false;
        }
    }
     return  true;
}
int main(){
     int p[ 10] = { 0,  3,  6,  9,  2,  4,  7,  1,  8,  5};
    cout <<  " Input permutation is 0369247185 " << endl;
    Railroad(p, 9, 3);
}

（2）电路布线

#include <iostream>
#include <fstream>
#include <queue>
#include <cstdio>
using  namespace std;
struct Position{
         int x;
         int y;
};
Position  operator+( const Position& a, const Position& b){
    Position p;
    p.x=a.x+b.x;
    p.y=a.y+b.y;
     return p;
}
bool  operator==( const Position& a, const Position& b){
     return (a.x==b.x&&a.y==b.y);
}
Position  operator-( const Position& a, int t){
    Position temp;
    temp.x=a.x-t;
    temp.y=a.y-t;
     return temp;
}
Position  operator+( const Position& a, int t){
    Position temp;
    temp.x=a.x+t;
    temp.y=a.y+t;
     return temp;
}
istream&  operator>>(istream&  is,Position& ps){
     is>>ps.x>>ps.y;
     return  is;
}
ostream&  operator<<(ostream& os, const Position& ps){
    os<< " ( "<<ps.x<< " , "<<ps.y<< " ) ";
     return os;
}
int **grid,m;
bool **flag;
const  char * const red =  " \033[0;40;31m ";
const  char * const normal =  " \033[0m ";

template < class T>
void make2darray(T ** &grid, int w, int h){
    grid= new T*[w];
    T *mem= new T[w*h];
     for( int i= 0;i<w;i++)
        grid[i]=mem+i*h;
}
template < class T>
void free2darray(T** maze){
     if(maze){
         if(*maze)
            delete[] *maze;
        delete[] maze;
    }
}

bool Inputgrid( const  char *file,Position& start,Position& finish)
{ //  Input the grid.
    ifstream inf(file);
    inf >> m;
    cout <<  "  grid size:  "<<m<< endl;
    make2darray(grid, m, m);
    inf>>start;
    inf>>finish;
    start=start- 1;
    finish=finish- 1;
    cout<< " start: "<<start<<endl;
    cout<< " finish: "<<finish<<endl;

     for ( int i= 0; i<m; i++)
         for ( int j= 0; j<m; j++) 
            inf >> grid[i][j];
    cout <<  " the grid: " << endl;
     for ( int i= 0; i<m; i++) {
         for ( int j= 0; j<m; j++) 
            cout<< grid[i][j]<< "   ";
        cout<<endl;
    }
    cout<<endl;
    make2darray(flag, m, m);
     for ( int i= 0; i<m; i++) 
         for ( int j= 0; j<m; j++) 
            flag[i][j]= false;
     return  true;
}                                                        
void OutputPath(vector<Position>& path)                                         
{ //  Output path to exit.
    cout <<  " The path is " << endl;
    vector<Position>::const_iterator it;
     for(it=path.begin();it!=path.end();++it){
        cout<<*it<<endl;
        flag[it->x][it->y]= true;

    }
    cout<< " Another: "<<endl;
     for ( int i= 0; i<m; i++) {
         for ( int j= 0; j<m; j++) 
        {
             if(flag[i][j])
                printf( " %s%d%s  ",red,grid[i][j],normal);
             else
                printf( " %d  ",grid[i][j]);
        }
        printf( " \n ");
    }
    printf( " \n ");
    
}
bool FindPath( const Position& start, const Position& finish,vector<Position>& path){
   //   if((start.x==finish.x)&&(start.y==finish.y)){
     if((start==finish)){
         return  true;
    }
    Position here=start;
    Position nbr;
    
     const  int NumOfNbrs= 4;
    Position offset[]={{ 0, 1},{ 1, 0},{ 0,- 1},{- 1, 0}};

    grid[start.x][start.y]= 2;
    queue<Position> Q;
     int lx,ly;
     do{
         for( int i= 0;i<NumOfNbrs;i++){
            nbr=here+offset[i];
            lx=nbr.x;
            ly=nbr.y;
             if(!(lx< 0||ly< 0||lx>m- 1||ly>m- 1)){
                 if(grid[nbr.x][nbr.y]== 0){
                    grid[nbr.x][nbr.y]=grid[here.x][here.y]+ 1;
                     if(nbr==finish)
                         break;
                    Q.push(nbr);
                }
            }
        }
         if(nbr==finish)
             break;
         if(Q.empty())
             return  false;
        here=Q.front();
        Q.pop();
    } while( 1);
     int PathLen=grid[finish.x][finish.y]- 2;
    path.resize(PathLen);
    here=finish;
     for( int j=PathLen- 1;j>= 0;j--){
        path[j]=here;
         for( int i= 0;i<NumOfNbrs;i++){
            nbr=here+offset[i];
            lx=nbr.x;
            ly=nbr.y;
             if(!(lx< 0||ly< 0||lx>m- 1||ly>m- 1)){
                 if(grid[nbr.x][nbr.y]==j+ 2)
                     break;
            }
        }
        here=nbr;
    }
     return  true;
}
int main(){
    Position start,finish;
    Inputgrid( " wire.dat ",start,finish);                       
    vector<Position> path;
     if (FindPath(start,finish,path))
        OutputPath(path);
     else
        cout <<  " No path " << endl;
    free2darray(grid);
    free2darray(flag);
}

布线路图：

 
7 
3 2 
4 6 
0 0 1 0 0 0 0 
0 0 1 1 0 0 0 
0 0 0 0 1 0 0 
0 0 0 1 1 0 0 
1 0 0 0 1 0 0 
1 1 1 0 0 0 0 
1 1 1 0 0 0 0 

程序输出如下： 

（3）识别图元

#include <iostream>
#include <fstream>
#include <queue>
#include <cstdio>
using  namespace std;
struct Position{
         int x;
         int y;
};
Position  operator+( const Position& a, const Position& b){
    Position p;
    p.x=a.x+b.x;
    p.y=a.y+b.y;
     return p;
}
int **pixel,m;
const  char *color[]={  " \033[0;40;31m ", " \033[0;40;32m ", " \033[0;40;33m ", " \033[0;40;34m ", " \033[0;40;35m ", " \033[0;40;36m "};
const  char * const normal =  " \033[0m ";

template < class T>
void make2darray(T ** &pixel, int w, int h){
    pixel= new T*[w];
    T *mem= new T[w*h];
     for( int i= 0;i<w;i++)
        pixel[i]=mem+i*h;
}
template < class T>
void free2darray(T** maze){
     if(maze){
         if(*maze)
            delete[] *maze;
        delete[] maze;
    }
}

void InputImage( const  char*file)
{ //  Input the pixel.
    ifstream inf(file);
    inf >> m;
    cout <<  "  pixel size:  "<<m<< endl;
    make2darray(pixel, m, m);

     for ( int i= 0; i<m; i++)
         for ( int j= 0; j<m; j++) 
            inf >> pixel[i][j];
    cout <<  " the pixel: " << endl;
     for ( int i= 0; i<m; i++) {
         for ( int j= 0; j<m; j++) 
            cout<< pixel[i][j];
        cout<<endl;
    }
    cout<<endl;
}                                                        
void OutputImage()                                         
{ //  Output path to exit.
    cout<< " Another: "<<endl;
     for ( int i= 0; i<m; i++) {
         for ( int j= 0; j<m; j++) 
        {
             if(pixel[i][j]> 1)
                printf( " %s%d%s  ",color[pixel[i][j]- 2],pixel[i][j],normal);
             else
                printf( " %d  ",pixel[i][j]);
        }
        printf( " \n ");
    }
    printf( " \n ");
}
void Label(){
     const  int NumOfNbrs= 4;
    Position offset[]={{ 0, 1},{ 1, 0},{ 0,- 1},{- 1, 0}};
    Position here,nbr;
    queue<Position> Q;
     int id= 1;
     for( int r= 0;r<m;r++){
         for( int c= 0;c<m;c++){
             if(pixel[r][c]== 1){
                pixel[r][c]=++id;
                here.x=r;
                here.y=c;
                 int lx,ly;
                 do{
                     for( int i= 0;i<NumOfNbrs;i++){
                        nbr=here+offset[i];
                        lx=nbr.x;
                        ly=nbr.y;
                         if(!(lx< 0||ly< 0||lx>m- 1||ly>m- 1)){
                             if(pixel[lx][ly]== 1){
                                pixel[lx][ly]=id;
                                Q.push(nbr);
                            }
                        }
                    }
                     if(Q.empty())
                         break;
                    here=Q.front();
                    Q.pop();
                } while( 1);
            }
        }
    }
}
int main(){
     const  char*file= " image.dat ";
    InputImage(file);
    cout <<  " The input image is " << endl;
    OutputImage();
    Label();
    cout <<  " The labeled image is " << endl;
    OutputImage();
}

图元数据： 

7 
0 0 1 0 0 0 0 
0 0 1 1 0 0 0 
0 0 0 0 1 0 0 
0 0 0 1 1 0 0 
1 0 0 0 1 0 0 
1 1 1 0 0 0 0 
1 1 1 0 0 0 0

程序输出： 

第7章 跳表和散列
1. 线性表来实现字典，该线性表按关键字从左到右依次增大。

#include <iostream>
using  namespace std;
template < class E,  class K>  class SortedChain;                      

template < class E,  class K>
class SortedChainNode {
    friend  class SortedChain<E,K>;
     private:
    E data;
    K key;
    SortedChainNode<E,K> *link;
};
template< class E, class K>
class SortedChain{
     public:
        SortedChain(){
            first= 0;
        }
        ~SortedChain();
         bool IsEmpty() const{
             return first== 0;
        }
         int Length() const;
         bool Search( const K& k,E& e) const;
        SortedChain<E,K>& Delete( const K& k,E& e);
        SortedChain<E,K>& Insert( const K& k, const E& e);
        SortedChain<E,K>& DistinctInsert( const K&k, const E& e);
         void Output(ostream&  out)  const;
     private:
        SortedChainNode<E,K> *first;
};
template< class E, class K>
SortedChain<E,K>::~SortedChain()
{
    SortedChainNode<E,K>* next;
     while(first){
        next=first->link;
        delete first;
        first=next;
    }
}
template< class E, class K>
int SortedChain<E,K>::Length() const
{
    SortedChainNode<E,K>* p=first;
     int len= 0;
     while(p){
        p=p->link;
        len++;
    }
     return len;

}
template< class E, class K>
bool SortedChain<E,K>::Search( const K& k,E& e) const
{
    SortedChainNode<E,K> *p=first;
     while(p&&p->key<k)
        p=p->link;
     if(p&&p->key==k) {
        e=p->data;
         return  true;
    }
     return  false;
}
template< class E, class K>
SortedChain<E,K>& SortedChain<E,K>::Delete( const K& k,E& e)
{
    SortedChainNode<E,K>*p=first,*tp= 0;
     while(p&&p->key<k){
        tp=p;
        p=p->link;
    }
     if(p&&p->key==k){
        e=p->data;
         if(tp)
            tp->link=p->link;
         else
            first=p->link;
        delete p;
         return * this;
    }
     throw  " Bad Input ";
     return * this;

}
template< class E, class K>
SortedChain<E,K>& SortedChain<E,K>::Insert( const K& k, const E& e)
{
    SortedChainNode<E,K>*p=first,*tp= 0;
     while(p&&p->key<k){
        tp=p;
        p=p->link;
    }
    SortedChainNode<E,K> *q= new SortedChainNode<E,K>;
    q->key=k;
    q->data=e;
    q->link=p;
     if(tp)
        tp->link=q;
     else
        first=q;
     return * this;
}
template< class E, class K>
SortedChain<E,K>& SortedChain<E,K>::DistinctInsert( const K& k, const E& e)
{
    SortedChainNode<E,K>*p=first,*tp= 0;
     while(p&&p->key<k){
        tp=p;
        p=p->link;
    }
     if(p&&p->data==e)
         throw  " Bad Input ";
    SortedChainNode<E,K> *q= new SortedChainNode<E,K>;
    q->key=k;
    q->data=e;
    q->link=p;
     if(tp)
        tp->link=q;
     else
        first=q;
     return * this;
}
template< class E, class K>
void SortedChain<E,K>::Output(ostream&  out)  const
{
    SortedChainNode<E,K>*p;
    p=first;
     while(p){
         out<< " ( "<<p->key<< " , "<<p->data<< " )  ";
        p=p->link;
    }
}
template< class E, class K>
ostream&  operator<<(ostream&  out, const SortedChain<E,K>& x){
    x.Output( out);
     return  out;
}

int main( void)
{
    SortedChain< int,  int> Z;                                           
     int x;
    Z.Insert( 2, 2).Insert( 6, 6).Insert( 4, 4);
    cout <<  " The chain is  " << Z << endl;
    cout <<  " Its length is  " << Z.Length() << endl;
    Z.Delete( 2,x);
    cout <<  " Deleted  " << x << endl;
    cout << Z << endl;
    Z.Insert( 1, 1).Delete( 6,x);
    cout << Z << endl;
    Z.Insert( 8, 8).Insert( 9, 9).Search( 8,x);
    cout <<  " Found  " << x << endl;
    Z.Insert( 7, 7).Delete( 9,x);
    cout << Z << endl;
     try {Z.DistinctInsert( 7, 7);}
     catch (...)
    {cout <<  " Attempt to insert duplicate element " << endl;}
    cout << Z << endl;
    Z.DistinctInsert( 10, 10);
    cout << Z << endl;
}

2. 跳表描述
（1）理想情况

（2）插入删除

（3）级的分配

（4）复杂性

跳表的实现代码：

#if 1
#include <iostream>
#include <cmath>
#include <cstdlib>
using  namespace std;
template < class E, class K>
class SkipList;
template < class E, class K>
class SkipNode{
    friend  class SkipList<E,K>;
    SkipNode( int size){
        link= new SkipNode<E,K>*[size];
    }
    ~SkipNode(){
        delete[] link;
    }
     private:
    E data;
    K key;
    SkipNode<E,K>**link;
};
template< class E, class K>
class SkipList{
     public:
       SkipList(K large, int MaxE= 10000, float p= 0.5);
       ~SkipList();
        bool Search( const K& k,E& e) const;
       SkipList<E,K>& Insert( const K& k, const E& e);
       SkipList<E,K>& Delete( const K& k,E& e);
        void Output();
     private:
        int Level();
       SkipNode<E,K>* SaveSearch( const K& k);
        int MaxLevel;
        int Levels;
        int CutOff;
       K TailKey;
       SkipNode<E,K>* head;
       SkipNode<E,K>* tail;
       SkipNode<E,K>* *last;
};
template< class E, class K>
SkipList<E,K>::SkipList(K large, int MaxE, float p)
{
    CutOff=p*RAND_MAX;
    MaxLevel=ceil(log(MaxE* 1.0)/log( 1/p))- 1;
    TailKey=large;
    Levels= 0;
    
    head= new SkipNode<E,K>(MaxLevel+ 1);
    tail= new SkipNode<E,K>( 0);
    last= new SkipNode<E,K>* [MaxLevel+ 1];
    tail->key=large;
     for( int i= 0;i<=MaxLevel;i++)
        head->link[i]=tail;
}
template< class E, class K>
SkipList<E,K>::~SkipList()
{
    SkipNode<E,K> *next;
     while(head!=tail){
        next=head->link[ 0];
        delete head;
        head=next;
    }
    delete tail;
    delete [] last;
}
template< class E, class K>
bool SkipList<E,K>::Search( const K& k,E& e) const
{
     if(k>=TailKey)
         return  false;
    SkipNode<E,K> *p=head;
     for( int i=Levels;i>= 0;i--)
         while(p->link[i]->key<k)
            p=p->link[i];

    e=p->link[ 0]->data;
    K tmp=p->link[ 0]->key;
     return e==tmp;
}
template< class E, class K>
SkipList<E,K>& SkipList<E,K>::Insert( const K& k, const E& e)
{
     if(k>=TailKey)
         throw  " Bad Input ";
    SkipNode<E,K> *p=SaveSearch(k);
     if(p->data==e)
         throw  " Bad Input ";
     int lev=Level();
     if(lev>Levels){
        lev=++Levels;
        last[lev]=head;
    }
    SkipNode<E,K> *y= new SkipNode<E,K>(lev+ 1);
    y->data=e;
    y->key=k;
     for( int i= 0;i<=lev;i++){
        y->link[i]=last[i]->link[i];
        last[i]->link[i]=y;
    }
     return * this;
}
template< class E, class K>
SkipList<E,K>& SkipList<E,K>::Delete( const K& k,E& e)
{
     if(k>=TailKey)
         throw  " Bad Input ";
    SkipNode<E,K> *p=SaveSearch(k);
     if(p->data==e)
         throw  " Bad Input ";
     for( int i= 0;i<=Levels&&last[i]->link[i]==p;i++)
        last[i]->link[i]=p->link[i];
     while(Levels> 0&&head->link[Levels]==tail)
        Levels--;
    e=p->data;
    delete p;
     return * this;
}
template< class E, class K>
int SkipList<E,K>::Level()
{
     int lev= 0;
     while(rand()<=CutOff)
        lev++;
     return lev<=MaxLevel?lev:MaxLevel;
}
template< class E, class K>
SkipNode<E,K>* SkipList<E,K>::SaveSearch( const K& k)
{
    SkipNode<E,K> *p=head;
     for( int i=Levels;i>= 0;i--){
         while(p->link[i]->key<k)
            p=p->link[i];
        last[i]=p;
    }
     return p->link[ 0];
}
template< class E,  class K>
void SkipList<E,K>::Output()
{
    SkipNode<E,K> *y = head->link[ 0];
     for (; y != tail; y = y->link[ 0])
        cout << " ( "<<y->key<< " , "<< y->data << " )  ";
    cout << endl;
}


int main( void)
{
   SkipList< int,  long> S( 10001,  100,  0.5);
    int i, n =  20;
    int data;
    long key;
    for (i =  1; i <= n; i++) {
      data = i; 
      key =  2*i;
      S.Insert(key,data);
   }
   S.Output();
    for (i= 1; i <= n+ 1; i++) {
      data = n+i; 
      key =  2*i- 1;
       try {S.Insert(key,data);}
       catch (...)
       {cout <<  " Unable to insert duplicate ( " <<key<< " , "<<data<< " ) "<< endl;}
      }
   
   S.Output();
    for (i =  1; i <= n+ 1; i++) {
      key =  2*i- 1;
       try {S.Delete(key,data);
         cout <<  " Deleted ( " << key <<  " , " << data << " ) "<< endl;}
       catch (...)
         {cout <<  " Delete of  " << ( 2*i- 1) <<  "  failed " << endl;}
      }
   S.Output();
}
#endif

3. 散列表描述/哈希表
（1）线性开型寻址

#include <iostream>
using  namespace std;
template< class E, class K>
class HashTable{
     public:
        HashTable( int divisior= 11);
        ~HashTable(){
            delete[] ht;
            delete[] empty;
        }
         bool Search( const K& k,E& e) const;
        HashTable<E,K>& Insert( const E& e);
         void Output();
     private:
         int hSearch( const K& k) const;
         int D;
        E *ht;
         bool *empty;
};
template< class E, class K>
HashTable<E,K>::HashTable( int divisior)
{
    D=divisior;
    ht= new E[D];
    empty= new  bool[D];
     for( int i= 0;i<D;i++)
        empty[i]= true;
}
template< class E, class K>
bool HashTable<E,K>::Search( const K& k,E& e) const
{
     int b=hSearch(k);
     if(empty[b]||ht[b]!=k)
         return  false;
    e=ht[b];
     return  true;

}
template< class E, class K>
HashTable<E,K>& HashTable<E,K>::Insert( const E& e)
{
    K k=e;
     int b=hSearch(k);
     if(empty[b]){
        empty[b]= false;
        ht[b]=e;
         return * this;
    }
     if(ht[b]==k)
         throw  " Bad Input ";
     throw  " No mem ";
     return * this;
}
template< class E, class K>
void HashTable<E,K>::Output()
{
     for( int i= 0;i<D;i++){
         if(empty[i])
            cout<< " empty "<<endl;
         else
            cout<<ht[i]<<endl;
    }

}
template< class E, class K>
int HashTable<E,K>::hSearch( const K& k) const
{
     int i=k%D;
     int j=i;
     do{
         if(empty[j]||ht[j]==k)
             return j;
        j=(j+ 1)%D;
    }
     while(j!=i);
     return j;
}
int main( void)
{  
     int data;
     long key;
   HashTable< int,  long> h( 11);
   data=  80;
   h.Insert(data);
   data=  40;
   h.Insert(data);
   data=  65;
   h.Insert(data);
   h.Output();
   data=  58;
   h.Insert(data);
   data=  24;
   h.Insert(data);
   cout <<  '   ' << endl;
   h.Output();
   data=  2;
   h.Insert(data);
   data=  13;
   h.Insert(data);
   data=  46;
   h.Insert(data);
   data=  16;
   h.Insert(data);
   data=  7;
   h.Insert(data);
   data=  21;
   h.Insert(data);
   cout <<  '   ' << endl;
   h.Output();
   data= 99;
    try {h.Insert(data);}
    catch (...)
      {cout  <<  "  No memory for 99 " << endl;}
}                                                         

（2）链表散列

#include <iostream>
#include <map>
#include <vector>
#include < string>
#include <cstdlib>
using  namespace std;
template < class K, class E>
class ChainHashTable{
     public:
        ChainHashTable( int div= 11):D(div){
            tab.resize(div);
        }
         bool Search( const K& k,E& e) const{
            typename map<K,E>::iterator ite;
            ite=tab[k%D].find(k);
             if(ite==tab[k%D].end())
                 return  false;
            e=ite->second;
             return  true;
        }
        ChainHashTable& Insert( const K& k, const E& e){
            tab[k%D].insert(pair<K,E>(k,e));
             return * this;
        }
        ChainHashTable& Delete( const K& k){
            tab[k%D].erase(k);
             return * this;
        }
         void Output(ostream& os) const{
            typename map<K,E>::const_iterator ite;
             for( int i= 0;i<D;i++){
                os<< " tab[ "<<i<< " ]: ";
                 for(ite=tab[i].begin();ite!=tab[i].end();++ite){
                    os<< " < "<<ite->first<< " , "<<ite->second<< " >  ";
                }
                os<<endl;
            }
        }
     private:
         int D;
        vector<map<K,E> > tab;
};
template < class E, class K>
ostream&  operator<<(ostream& os, const ChainHashTable<E,K>& cht){
    cht.Output(os);
     return os;
}
const  string letters( " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ");
string rand_str( int n){
     string s(n, '   ');
     for( int i= 0;i<n;i++){
         int pos=rand()% 52;
        s[i]=letters[pos];
    }
     return s;
}
int main(){
    ChainHashTable< int, string> ht( 11);
     int N= 20;
     for( int i= 0;i<N;i++){
         int val=rand()% 100;
         string str=rand_str( 10);
        ht.Insert(val,str);
    }
    cout<< " ok "<<endl;
    cout<<ht<<endl;

}

实现代码采用了STL中的map: 

4. 散列与跳表的比较：

5.应用

 LzW压缩 

压缩代码的实现如下：下面的代码没有采用上面的等长位编码，而是采用的最显而易见的方式：  

map< string,unsigned> compress( string & in_str, string& str_code){
    map< string,unsigned> mp;
     int N=Alpha;
     int used=N;
     for( int i= 0;i<N;i++){
         string key( 1, ' a '+i);
        unsigned code=i;
        mp.insert(pair< string,unsigned>(key,code));
    }
    typename map< string,unsigned>::iterator ite;
    ostringstream  oss;
    size_t len=in_str.length();
     if(len< 2){
        ite=mp.find(in_str.substr( 0, 1));
        oss<<ite->second;
    }
     else{
         string pcode;
        pcode+=in_str[ 0];
         for( int i= 1;i<len;i++){
             char c=in_str[i];
             string key=pcode+c;
            ite=mp.find(key);
             if(ite!=mp.end()){
                pcode=key;
            }
             else{
                oss<<mp[pcode];
                mp.insert(pair< string,unsigned>(key,used++));
                pcode=c;
            }
        }
        oss<<mp[pcode];
    }
    str_code=oss.str();
     return mp;
}

  LZW解压缩  

解压缩代码：与压缩代码是对应的： 

map<unsigned, string> decomp( string& str_code, string& out_str){
    map<unsigned, string> mp;
     int N=Alpha;
    unsigned used=N;
     for( int i= 0;i<N;i++){
        unsigned key=i;
         string code( 1, ' a '+i);
        mp.insert(make_pair(key,code));
    }
    typename map<unsigned, string>::iterator ite;
    ostringstream  oss;
    size_t len=str_code.length();
     if(len< 2){
        oss<<mp[(unsigned)(str_code[ 0]- ' 0 ')];
    }
     else{
        unsigned pcode=(unsigned)(str_code[ 0]- ' 0 ');
        oss<<mp[pcode];
         for( int i= 1;i<len;i++){
             string prefix=mp[pcode];
             char surfix;
             string code;
            unsigned key=used++;
            unsigned ccode=(unsigned)(str_code[i]- ' 0 ');
            ite=mp.find(ccode);
             if(ite!=mp.end()){
                oss<<ite->second;
                surfix=(ite->second).at( 0);
                code=prefix+surfix;
//                 unsigned key=used++;
//                 mp.insert(make_pair(key,code));
            }
             else{
//                 string prefix=mp[pcode];
                surfix=prefix[ 0];
                code=prefix+surfix;
//                 unsigned key=used++;
                oss<<code;
            }
            mp.insert(make_pair(key,code));
            pcode=ccode;
        }
    }
    out_str=oss.str();

     return mp;
}

下面的代码是对上面压缩与解压缩的测试，包括测试压缩然后再解压缩得到的字符串与原字符串是否相等，压缩与解压所构造的字典是否一致，并给出了字典。 

#include <iostream>
#include <map>
#include < string>
#include <sstream>
#include <cstdlib>
using  namespace std;
const  string letters( " ab "); // cdefghijklmnopqrstuvwxyz");
const  int Alpha= 2;
template < class T>
void con_print(T& c){
    typename T::iterator ite;
     for(ite=c.begin();ite!=c.end();++ite){
        cout<<*ite<< '   ';
    }
    cout<<endl;
}
template < class K, class E>
void map_print(map<K,E>& mp){
    typename map<K,E>::iterator ite;
     for(ite=mp.begin();ite!=mp.end();++ite)
        cout<< " < "<<ite->first<< " , "<<ite->second<< " > "<< '   ';
    cout<<endl;
}
map< string,unsigned> compress( string & in_str, string& str_code){
    map< string,unsigned> mp;
     int N=Alpha;
     int used=N;
     for( int i= 0;i<N;i++){
         string key( 1, ' a '+i);
        unsigned code=i;
        mp.insert(pair< string,unsigned>(key,code));
    }
    typename map< string,unsigned>::iterator ite;
    ostringstream  oss;
    size_t len=in_str.length();
     if(len< 2){
        ite=mp.find(in_str.substr( 0, 1));
        oss<<ite->second;
    }
     else{
         string pcode;
        pcode+=in_str[ 0];
         for( int i= 1;i<len;i++){
             char c=in_str[i];
             string key=pcode+c;
            ite=mp.find(key);
             if(ite!=mp.end()){
                pcode=key;
            }
             else{
                oss<<mp[pcode];
                mp.insert(pair< string,unsigned>(key,used++));
                pcode=c;
            }
        }
        oss<<mp[pcode];
    }
    str_code=oss.str();
     return mp;
}
map<unsigned, string> decomp( string& str_code, string& out_str){
    map<unsigned, string> mp;
     int N=Alpha;
    unsigned used=N;
     for( int i= 0;i<N;i++){
        unsigned key=i;
         string code( 1, ' a '+i);
        mp.insert(make_pair(key,code));
    }
    typename map<unsigned, string>::iterator ite;
    ostringstream  oss;
    size_t len=str_code.length();
     if(len< 2){
        oss<<mp[(unsigned)(str_code[ 0]- ' 0 ')];
    }
     else{
        unsigned pcode=(unsigned)(str_code[ 0]- ' 0 ');
        oss<<mp[pcode];
         for( int i= 1;i<len;i++){
             string prefix=mp[pcode];
             char surfix;
             string code;
            unsigned key=used++;
            unsigned ccode=(unsigned)(str_code[i]- ' 0 ');
            ite=mp.find(ccode);
             if(ite!=mp.end()){
                oss<<ite->second;
                surfix=(ite->second).at( 0);
                code=prefix+surfix;
//                 unsigned key=used++;
//                 mp.insert(make_pair(key,code));
            }
             else{
//                 string prefix=mp[pcode];
                surfix=prefix[ 0];
                code=prefix+surfix;
//                 unsigned key=used++;
                oss<<code;
            }
            mp.insert(make_pair(key,code));
            pcode=ccode;
        }
    }
    out_str=oss.str();

     return mp;
}
bool map_equal(map< string,unsigned>& mp,map<unsigned, string>& mp2){
    typename map< string,unsigned>::iterator ite;
    typename map<unsigned, string>::iterator ite2;
     for(ite=mp.begin();ite!=mp.end();++ite){
        ite2=mp2.find(ite->second);
         if(ite->first!=ite2->second)
             return  false;
    }
     return  true;
}
int main1(){
     string in_str( " aaabbbbbbaabaaba ");
     string str_code;
    map< string,unsigned> mp=compress(in_str,str_code);
    cout<<in_str<< " : "<<str_code<<endl;
    map_print(mp);

     return  0;
}
int main2(){
     string str_code( " 0214537 ");
     string out_str;
    map<unsigned, string> mp=decomp(str_code,out_str);
    cout<<str_code<< " : "<<out_str<<endl;
    map_print(mp);
     return  0;
}
int main(){
     int N= 15;
     for( int i= 0;i< 50;i++){
         string in_str(N, '   ');
         for( int j= 0;j<N;j++)
            in_str[j]=letters[rand()% 2];
         string str_code;
        map< string,unsigned> mp=compress(in_str,str_code);
         string out_str;
        map<unsigned, string> mp2=decomp(str_code,out_str);

        cout<<in_str<< "   ";
        cout<<str_code<< "   ";
        cout<<out_str<< "   ";
         if(in_str==out_str)
            cout<< " OK  ";
         else
            cout<< " NO  ";
         if(map_equal(mp,mp2))
            cout<< " OK  ";
         else
            cout<< " NO  ";
        map_print(mp2);
    }

}

  下面是一个测试结果示例： 

每一个行中的两个OK表示字符串是否一致，字典是否一致。 最后的是字典。  

这儿存在的一个问题是：字符串不要太长，不然如果之巅长度超过10以后编码就乱了，因为编码之后的数字之间是没有空格进行分隔的。解决方法是可以换一种编码方式，可以采用大写字母。

上面的截图中也出现了字典长度超过10的情况，但是压缩和解压的结果仍然一致，原因是因为最后一个映射没有用到。