棧和隊列相關操作的算法總結

棧相關操作的算法總結

順序棧

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