算法导论第十章基本数据结构

10.1栈与队列

（1） 栈

概念定义：栈属于动态集合，采用先进后出策略（LIFO）。基本操作是压入（PUSH）和弹出（POP）。如果s.top=0，表示栈空，如果试图对空栈进行POP操作会发生下溢（underflow）。如果s.top>n,表示栈满，如果进行PUSH操作会发生上溢（overflow）。

基本代码：

//基本的栈操作
#include <iostream>
#include <time.h>
using namespace std;
const n=10;
struct stack
{
    int top;
    int Array[n];
}s;
//初始化一个空栈
int Init_Stack()
{
    s.top = 0;//top为0表示空栈
    return 1;
}
//判断栈是否为空
bool stack_empty(int Array[])
{
    if (s.top==0)
    {
        return true;
    }
    else
    {
        return false;
    }
}
//入栈
void stack_push(int Array[],int x)
{
    if (s.top==n)
    {
        cerr<<"overflow!"<<endl;
    } 
    else
    {
        s.top++;
        s.Array[s.top]=x;
        
    }
}
//出栈
int stack_pop(int Array[])
{
    if (stack_empty(s.Array))
    {
        cerr<<"underflow"<<endl;
        return -1;
    }
    else
    {
        s.top--;
        return s.Array[s.top+1];
    }    
}
void main()
{
    struct stack s;
    Init_Stack();
    int x=0;
    srand( (unsigned)time( NULL ) );
    for ( int i=0;i<n;i++)
    {
        x=rand()%100;
        stack_push(s.Array,x);
    }
    for (i=0;i<n;i++)
    {
        cout<<stack_pop(s.Array)<<endl;
    }

}

（2） 队列

概念定义：队列属于动态集合，采用先进先出策略（FIFO）。基本操作是出队（enqueue）和出队（dequeue）。如果head=tail，表示队列为空，如果试图对空队列进行enqueue操作会发生下溢（underflow）。如果head=tail+1,表示队列满，如果进行dequeue操作会发生上溢（overflow）。

基本代码：

//基本的队列操作
/*#include <iostream>
#include <time.h>
using namespace std;
const n=5;
struct Queue
{
    int head;
    int tail;
    int Array[n];
}Q;
void Init_Queue()
{
    Q.head=Q.tail=1;//表示队列为空栈
}
//判断栈是否为空
bool Queue_empty(int Array[])
{
    if (Q.head==Q.tail)
    {
        return true;
    }
    else
    {
        return false;
    }
}
void ENQueue(int Array[],int x)
{
    if (Q.head==Q.tail+1)
    {
        cerr<<"overflow!"<<endl;
    } 
    else
    {
        Q.Array[Q.tail]=x;
        if (Q.tail==n)
        {
            Q.tail=0;
        }
        else
        {
            Q.tail++;
        }
    }
}
int DEQueue(int Array[])
{
    int x=0;
    if (Queue_empty(Q.Array))
    {
       cerr<<"underflow"<<endl;
    } 
    else
    {
        x=Q.Array[Q.head];
        if (Q.head==n)
        {
            Q.head=0;
        } 
        else
        {
            Q.head++;
        }
    }
   return x;
}
void main()
{
    struct Queue Q;
    Init_Queue();
    int x=0;
    srand( (unsigned)time( NULL ) );
    for ( int i=0;i<n;i++)
    {
        x=rand()%100;
        ENQueue(Q.Array,x);
    }
    for (i=0;i<n;i++)
    {
        cout<<DEQueue(Q.Array)<<endl;
    } 
}

10.1-1 仿照图10-1，说明对一个存储在数组S[1..6]中的，初始为空的栈S，依次执行PUSH(S,4),PUSH(S,1),PUSH(S,3),POP(S),PUSH(S,8)以及POP(S)操作后的结果。

操作结果4,1

10.1-2 说明如何用一个数组A[1..n]来实现两个栈，使得两个栈中的元素总数不到n时，两者都不会发生上溢。注意PUSH和POP操作的时间应为O(1)

//一个数组实现两个栈
#include <iostream>
#include <time.h>
using namespace std;
const n=10;
struct stack
{
    int top1;
    int top2;
    int Array[n];
}s;
//初始化一个空栈
void Init_Stack()
{
    s.top1 = -1;//top1为0表示以左端端点为初始栈顶的栈（简称左栈）空栈
    s.top2=n;//top2为n-1表示以右端端点为初始栈顶的栈（简称右栈）空栈
}
//判断栈是否为空
bool stack_empty(int Array[],int flag)
{
    if (s.top1<-1&&flag==0)
    {
        return true;
    }
    if (s.top2>n&&flag==1)
    {
        return true;
    }
     return false;
}
//入栈
void stack_push(int Array[],int x,int flag)
{
       if (flag==0)
       {
           s.top1++;
           if (s.top1>=s.top2)
           {
               cerr<<"试图入左栈，发生上溢"<<endl;
           } 
           else
           {
               s.Array[s.top1]=x;
           }
       } 
       else
       {
           s.top2--;
           if (s.top1>=s.top2)
           {
               cerr<<"试图入右栈，发生上溢!"<<endl;
           } 
           else
           {
               s.Array[s.top2]=x;
           }
           
       }
}
//出栈
int stack_pop(int Array[],int flag)
{
        if (flag==0)
        {
            s.top1--;
            if (stack_empty(s.Array,flag))
            {
                cerr<<"试图出左栈，发生下溢！"<<endl;
                return -1;
            }
            else
            {
                return s.Array[s.top1+1];
            }
        } 
        else
        {
            s.top2++;
            if (stack_empty(s.Array,flag))
            {
                cerr<<"试图出右栈，发生下溢"<<endl;
                return -1;
            }
            else
            {
                
                return s.Array[s.top2-1];
            }
        }    
}
bool All_data_out_of_stack()//检测是否两个栈都为空，目的是使数组中所有数据都能输出
{
   if (s.top1<-1&&s.top2>n)
   {
       cout<<"数组全部数据已全部出栈！"<<endl;
       return true;
   } 
   else
       return false;
}
void main()
{
    struct stack s;
    Init_Stack();
    int x=0,flag=0;
    static h1=0,h2=0;
    srand( (unsigned)time( NULL ) );
    cout<<"随机对两个栈进行入栈操作中。。"<<endl;
    for ( int i=0;i<n;i++)
    {
        x=rand()%100;
        flag=rand()%(1-0+1)+0;
        stack_push(s.Array,x,flag);
    }
    cout<<"随机对两个栈进行出栈操作中。。"<<endl;
    for (i=0;;i++)
    {
        flag=rand()%(1-0+1)+0;
        int t=stack_pop(s.Array,flag);
        if (All_data_out_of_stack())
        {
            break;
        } 
        else if(t!=-1)