数据结构与算法-栈和队列

三、栈和队列

（一）栈

1.定义

栈是线性表的一种特殊形式，它的数据满足先入后出。

---

2.编程实现

（1）顺序表实现栈

//栈顶元素为数组的最后一个元素
#include <stdio.h>
#include <stdlib.h>


typedef struct Stack {
	
	int* data;
	int capacity;
	int top;
}stack;


void init(stack* s,int capacity){
	
	s->capacity = capacity;
	s->data = (int*)malloc(sizeof(int)*capacity);
	s->top = -1;
}

int isFull(const stack* s){
	
	int flag = -1;
	
	if(s->top == s->capacity - 1)
		flag = 0;
	
	return flag;
}

int push(stack* s,int data){
	
	int flag = -1;
	if(isFull(s) != 0)
	{
		s->data[++s->top] = data;
		flag = 0;
	}
	
	return flag;
}

int isEmpty(const stack* s){
	
	int flag = -1;
	if(s->top == -1)
		flag = 0;
	return flag;
}

int pop(stack* s,int* data){
	
	int flag = -1;
	if(isEmpty(s) != 0)
	{
		*data = s->data[s->top];
		s->top--;
		flag = 0;
	}
	
	return flag;
}

void print(stack s){
	
	for(int i = 0;i <= s.top;i++)
		printf("%d",s.data[i]);
}


int main(){
	
	stack s;
	init(&s,5);
	for(int i = 0;i < 5;i++)
		push(&s,i);
	int data;
	for(int i = 0;i < 4;i++)
		pop(&s,&data);
	print(s);
	
	return 0;
}

---

（2）链表实现栈

//栈顶为链表头节点
#include <stdio.h>
#include <stdlib.h>

typedef struct Stack{
	
	int data;
	struct Stack* next;
	
}stack;

int push(stack** top,int data){
	
	int flag = -1;
	
	stack* node = (stack*)malloc(sizeof(stack));
	node->data = data;
	node->next = NULL;
	
	node->next = *top;
	*top = node;
	
	flag = 0;
	
	return flag;
}

int pop(stack** top){
	
	int flag = -1;
	
	if(*top == NULL)
		flag = -1;
	else
	{
		stack* temp = *top;
		*top = (*top)->next;
		free(temp);
	
		flag = 0;
	}
	return flag;
}

int gettop(stack* top){
	
	return top->data;
}

void print(stack* top){
	
	while(top)
	{
		printf("%d",top->data);
		top = top->next;
	}
}




int main(){
	
	stack* top = NULL;
	
	push(&top,1);
	push(&top,2);
	push(&top,3);
	push(&top,4);
	pop(&top);
	pop(&top);
	print(top);
	printf("%d",gettop(top));
	
	return 0;
}

---

（二）队列

1.定义

队列是线性表的一种特殊形式，它的数据满足先入先出。时间复杂度只有O(1)

---

2.C语言实现

（1）顺序表实现队列

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

typedef struct Queue{
	
	int* data;
	int capacity;
	int front;
	int rear;
}queue;

void init(queue* q,int capacity){
	
	q->capacity = capacity;
	q->data = (int*)malloc(sizeof(int)*(capacity+1));
	q->front = 0;
	q->rear = 0;
}

int isFull(const queue* q){
	
	int flag = -1;
	if((q->rear+1)%(q->capacity+1) == q->front)
		flag = 0;
	return flag;
}

int enqueue(queue* q,int data){
	
	int flag = -1;
	if(isFull(q) != 0)
	{
		q->data[q->rear] = data;
		q->rear = (q->rear+1)%(q->capacity+1);
		flag = 0;
	}
	
	return flag;
}

int isEmpty(const queue* q){
	
	int flag = -1;
	if(q->rear == q->front)
		flag = 0;
	return flag;
}

int dequeue(queue* q,int* data){
	
	int flag = -1;
	if(isEmpty(q) != 0)
	{
		*data = q->data[q->front];
		q->front = (q->front+1)%(q->capacity+1);
		flag = 0;
	}
	
	return flag;
}

void print(queue q){
	
	for(int i = q.front;i < q.rear;i++)
		printf("%d",q.data[i]);
}

int main()
{
	queue q;
	init(&q,5);
	for(int i = 0;i < 5;i++)
		enqueue(&q,i);
	
	int data;
	for(int i = 0;i < 6;i++)
		dequeue(&q,&data);
	print(q);
   
   return 0;
}

---

（2）链表实现队列

//C++ 实现
#include <iostream>
using namespace std;

struct QueueNode{
	
	int data;
	QueueNode* next;
};

class Queue{
	
	private:
		QueueNode* front;
		QueueNode* rear;
	public:
		QueueNode* createNode(int data);
		bool enQueue(int data);
		bool deQueue(int &data);
		void print();
	
		Queue();
};

QueueNode* Queue::createNode(int data){
	
	QueueNode* node = new QueueNode();
	node->data = data;
	node->next = NULL;
	
	return node;
}

Queue::Queue(){
	
	rear = front = NULL;
}

bool Queue::enQueue(int data){
	
	bool flag = false;
	QueueNode* temp = createNode(data);
	if(front == NULL)
	{
		rear = front = temp;
	}
	else
	{
		rear->next = temp;
		rear = temp;
	}
	
	flag = true;
	return flag;
	
}

bool Queue::deQueue(int &data){
	
	bool flag = false;
	if(front == NULL)
		flag = false;
	else
	{
		data = front->data;
		QueueNode* temp = front;
		front = front->next;
		delete temp;
		flag = true;
	}
	
	return flag;
}


void Queue::print(){
	
	QueueNode* temp = front;
	while(temp)
	{
		cout << temp->data <<endl;
		temp = temp->next;
	}
}

int main()
{
	Queue q;
	for(int i = 0;i < 10;i++)
		q.enQueue(i);
	int data;
	for(int i = 0;i < 11;i++)
		q.deQueue(data);
	q.enQueue(2);
	q.print();
   cout << "Hello World";
   return 0;
}

---

（三）总结

栈和队列只是线性表中的元素的插入和删除有特定的物理结构，其本质还是线性表，这只是简单的栈和队列功能的实现，在实际运用中栈和队列的思想非常广泛。

重点

（1）栈只能满足先入后出

（2）队列把握对首和队尾这两个中间变量，使得时间复杂度为O(1)

（3）队列满足先入先出