数据结构第三章栈和队列

第三章

静态栈

#include <stdlib.h>

#define Maxsize 10
typedef struct 
{	
	int data[Maxsize];
	int top;
}SqStack;



/*
	以下代码为栈顶指针指向-1
*/

//初始化栈
void InitStack(SqStack& S) {
	S.top = -1;
}

//判空
bool StackEmpty(SqStack S) {
	if (S.top == -1)
	{
		return true;
	}
	else
	{
		return false;
	}
}

//入栈
bool Push(SqStack& S, int x) {
	if (S.top ==Maxsize-1)
	{
		return	false;
	}
	S.data[++S.top] = x;
	/*
	S.top = S.top +1;
	S.data[S.top] =x;
	*/
	return true;
}

//出栈
bool Pop(SqStack& S, int& x) {
	if (S.top ==-1)
	{
		return false;
	}
	x = S.data[S.top --];
	/*
	x=S.data[S.top];
	S.top =S.top -1;
	*/
	return true;
}

//读栈顶元素
bool GetTop(SqStack S, int& x) {
	if (S.top ==-1)
	{
		return false;
	}
	x = S.data[S.top];
	return true;
}


/*
	以下代码为栈顶指针指向0
*/


//初始化栈
void InitStack(SqStack& S) {
	S.top = 0;
}

//判空
bool StackEmpty(SqStack S) {
	if (S.top == 0)
	{
		return true;
	}
	else
	{
		return false;
	}
}

//入栈
bool Push(SqStack& S, int x) {
	if (S.top == Maxsize - 1)
	{
		return	false;
	}
	S.data[S.top++] = x;
	/*
	S.data[S.top] =x;
	S.top = S.top +1;
	*/
	return true;
}

//出栈
bool Pop(SqStack& S, int& x) {
	if (S.top == 0)
	{
		return false;
	}
	x = S.data[--S.top];
	/*
	S.top =S.top -1;
	x=S.data[S.top];
	*/
	return true;
}

//读栈顶元素
bool GetTop(SqStack S, int& x) {
	if (S.top == 0)
	{
		return false;
	}
	x = S.data[S.top];
	return true;
}

// 共享栈

typedef struct 
{
	int data[Maxsize];
	int top0, top1;
}Shstack;

void InitShStack(Shstack& S) {
	S.top0 = -1;
	S.top1 = Maxsize;
}
/*
栈满的条件为 top0 + 1 ==top1
*/

链栈（不带头结点）

#include <stdlib.h>

typedef struct Linknode
{
	int data;
	struct Linknode* next;
}Linknode,*LiStack;

/*
	带头结点的
*/
//初始化
bool InitLiStack(LiStack& L) {
	L = (Linknode*)malloc(sizeof(Linknode));
	if (L)
	{
		L->next = NULL;
		return true;
	}
	else
	{
		return false;
	}
	
}

bool LiListEmpty(LiStack L) {
	if (L->next == NULL)
	{
		return true;
	}
	else
	{
		return false;
	}
}

bool Push(LiStack& L, int x) {
	if (L==NULL || x ==NULL)
	{
		return false;
	}
	Linknode* s = (Linknode*)malloc(sizeof(Linknode));
	if (s ==NULL)
	{
		return false;
	}
	s->data = x;
	s->next = L->next;
	L->next = s;
}

bool Pop(LiStack& L, int& x) {
	if (L->next == NULL)
	{
		return false;
	}
	else
	{	
		Linknode* s = L->next;
		x = s->data;
		L->next = s->next;
		free(s); 
	}
}

bool GetTop(LiStack L,int &x) {
	if (L->next ==NULL)
	{
		return false;
	}
	else
	{
		x = L->next->data;
		return true;
	}
}

静态队列

#include <stdlib.h>
#define Maxsize 10

typedef struct 
{
	int data[Maxsize];
	int front, rear;
}SqQueue;

void InitQueue(SqQueue& Q) {
	Q.rear = Q.front = 0;
}

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

//入队
/*
形成循环队列
*/
bool EnQueue(SqQueue& Q, int x) {
	if ((Q.rear + 1 )%Maxsize == Q.front)//判断队满
	{
		return false;
	}
	Q.data[Q.rear] = x;				//新元素插入队尾					 
	Q.rear = (Q.rear + 1) % Maxsize;//队尾指针加1取模，使队尾数超过Maxsize时可以从头开始
}

//出队
bool DeQueue(SqQueue& Q, int& x) {
	if (Q.rear == Q.front)
	{
		return false;
	}
	x = Q.data[Q.front];
	Q.front = (Q.front +1) % Maxsize;
}

bool GetHead(SqQueue Q,int &x) {
	if (Q.rear ==Q.front)
	{
		return false;
	}
	x = Q.data[Q.front];
	return true; 
}

int SqQueueSize(SqQueue Q) {
	return int(Q.rear + Maxsize - Q.front) / Maxsize;
}

/*
如果要求空间全部利用，不能有空的
typedef struct
{
	int data[Maxsize];
	int front, rear;
	int size；
}SqQueue;
初始化时，size =0；入队加一，出队减一



或者
typedef struct
{
	int data[Maxsize];
	int front, rear;
	int tag；			//最近进行的是插入还是删除
}SqQueue;
初始化时， tag = 0； 删除成功的话，使tag =0，插入成功使tag = 1
只有插入才可能导致队满   front ==rear && tag ==1
只有删除才可能导致队空  front == rear && tag ==0
*/

链队（带头结点）

#include <stdio.h>
#include <stdlib.h>

typedef struct LinkNode {
	int data;
	struct LinkNode* next;
}LinkNode;

typedef struct {
	LinkNode* front, * rear;   //头尾指针
}LinkQueue;

void InitQueue(LinkQueue& Q) {
	Q.front = Q.rear = (LinkNode*)malloc(sizeof(LinkNode));
	if (Q.front)
	{
		Q.front->next = NULL;
	}
 }

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

//入队
void EnQueue(LinkQueue& Q, int x) {
	LinkNode* s = (LinkNode*)malloc(sizeof(LinkNode));
	if (s)
	{
		s->data = x;
		s->next = NULL;
		Q.rear->next = s;	//s放在rear后
		Q.rear = s;			//s成为rear
	}
}

//出队
bool DeQueue(LinkQueue& Q, int& x) {
	if (Q.front == Q.rear)
	{
		return false;
	}
	LinkNode* s = Q.front->next;
	if (s == NULL)
	{
		return false;
	}
	x = s->data;
	Q.front->next = s->next;
	if (Q.rear ==s)
	{
		Q.rear = Q.front;
	}
	free(s);
	return true;
}

链队（不带头结点）

#include <stdio.h>
#include <stdlib.h>

typedef struct LinkNode {
	int data;
	struct LinkNode* next;
}LinkNode;

typedef struct {
	LinkNode* front, * rear;   //头尾指针
}LinkQueue;

void InitQueue(LinkQueue& Q) {
	Q.front = Q.rear = (LinkNode*)malloc(sizeof(LinkNode));
	if (Q.front )
	{
		Q.front= NULL;
		Q.rear = NULL;
	}
}

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

//入队
void EnQueue(LinkQueue& Q, int x) {
	LinkNode* s = (LinkNode*)malloc(sizeof(LinkNode));
	if (s)
	{
		s->data = x;
		s->next = NULL;
		if (Q.front == NULL)	//第一个元素入队
		{
			Q.front = s;
			Q.rear = s;
		}
		else {
			Q.rear->next = s;	//s放在rear后
			Q.rear = s;			//s成为rear
		}
	}
}

//出队
bool DeQueue(LinkQueue& Q, int& x) {
	if (Q.front ==NULL)
	{
		return false;
	}
	LinkNode* s = Q.front;
	if (s == NULL)
	{
		return false;
	}
	x = s->data;
	Q.front = s->next;
	if (Q.rear == s)
	{
		Q.rear = Q.front =NULL;
	}
	free(s);
	return true;
}