jake1036

队列和栈的基本操作

                              队列和栈的基本操作

     栈的操作,栈是一种先进后出的操作,需要注意的是栈的满与空,栈空的情况是 top == 0 ,栈满的情况是 top == N 。
     栈实现的代码如下:
    

#include<iostream>
 
using namespace std ;
 
const int N = 100 ;
 
struct Stack
 
{
    
int a [N] ;    
    
int top    ;    
 }
 ;
 
 
 
void iniStack(Stack *stack) ;
 
bool empty(Stack *stack) ;
 
void push(Stack *stack , int x) ;
 
int pop(Stack *stack ) ;
 
bool full(Stack * stack) ;
 
 
int main()
 
{
    Stack 
* stack = new Stack ;
    iniStack(stack) ;
    push(stack , 
4);
    push(stack , 
5) ;
    cout
<<pop(stack) ;
    cout
<<pop(stack) ;
    cin.
get() ;
  
  
return 0 ;    
 }

 
 
void push(Stack *stack , int x) 
 
{
   
if(!full(stack))
      
{
        stack
->a[stack->top++= x ;
                      
      }
 
   
else 
      cout
<<"error full"<<endl ;
 }

 
 
int pop(Stack * stack)
 
{
   
if(empty(stack))  
     
return - 1 ;
   
else
    
return stack->a[--stack->top] ;
       
 }
  
  
  
  
void iniStack(Stack * stack)
  
{
    stack
->top = 0 ;      
  }


  
bool empty(Stack * stack)
  
{
    
return stack->top == 0 ;       
  }

  
  
bool full(Stack * stack)
   
{
     
return stack->top == N ;     
   }

  
  
   
   
 

   
 


2 队列的操作
   队列为空的判断条件,tail == head 。队列采用head插入,TAIL弹出。

   队列为满的条件是,(HEAD + 1) % N = TAIL。
  
  

   代码如下:
    

#include <iostream>
 
using namespace std ;
 
const int N = 10 ;
 
struct Queue
 
{
    
int head ; //头部插入    
    int tail ; //尾部取出    
    int a[N] ;    
 }
 ;
 
 
bool empty(Queue * queue) ;
 
bool full (Queue * queue) ;
 
void enqueue( Queue * queue , int x) ;
 
int  dequeue(Queue * queue) ;
 
void iniQueue(Queue * queue) ;
 
int main()
 
{
   Queue 
* queue = new Queue ;
   iniQueue(queue);
   enqueue(queue , 
4) ;
   enqueue(queue , 
5) ;
   cout
<<dequeue(queue) ;
   cout
<<dequeue(queue) ;
   cin.
get() ;
   
return 0 ;    
 }
 

 
void iniQueue(Queue * queue)
 
{
   queue
->head = 0 ;
   queue
->ta il = 0 ;        
 }


  
void enqueue( Queue * queue , int x)
  
{
       
if(!full(queue))
       
{
        queue
->a[queue->head++]  = x;                
       }

       
else
        cout
<<"full"<<endl ;
  }


  
int dequeue(Queue * queue) 
  
{
    
if(!empty(queue))
      
{
        
return queue->a[queue->tail++] ;             
      }

      
else
      
{
      cout
<<"empty"<<endl;  
       
return -1 ;
      }

  }

  
  
  
bool empty(Queue * queue)
  
{
    
return queue->tail == queue->head ;        
  }

  
   
bool full(Queue * queue)
   
{
    
return (queue->head + 1 ) % N == queue->tail ;      
   }

  





 

posted on 2011-04-10 10:42 kahn 阅读(793) 评论(1)  编辑 收藏 引用 所属分类: 算法相关

Feedback

# re: 队列和栈的基本操作 2011-12-11 07:19 jemmyLiu

博主判断队列满的情况好像不对
bool full(Queue* queue)
{
if (queue->head != 0)
{
return (queue->head)%N == queue->tail;
}

return false;
}
是否是我写错了 请指教  回复  更多评论   



只有注册用户登录后才能发表评论。
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理