catalogue
Concept and structure of stack
Gets the number of valid elements in the stack
Determine whether the stack is empty
Concept and structure of stack
Stack: a special linear table that allows insertion and deletion of elements only at a fixed end. One end for data insertion and deletion is called the top of the stack, and the other end is called the bottom of the stack.
The data elements in the stack comply with the Last In First Out LIFO (Last In First Out) principle.
Stack pressing: the stack insertion operation is called stack entering / stack pressing / stack entering, and the input data is at the top of the stack.
Stack out: stack deletion is called stack out. The output data is also at the top of the stack.
Implementation of stack
Stack can generally be implemented by array or linked list. Relatively speaking, the structure of array is better. Because the cost of inserting data on the tail of the array is relatively small.
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int STDataType;
// The following is the structure of fixed length static stack, which is generally not practical in practice, so we mainly implement the following stack that supports dynamic growth
#define N 10
typedef struct Stack
{
STDataType _a[N];
int _top; // Stack top
}Stack;
// Stack supporting dynamic growth
typedef struct Stack
{
STDataType* a;
int top;//Stack top
int capacity;//Stack capacity
}Stack;
//initialization
void StackInit(Stack*ps);
//Destroy
void StackDestroy(Stack* ps);
//Push
void StackPush(Stack* ps, STDataType x);
//Out of stack
void StackPop(Stack* ps);
//Get stack top element
STDataType StackTop(Stack* ps);
//Determine whether the stack is empty
bool StackEmpty(Stack* ps);
//Gets the number of valid elements in the stack
int StackSize(Stack* ps);Initialization stack
The initialization and destruction of the stack are similar to that of the sequence table, which will not be explained in detail here, but the size (number of effective elements) in the sequence table is replaced by the top of the stack here.
void StackInit(Stack* ps)
{
assert(ps);
ps->a = NULL;
ps->capacity = 0;
ps->top = 0;//It can also be initialized to - 1, but it needs to be changed in the implementation of later functions
}Destroy
void StackDestroy(Stack* ps)
{
assert(ps);
free(ps->a);
ps->a = NULL;
ps->capacity = ps->top = 0;
}Push
Like the sequence table, when adding elements, you must first judge whether the capacity is sufficient. If the capacity is insufficient, you need to expand the capacity.
The stacking here is the same as the tail insertion of the sequence table.
void StackPush(Stack* ps, STDataType x)
{
assert(ps);
if (ps->top == ps->capacity)
{
int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
STDataType* tmp = (STDataType*)realloc(ps->a , sizeof(STDataType) * newcapacity);
if (tmp == NULL)
{
perror("realloc");
exit(-1);
}
ps->a = tmp;
ps->capacity = newcapacity;
}
ps->a[ps->top] = x;
ps->top++;
}
Out of stack
When the stack is out, the tail is deleted. To delete elements, you need to judge whether the stack is empty. An empty stack cannot be out of the stack.
Determine whether the stack is empty, which is implemented below.
void StackPop(Stack* ps)
{
assert(ps);
assert(!StackEmpty(ps));
ps->top--;
}Get stack top element
The top element of the stack is the last element in the sequence table, which can be found directly according to the subscript.
Of course, the stack cannot be empty.
STDataType StackTop(Stack* ps)
{
assert(ps);
assert(!StackEmpty(ps));
return ps->a[ps->top - 1];
}
Gets the number of valid elements in the stack
Just return to top.
int StackSize(Stack* ps)
{
assert(ps);
return ps->top;
}
Determine whether the stack is empty
You can directly judge whether the stack is empty according to whether top is equal to 0.
bool StackEmpty(Stack* ps)
{
assert(ps);
return ps->top == 0;
}test
The stack test cannot print each element of the stack in turn, but needs to enter the stack first, then find the top element of the stack and exit the stack in turn.
int main()
{
Stack s;
StackInit(&s);
StackPush(&s, 1);
StackPush(&s, 2);
StackPush(&s, 3);
StackPush(&s, 4);
StackPush(&s, 5);
while (!StackEmpty(&s))
{
printf("%d ", StackTop(&s));
StackPop(&s);
}
StackDestroy(&s);
return 0;
}The results are as follows:
