数据结构(严蔚敏)读书笔记 (3): 栈和队列

顺序栈

#include<iostream>
#include<stdlib.h>
#include<bits/stdc++.h>
using namespace std;

#define OK 1
#define ERROR 0
#define MAX 1000
typedef int ElemType;

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

int InitStack(SqStack &s){
	s.base = new ElemType[MAX];
	if(!s.base) exit(EOVERFLOW);
	s.top = s.base;
	s.stacksize = MAX;

	return OK;
}

int Push(SqStack &s, ElemType e){
	if(s.top - s.base == s.stacksize) return ERROR;
	*s.top = e;
	s.top++;
	return OK;
}

int Pop(SqStack &s, ElemType &e){
	if(s.top == s.base) return ERROR;
       	e = *--s.top;
	return OK;
}

int GetTop(SqStack s){
	if(s.top == s.base) return ERROR;
	return *(s.top - 1);



}


int main(int argc, char*argv[]){
	

	return 0;
}

链栈

#include<iostream>
#include<stdlib.h>
#include<bits/stdc++.h>
using namespace std;

#define OK 1
#define ERROR 0
#define MAX 1000
typedef int ElemType;

typedef struct StackNode{
	ElemType data;
	struct StackNode *next;
}Stack, *LinkStack;

int InitStack(LinkStack &s){
	s = new StackNode;
	s = NULL; //??????????
	return OK;
	
}

int Push(LinkStack &s, ElemType e){
	StackNode* p = new StackNode;
	p->data = e;
	p->next = s;
	s = p;
	return OK;

}

int Pop(LinkStack &s, ElemType &e){
	if(s == NULL) return ERROR;
	e = s->data;
	StackNode* p = s;
	s = s->next;
	delete p;
	return OK;


}

ElemType GetTop(LinkStack s){
	if(s == NULL) return ERROR;


	return s->data;;
}


int main(int argc, char*argv[]){
	return 0;
}

有关递归

|| 高级语言编制的程序中， 调用函数和被调用函数之间的链接及信息交换需通过栈来进行。

|| 当有多个函数构成嵌套调用时， 按照 “后调用先返回＂ 的原则， 上述函数之间的信息传递和控制转移必须通过 ＂栈 ” 来实现， 即系统将整个程序运行时所需的数据空间安排在一个栈中，每当调用一个函数时，就为它在栈顶分配一个存储区，每当从一个函数退出时，就释放它的存储区，则当前正运行的函数的数据区必在栈顶。

顺序队列(循环队列)

|| 初始化创建空队列时，令 front = rear = 0 , 每当插入新的队列尾元素时，尾指针 rear增1; 每当删除队列头元素时， 头指针 front增1。因此，在非空队列中，头指针始终指向队列头元素，而尾指针始终指向队列尾元素的下一个位置
当把rear顶到最上方时，，队列无法再入队，处于“假溢出”的状态，我们采用循环的方式，通过 “模” 运算，Q.rear = (Q.rear + 1)%6, 把rear重置到下方。

此时

• 队空的条件： Q.front = Q.rear
• 队满的条件： (Q rear+ 1)%M心CQSIZE = Q.front

#include<stdlib.h>
#include<bits/stdc++.h>
using namespace std;

#define OK 1
#define ERROR 0
#define MAX 1000
typedef int ElemType;

typedef struct{
	ElemType *base;
	int front; // 头指针
	int rear; // 尾指针
}SqQueue;


int InitQueue(SqQueue &q){
	q.base = new ElemType[MAX];
	if(!q.base) exit(EOVERFLOW);
	q.front = q.rear = 0;
	return OK;
}

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

int EnQueue(SqQueue &Q, ElemType e){
	if((Q.rear + 1) % MAX == Q.front) return ERROR;
	Q.base[Q.rear] = e;
	Q.rear = (Q.rear + 1) % MAX;

	return OK;
}

int DeQueue(SqQueue &Q, ElemType &e){
	if(Q.front == Q.rear) return ERROR;
	e = Q.base[Q.front];
	Q.front = (Q.front + 1) % MAX;
	return OK;

}


ElemType GetHead(SqQueue Q){
	if(Q.front == Q.rear) return ERROR;
	return Q.base[Q.front];
}


int main(int argc, char*argv[]){

	return 0;
}

链队

#include<stdlib.h>
#include<bits/stdc++.h>
using namespace std;

#define OK 1
#define ERROR 0
#define MAX 1000
typedef int ElemType;

typedef struct {   // 头尾两个特殊指针即可以表示链队列
        QueuePtr front; // 队头指针
        QueuePtr rear; // 队尾指针
}LinkQueue;

int InitQueue(LinkQueue &q){
        q.front = q.rear = new QNode;  // 头节点

        q.front->next = NULL; // 头指针的头节点指向NULL
        return OK;
}





int InitQueue(LinkQueue &q){
	q.front = q.rear = new QNode;  // 澶磋妭鐐?
	
	q.front->next = NULL; // 澶存寚閽堢殑澶磋妭鐐规寚鍚慛ULL
	return OK;
}

int EnQueue(LinkQueue &q, ElemType e){
	QNode* a = new QNode;
	a->data = e;
	//a->next = q.rear;
	a->next=NULL; q.rear->next = a;
	q.rear = a;
	
	return OK;

}


int DeQueue(LinkQueue &Q, ElemType &e){
        if(Q.front == Q.rear) return ERROR;

        QNode* p = Q.front->next;  // 头节点后的首元节点
        e = Q.front->data;
        Q.front->next = Q.front->next->next;
        if(Q.rear==Q.front->next) Q.rear=Q.front; // 注意最后一个元素被删除时要>将对为指针指向头节点
        delete p;
        return OK;


}


ElemType GetHead(LinkQueue Q){
	if(Q.front != Q.rear)
		return Q.front->next->data;
	return ERROR;
}

int main(int argc, char*argv[]){

	return 0;
}