数据结构与算法（青岛大学-王卓老师）——学习笔记（第5周）

栈与队列
P48——栈与队列的定义与特点






逻辑结构为：有一个前驱后一个后继，除了端点。
队列：


案例引入：

顺序栈的表示与实现：









注意：这里文字叙述错误，（2）（3）换顺序。

#define char SElemType 
#define int status 

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define MAXSIZE 100

typedef struct{
	SElemType* top;
	SElemType* base;
	int stacksize;
}SqStack;

// 1.初始化顺序栈
status InitStatus(SqStack& S)
{
	S.base = new SElemType[MaxSize];
	// S.base = (SElemType *)malloc(MaxSize*sizeof(SElemType));
	if(!S.base) exit(OVERFLOW);
	S.top = S.base;
	S.stacksize = MAXSIZE;
	return OK;	
}

// 2.判断顺序栈是否为空
status StackEmpty(SqStack S)
{
	if(S.top == S.base)
		return TRUE;
	else
		return FALSE;
}

// 3.求顺序栈的长度
int StackLength(SqStack S)
{
	return S.top-S.base;
}

// 4.清空顺序栈
status ClearStack(SqStack &S)
{	
	if(S.base)
		S.base = S.top;
	return OK;
}

// 5.销毁顺序栈
status DestoryStack(SqStack &S)
{
	if(S.base)
	{
		S.top = S.base = NULL;
		S.stacksize = 0;
		delete s.base;
	}
	return OK;
}

// 6.顺序栈的入栈
status Pust(SqStack S, SElemType e)
{
	if(S.top - S.base == S.stacksize) return OVERFLOW;
	*S.top++ = e;
	return OK;
}

// 7.顺序栈的出栈
status Pop(SqStack &S,SElemType &e)
{
	if(S.top == S.base) return ERROR;
	e = *--S.top;
	return OK
}

链栈：

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

// 1.链栈的初始化
status InitLStack(LinkStack &S)
{
	S = NULL;
	return OK;
}

// 2.判断链栈是否为空
status LStackIsEmpty(LinkStack S)
{
	if(S == NULL) return TRUE;
	else return FALSE;
}

// 3.链栈压栈
status LStackPush(LinkStack &S,SElemType e)
{
	p = new StackNode;
	p->data = e;
	p->next = S;
	S = p;

	return OK;
}

// 4.链栈出栈
status LStackPush(LinkStack &S,SElemType &e)
{	
	if(S==NULL) return ERROR;
	p = new StackNode;
	e = S->data;
	p = S;
	S = S.next;
	delete p;
	return OK;
}

// 5.取栈顶元素
SElemtype GetTop(LinkStack S)
{
	if(S!=NULL)
	{
		return S->data;
	}
}

栈与递归：






队列:



假溢出：队列还有空间。






注意：不能直接相减




链队：

// 顺序队列

typedef struct{
	QElemType* base;
	int font;
	int rear;
}SqQueue

SqQueue Q;

// 1.求顺序队列长度
int Get_len(SqQueue Q)
{
	return (Q.rear-Q.font+MaxSize)%MaxSize;
}

// 2.顺序队（循环队列）入队
status EnQueue(SqQueue &Q,QElemType e)
{
	if((Q.rear+1)%MaxSize == Q.font) return ERROR;
	Q.base[rear] = e;
	Q.rear = (Q.rear+1)%MaxSize; // 循环
	return OK;
}

// 3.顺序队（循环队列）出队
status DeQueue(SqQueue& Q, QElemType e)
{
	if(Q.rear == Q.font) return ERROR;
	e = Q.front
	Q.font = (Q.font+1)%MaxSize;  //  循环
	return OK;
}

// 4.获取队头元素
status GetFontData(SqQueue Q,QElemType e)
{
	if(Q.front == Q.rear) return ERROR;
	e = Q.base[front];
	return OK;
}

// 链队
#define MaxSize 100;

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

typedef struct
{
	Queueptr *front;
	Queueptr *rear;
}LinkQueue;

// 1.链队的初始化
status InitLQueue(LinkQueue& Q)
{
	Q.front = Q.rear = (Queueptr)malloc(sizeof(QNode));
	// Q.front = Q.rear = new Queueptr;
	if(Q.front) exit(OVERFLOW);
}

// 2.销毁链队
status DestoryLQueue(LinkQueue& Q)
{
	while(Q.front)
	{
		Q.rear = Q.front->next;
		// delete Q.front;
		free(Q.front);
		Q.front = Q.rear;
	}
}
// 3. 链队入队
status EnLQueue(LinkQueue& Q,QElemType e)
{
	p = (Queueptr)malloc(sizeof(QNode));
	if(!p) exit(OVERFLOW);
	p->data = e;
	P->next = NULL;
	Q.rear->next = p;
	Q.rear = p;
}
// 4. 链队出队
status DeLQueue(LinkQueue Q, QElemType e)
{
	if(Q.rear == Q.front) return ERROR;// 空队
	p = (Queueptr)malloc(sizeof(QLnode));
	p = Q.front->next;
	e = p->data;
	Q.front->next = p->next;
	if(p == Q.rear) Q.rear = Q.front; // 判断Q.front 的下一个元素是否为Q.rear
	delete p ;
	return OK;
}

// 5. 获取链队的队头元素
status GetLQueue(LinkQueue Q,QElemType e)
{
	if(Q.front = Q.rear) return ERROR;
	e = Q.front->next->data;
	return OK;
}