栈和队列的插入、删除等基本操作_队列和栈的插入和删除

栈和队列

栈

• 栈：是一种特殊的线性表，其只允许在其固定的一段进行插入或者删除元素等操作；进行插入或者删除的一段称为栈顶，另一端称为栈顶；

• 栈的特性：

  先进先出
  后进后出

栈的构造（C语言实现）

1. 静态栈的构造（栈的容量不能改变）
2. 动态栈的构造（栈的容量可以改表）
1
2

//静态栈的构造就是定义一个静态的顺序表
typedef struct Stack {
        int array[100];
       int size;

} Stack;

1
2
3
4
5
6
7

//动态栈的构造
typedef int STDataType; 

typedef struct Stack {
        STDataType* _a;
        int _top; // 栈顶
        int _capacity;  // 容量
}Stack;


1
2
3
4
5
6
7
8
9
10

栈的初始化与销毁

1. 栈的初始化

void StackInit(Stack* s) {
        s->size = 0;
}
1
2
3

2. 栈的销毁

void StackDestory(Stack* s){
    s->size = 0;
}
1
2
3

栈的插入、删除、返回栈顶元素、栈内元素个数、检查栈是否为空栈

1. 栈的插入也叫入栈

//插入

void StackPush(Stack* s,int v) {
        s->array[s->size++] = v;
}
1
2
3
4
5

2. 栈的删除也叫弹栈或者出栈

void StackPop(Stack* s,int v) {
        s->size--;
}
1
2
3

3.获取栈顶元素

/返回栈顶的数据，不需要删除栈顶的数据

int StsckTop(Stack* s) {
        return s->array[s->size - 1];
}
1
2
3
4
5

4.获取栈内元素个数

//返回栈内数据个数

int StackSize(Stack* s) {
        return s->size;
}
1
2
3
4
5

5.检查栈是否为空栈；（返回0表示空栈）

//返回栈内是否为空栈
//返回0：代表不是空；返回非0：表示为空

int StackEmpty(Stack* s) {
        return !s->size;
}
1
2
3
4
5
6

队列

• 队列：只允许在一端进行插入数据操作操作 ，在另一端进行删除数据操作的特殊线性表；进行插入数据的一端叫队尾，进行删除一端叫队头；
• 特性：先进先出，后进后出
• 队的实现：队列也可以用数组或者链表实现；使用链表的结构实现会更优一些；因为使用数组结构在出队列是在数组的头上出数据，效率会更低；

队列的构造（用链表实现）

//链表节点的结构体
typedef struct Node {
        int value;
        struct Node* next;
} Node;

//队列的构造
typedef struct Queue {
        Node* head;  //队头
        Node* last;  //队尾
} Queue;
1
2
3
4
5
6
7
8
9
10
11

队列的初始化与销毁

//初始化
void QueueInit(Queue* q) {
       q->head = q->last = NULL;
}

//队列的销毁
void QueueDestroy(Queue* q) {
        Node *cur, *next;
        for (cur = q->head; cur != NULL; cur = next) {
               next = cur->next;
               free(cur);
        }
        q->head = q->last = NULL;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

队列的入队、出对、获取队列首元素、获取队列大小、判断队列是否为空

• 队列的入队（尾插）

void QueuePush(Queue* q,int v){ 
        Node* node= (Node*)malloc(sizeof(Node));
        node->value = v;
        node->next = NULL;
        if (q->head == NULL) {
               q->head = node;
               q->last = node;
        }
        else {
              q->last->next = node;
               q->last = node;
        }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

• 删除队列的头一个数据（头删）

void QueuePop(Queue* q) {
        Node* second = q->head->next;
        free(q->head);
        q->head = second;

        //last也有可能需要变更
        if (q->head == NULL) {
              q->head == NULL;
        }
}
1
2
3
4
5
6
7
8
9
10

• 获取队列的首元素

//返回队列首元素

int QueueFront(Queue* q) {
       return q->head->value;
}
1
2
3
4
5

• 获取队列的大小

int  QueueSize(Queue* q) {
        int size = 0;
        for (Node* cur = q->head; cur != NULL; cur = cur->next) {
               size++;
        }
        return size;
}
1
2
3
4
5
6
7

• 判断队列是否为空

//判断队列是否为空
int QueueEmpty(Queue* q) {
        if (q->head == NULL) {
               return -1;
        }
        else {
               return 0;
        }
}
1
2
3
4
5
6
7
8
9