三、栈和队列
(一)栈
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)队列满足先入先出