队列和栈
{
队列:
顺序存储队列和链式存储队列
栈:
顺序存储栈和链式存储栈
}
队列
{
队列的定义:
只能在表的一端(队尾)进行插入,在另一端(队头)进行删除运算的线性表
顺序存储队列
{
顺序存储队列的表示:
顺序存储队列的实现(一般采用循环队列)
{
顺序队列的定义:
#define MAXQSIZE 100 //最大长度
Typedef struct
{
QElemType *base; //初始化的动态分配存储空间
int front; //头指针
int rear; //尾指针
}SqQueue;
顺序队列的重要操作的实现:
(1)队列的初始化
Status InitQueue(SqQueue &Q)
{
Q.base=new ElemType[MAXSIZE]; //为队列分配空间
If(!Q.base) return false; //分配空间失败
front=rear=0; //设置为空队列
Return ture; //初始化成功
}
(2)求队列的长度
int QueueLength(SqQueue Q)
{
return (Q.rear-Q.font+MAXSIZE)%MAXSIZE; //返回队列的长度
}
(3)循环队列入队
Status EnQueue(SqQueue &Q,ElemType e)
{
If((Q.rear-Q.front+MAXSIZE)%MAXSIZE==MAXSIZE-1) return false;
//堆满,入队失败
Q.base[rear]=e; //插入队列的尾部
Q.rear=(Q.rear+1)%MAXSIZE; //队尾指针上移
return ture; //入队成功
}
(4)顺序队列出队
Status DeQueue(SqQueue &Q,ElemType e)
{
If(Q.rear==Q.front) return false; //空队
e=Q.base[front]; //出队
front=(front+1)%MAXSIZE; //修改队头指针
return ture; //出队成功
}
}
链式存储队列
{
链式存储队列的表示:
链式存储队列实现:
typedef struct QNode{
ElemType data;
struct Qnode *next;
}Qnode, *QueuePtr;
typedef struct {
QueuePtr front; //队头指针
QueuePtr rear; //队尾指针
}LinkQueue;
链队的重要操作的实现:
(1)链队的初始化
Status IniQueue(LinkQueue &Q)
{
Q.front=Q.rear=QueuePtr=new Struct QNode //初始化为空队
If(!Q.front)return false; //分配空间失败
Q.front->next=NULL; //
Return OK; //分配成功
}
(2)摧毁队列
Status DestroyQueue(LinkQueue &Q)
{
while(Q.front) //队列非空
{Q.rear=Q.front->next; delete Q.front;Q.front=Q.rear;}
//删除队头元素,借助队尾指针前移动
return ture;
}
(3)判断链队列是否为空
Status IsEmpty_Queue(LinkQueue Q)
{
if(Q.rear==Q.front) return ture;
else return false;
}
(4)求链队列的队头元素
Status GetHead(LinkQueue Q,ElemType &e)
{
if(Q.rear==Q.front) return false; //队空
e=Q.front->next->data; //取出队头元素
return ture;
}
(5)链队列入队
Status EnQueue(LinkQueue Q,ElemType &e)
{
Q.rear->next=new QNode; //队尾指针指向新结点
if(Q.rear->next)return false; //入队成功
Q.rear->next->data=e;Q.rear->next->next=NULL;
Q.rear=Q.rear->next;
return true;
}
(6)链队列出队
Status DeQueue(LinkQueue &Q,ElemType &e)
{
p=Q.front->next ;
if(Q.front==Q.rear) reture false;
e=p->data;
Q.front->next=p->next;
if(Q.rear==p)
Q.rear=Q.front;
delete p;
return ture;
}
}
}
栈
{
栈的定义:
只能在表的一端(栈顶)进行插入和删除运算的线性表
栈的表示:
顺序存储栈
{
顺序存储栈的表示:
顺序存储栈的实现
{
顺序栈的类型定义:
#define MAXSIZE 100
typedef struct
{
ElemType *base;
ElemType *top;
int stacksize;
}SqStack;
顺序栈的重要操作的实现:
(1)顺序栈的初始化
Status InitStack(SqStack &S)
{
S.base=new ElemType[MAXSIZE];
if(!S.base) return false;
S.top=S.base;
S.stacksize=MAXSIZE;
return ture;
}
(2)判断顺序栈是否为空
bool StackEmpty(Sqstack S)
{
return(S.base==S.top);
}
(3)求顺序栈的长度
int StackLength(SqStack S)
{
return (S.base-S.top);
}
(4)清空顺序栈
Status ClearStack(SqStack &S)
{
if(S.base)S.top=S.base;
return ture;
}
(5)摧毁顺序栈
Status DestroryStack(SqStack &S)
{
if(S.base)
{
delete []S.base;
S.stacksize=0;
S.base=S.top=NULL;
}
return ture;
}
(6)顺序栈入栈
Status Push(SqStack &S,ElemType &e)
{
if(S.top-S.base==S.stcaksize) return false;
*S.top++ =e;return ture;
}
(7)顺序栈出栈
Status Pop(SqStack &S,ElemType &e)
{
if(S.top==S.base) return false;
e=*--S.top;
return ture;
}
(8)取顺序栈栈顶元素
Status GetTop(SqStack &S,ElemType &e)
{
if(S.base==S.top) return false;
e=*(S.top-1);
return ture;
}
}
链式存储栈
{
链式存储栈的表示:
链式存储栈的实现
{
链栈的类型定义:
typedef struct StackNode {
ElemType data;
struct StackNode *next;
} StackNode, *LinkStack;
LinkStack S;
链栈的重要操作的实现:
(1)链栈的初始化
Status InitStack(LinkStack &S)
{
S=NULL;
}
(2)判断链栈是否为空
Status StackEmpty(LinkStack S)
{
if(!S)return false;
else return ture;
}
(3)链栈进栈
Status Push(LinkStack &S,ElemType &e)
{
p=new StackNode;
if(!p) return fasle;
p->data=e;p->next=S;S=p;
return ture;
}
(4)链栈出栈
Status Pop(LinkStack &S,ElemType &e)
{
if(!S)return false;
e=S->data;p=S->next;delete S;S=p;
return ture;
}
(5)取链栈栈顶元素
ElemType GetTop(LinkStack &S)
{
if(!S) return false;
else return S->data;
}
}
}
栈的应用:
递归与递归算法
以下三种情况常常用到递归方法(分治法):
(1)递归定义的数学函数
(2)具有递归特性的数据结构(树和广义表)
(3)可递归求解的问题
}