データ構造のスタックとキューの基本操作

1. シーケンシャルスタックの先頭が -1 に初期化される場合の基本操作:

#define Maxsize 50
typedef struct{
	ElemType data[Maxsize];    //存放栈中元素 
	int top;					//栈顶指针 
}SqStack; 

//初始化操作
void InitStack(SqStack &S)
{
	S.top=-1;
 } 
 
 //判断栈是否为空
 bool StackEmpty(SqStack S)
 {
 	if(S.top==-1)
 	return true;
 	else
 	return false;
}

//进栈
bool push(SqStack &S,ElemType x)
{
	if(S.top==Maxsize-1)   //进栈的第一步就是判断栈是否为满 
	{
		return false;
	}
	S.data[++S.top]=x;
	return true;
 } 
 
 //出栈
 bool pop(SqStack &S,ElemType &x)
{
	if(S.top==-1)   //出栈的第一步就是判断栈是否为空 
	{
		return false;
	}
	x=S.data[S.top--];
	return true;
 }  
 
 //读取栈顶元素
 bool GetTop(SqStack S,ElemType &x)
{
	if(S.top=-1)   //读栈的第一步就是判断栈是否为空 
	{
		return false;
	}
	x=S.data[S.top];
	return true;
 }  

2. シーケンシャルスタックの先頭を 0 に初期化する場合の基本動作: 

#define Maxsize 50
typedef struct{
	ElemType data[Maxsize];    //存放栈中元素 
	int top;					//栈顶指针 
}SqStack; 

 //初始化操作
void InitStack(SqStack &S)
{
	S.top=0;
 } 
 
 //判断栈是否为空
 bool StackEmpty(SqStack S)
 {
 	if(S.top==0)
 	return true;
 	else
 	return false;
}

//进栈
bool push(SqStack &S,ElemType x)
{
	if(S.top==Maxsize)   //进栈的第一步就是判断栈是否为满 
	{
		return false;
	}
	S.data[S.top++]=x;
	return true;
 } 
 
 //出栈
 bool pop(SqStack &S,ElemType &x)
{
	if(S.top==0)   //出栈的第一步就是判断栈是否为空 
	{
		return false;
	}
	x=S.data[--S.top];
	return true;
 }  
 
 //读取栈顶元素
 bool GetTop(SqStack S,ElemType &x)
{
	if(S.top==0)   //读栈的第一步就是判断栈是否为空 
	{
		return false;
	}
	x=S.data[S.top-1];
	return true;
 }  

 3. ヘッド ノードを使用しないチェーン スタックの基本操作: 

typedef struct Linknode{
	ElemType data;           //数据域 
	struct Linknode *next;    //指针域 
} *LiStack; 
 
 //初始化栈 
 bool InitStack(LiStack &S)
 {
 	S=(LiStack)malloc(sizeof(LiStack));
 	S->data=0;
 	S->next=NULL;
 }
 
 //入栈 
 bool PushStack(LiStack &S,ElemTyped x)
 {
 	LiStack p;
	p=(LiStack)malloc(sizeof(LiStack));
	p->data=x;
	p->next=S;
	S=p;
	return true;	
 }
 
 //出栈
 bool PopStack(LiStack &S,ElemTyped &x)
 {
 	LiStack p;
 	if(S==NULL)
	 	return false;
	p=S;
	x=S->data;
	S=S->next;
	free(p);
	return true;	
 }
 
 //判断栈是否为空
  bool StackEmpty(LiStack &S)
 {
 	if(S==NULL)
	return true;
	else
	return false;	
 } 

 4.先頭ノードを使用したチェーン スタックの基本操作:  

typedef struct Linknode{
	ElemType data;           //数据域 
	struct Linknode *next;    //指针域 
} *LiStack; 
 
 //初始化栈 
 bool InitStack(LiStack &S)
 {
 	S=(LiStack)malloc(sizeof(LiStack));
 	S->data=0;
 	S->next=NULL;
 }
 
 //入栈 
 bool PushStack(LiStack &S,ElemTyped x)
 {
 	LiStack p;
	p=(LiStack)malloc(sizeof(LiStack));
	p->data=e;
	p->next=S->next;  //由于栈是LIFO的特性，故用头插法 
	S->next=p;
	return true;	
 }
 
 //出栈
 bool PopStack(LiStack &S,ElemTyped &x)
 {
 	LiStack p;
 	if(S->next==NULL)
	 	return false;
	p=S->next;
	x=S->data;
	S->next=p->next;   //只能在头部删除 
	free(p);
	return true;	
 }
 
 //判断栈是否为空
  bool StackEmpty(LiStack &S)
 {
 	if(S->next==NULL)
	return true;
	else
	return false;	
 } 

5. 順次格納されたキューの基本操作:

 (1) キューの順次格納

キューのシーケンシャルストレージには、フロントとリアの 2 つのポインタがあり、フロントポインタはキューの先頭の要素を指し、後方のリアポインタは最後尾の要素の次の位置を指します。キューの。

初期状態 (キューが空の状態): Q.front=Q.rear=0;

キュー操作の開始: キューがいっぱいでない場合は、最初に値をキューの最後に送信し、次にキューの最後にあるポインタに 1 を追加します。

デキュー操作: チームが空でない場合、最初にキューの先頭にある要素をフェッチし、次にキューの先頭にあるポインタに 1 を追加します。

 (1.1) 循環キュー

最初 (空の状態): Q.front=Q.rear=0;

チーム ヘッド ポインタが 1 に入ります: Q.front=(Q.front+1)%Maxsize;

末尾ポインタには 1 が入ります: Q.rear=(Q.rear+1)%Maxsize;

キューの長さ: (Q.rear-Q.front+Maxsize)%Maxsize;

チームのフルコンディション: (Q.rear+1)%Maxsize==Q.front; または Q.front=Q.rear&&Q.size==Maxsize; または Q.front=Q.rear&&tag=1;

(2) 循環キューの基本動作:

#define Maxsize 50
typedef struct {
	ElemType data[Maxsize];      //存放队列元素
	int front,rear;             //存放队头和队尾指针 
}SqQueue; 

//初始化操作
void InitQueue(SqQueue &Q)
{
	Q.front=Q.rear=0;
 } 
 
 //判断队空
 bool Isempty(SqQueue Q)
 {
 	if(Q.front==Q.rear)
 	return true;
 	else
 	return false;
  } 
  
 //入队
 bool EnQueue(SqQueue &Q,ElemType x)
 {
 	if((Q.rear+1)%Maxsize==Q.front)
 	return false;
 	Q.data[Q.rear]=x;
 	Q.rear=(Q.rear+1)%Maxsize;
 	return true;
  } 
  
  //出队
bool DeQueue(SqQueue &Q,ElemType &x)
 {
 	if(Q.rear==Q.front)
 	return false;
 	x=Q.data[Q.front];
 	Q.front=(Q.front+1)%Maxsize;
 	return true;
  } 

 (3) 先頭ノードのチェーンキューの基本動作：

typedef struct LinkNode{
	ElemType data;                //存放队列结点 
	struct LinkNode *next;
}LinkNode; 

typedef struct{
	LinkNode *front,*rear;      //队列的队头和队尾指针 
}LinkQueue;
  
//初始化
void InitQueue(LinkQueue &Q)
{
	Q.front=Q.rear=(LinkNode *)malloc(sizeof(LinkNode));  //建立头结点
	Q.front->next=NULL; 
 } 
 
 //判队空
 bool Isempty(LinkQueue Q)
 {
 	if(Q.front==Q.rear)
 	return true;
 	else
 	return false;
  } 
  
//入队
void EnQueue(LinkQueue &Q,ElemType x)
{
	LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
	s->data=x;
	s->next=NULL;
	Q.rear->next=s;
	Q.rear=s;
 } 
 
 //出队
 void DeQueue(LinkQueue &Q,ElemType &x)
{
	if(Q.front==Q.rear)
	return false;
	LinkNode *p=Q.front->next;
	x=p->data;
	Q.front->next=p->next;
	if(Q.rear==p)   //判断是不是最后一个结点 
	{
		Q.rear=Q.front;
	} 
	free(p);
	return true; 
 } 

(4) リーダーノードなしのチェーンキューの基本動作:

typedef struct LinkNode{
	ElemType data;                //存放队列结点 
	struct LinkNode *next;
}LinkNode; 

typedef struct{
	LinkNode *front,*rear;      //队列的队头和队尾指针 
}LinkQueue;
  
//初始化
void InitQueue(LinkQueue &Q)
{
	Q.front=Q.rear=NULL; 
 } 
 
 //判队空
 bool Isempty(LinkQueue Q)
 {
 	if(Q.front==NULL)
 	return true;
 	else
 	return false;
  } 
  
//入队
void EnQueue(LinkQueue &Q,ElemType x)
{
	LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
	s->data=x;
	s->next=NULL;
	if(Q.front==NULL)  //第一个结点 
	{
		Q.front=s;
		Q.rear=s;
	}
	else
	{
		Q.rear->next=s;
		Q.rear=s;	
	}
 } 
 
 //出队
 void DeQueue(LinkQueue &Q,ElemType &x)
{
	if(Q.front==NULL)
	return false;
	LinkNode *p=Q.front;
	x=p->data;
	Q.front=p->next;
	if(Q.rear==p)   //判断是不是最后一个结点 
	{
		Q.rear=Q.front=NULL;
	} 
	free(p);
	return true; 
 }