读书笔记之：数据结构，算法与应用（2）

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

View Code

#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.链表实现的堆栈
源代码如下：

View Code

#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)括号匹配

View Code

#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）汉诺塔

View Code

#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);

}

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

View Code

#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对上面的代码进行了一下修改：

View Code

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）火车车厢重排

View Code

// 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）开关盒布线

View Code

#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）离线等价类

View Code

#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）迷宫老鼠

View Code

#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. 公式化实现队列
实现代码：

View Code

#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. 链表描述
实现代码：

View Code

#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）火车重排

View Code

// 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);
}

不使用队列的实现：

View Code

// 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）电路布线

View Code

#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）识别图元

View Code

#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. 线性表来实现字典，该线性表按关键字从左到右依次增大。

View Code

#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）级的分配