栈和队列相关操作的算法总结

栈相关操作的算法总结

顺序栈

1.栈的顺序存储表示

#define MAXSIZE
typedef struct
{
	//在栈构造之前和销毁之后，base的值为NULL。 
	SElemType *base; 
	//栈顶指针
	SElemType *top;
	//当前已分配的存储空间，以元素为单位。 
	int stackSize;
}SqStack;

1.顺序栈初始化

void InitStack(SqStack &S)
{
	S.base = new SElemType[MAXSIZE];
	if(!S.base)
		exit(OVERFLOW);
	S.top = S.base;
	S.stackSizie = MAXSIZE;
}

2.判断顺序栈是否为空

bool StackEmpty(SqStack S)
{
	if(S.top == S.base)
		return true;
	else
		reurn false;
}

3.求顺序栈的长度

int StackLength(SqStack S)
{
	return S.top - S.base;
}

4.清空顺序栈

void ClearStack(SqStack &S)
{
	if(S.base)
		S.base = S.top;
}

5.销毁顺序栈

void DestroyStack(SqStack &S)
{
	if(S.base)
	{
		delete(S.base);
		S.stackSize = 0;
		S.base = S.top = NULL;
	}
}

6.入栈

void Push(SqStack &S,SElemType e)
{
	if(S.top-S.base == S.stackSize)
		return ERROR;
	*S.top++ = e;  //相当于*S.top = e; S.top++;
}

7.出栈

void Pop(SqStack &S,SElemType &e)
{
	if(S.top == S.base)
		return ERROR;
	e = *--S.top;  //相当于--S.top; e=*S.top;
}

8.取栈顶元素

void GetTop(SqStack S,SElemType &e)
{
	if(S.top == S.base)
		return ERROR;
	e = *(S.top-1);
}

链栈

1.栈的链式存储表示

typedef struct StackNode
{
	SElemType data;
	struct StackNode *next;
}StackNode,*LinkStack;

2.链栈的初始化

void InitStack(LinkStack &S)
{
	S = NULL;
}

3.判断链栈是否为空

bool StackEmpty(LinkStack S)
{
	if(S == NULL)
		return true;
	else 
		return false;
}

4.链栈进栈

void Push(LinkStack &S,SElemType e)
{
	p = new StackNode;
	if(!p)
		exit(OVERFLOW);
	p->data = e;
	p->next = S;
	S = p;
}

8.链栈出栈

void Pop(LinkStack &S,SElemType &e)
{
	if(S == NULL)
		return ERROR;
	e = S->data;
	p = S;
	S = S->next;
	delete p;
}

队列相关操作的算法总结

链队

1.队列的链式存储结构

typedef struct QNode
{
	QElemType data;
	struct QNode *next;
}QNode,*QueuePtr;

typedef struct 
{
	QueuePtr *front;	//队头指针
	QueuePtr *rear;		//队尾指针
}LinkQueue;   			//链队列

2.初始化链队

void InitQueue(LinkQueue &Q)
{
	Q.front = Q.rear = new QNode;
	Q.front->next = NULL;
}

3.销毁链队

void DestroyQueue(LinkQueue &Q)
{
	while(Q.front)
	{
		Q.rear = Q.front->next;
		delete Q.front;
		Q.front = Q.rear;
	}
}

4.判断链队是否为空

bool QueueEmpty(LinkQueue Q)
{
	if(Q.front == Q.rear)
		return true;
	else
		return false;
}

5.求链队的队头元素

void GetHead(LinkQueue Q,QElemType &e)
{
	if(Q.front == Q.rear)
		return ERROR;
	e = Q.front->next->data;
}

6.入队操作

void EnQueue(LinkQueue &Q,QElemType e)
{
	p = new QNode;		//为入队元素分配结点空间
	p->data = e;
	p->next = NULL;
	Q->rear->next = p;	//将新结点插入队尾
	Q->rear = p;		//修改队尾指针
}

7.出队操作

void DeQueue(Queue &Q,QElemType &e)
{
	if(Q.front == Q,rear)
		return ERROR;
	p = Q.front->next;
	e = p->data;
	Q.front->next = p->next;
	if(Q.rear == p)
		Q.rear = Q.front;
	delete p;
}

循环队列

1.循环队列的存储结构

#define MAXSIZE 100		//最大队列长度
typedef struct
{
	QElemType *base;	//用于动态分配存储空间
	int front;			//队头索引
	int rear;			//队尾索引
}SqQueue;

2.循环队列初始化

void InitQueue(SqQueue &Q)
{
	Q.base = new QElemType[MAXSIZE];
	if(!Q.base)
		exit(OVERFLOW);
	Q.front = Q.rear = 0;
}

3.求循环队列的长度

int QueueLength(SqQueue Q)
{
	return (Q.rear-Q.front+MAXSIZE)%MAXSIZE;
}

4.循环队列入队

void EnQueue(SqQueue &Q,QElemType e)
{
	if((Q.rear+1)%MAXSIZE == Q.front)
		return ERROR;
	Q.base[Q.rear] = e;
	Q.rear = (Q.rear+1)%MAXSIZE;
}

5.循环队列出队

void DeQueue(SqQueue &Q,QElemType &e)
{
	if(Q.front == Q.rear)
		return ERROE;
	e = Q.base[Q.front];
	Q.front = (Q.front+1)%MAXSIZE;
}