Adding, deleting, checking and modifying stack - dynamic memory

Stack access is “ First in first out or last in first out ”.

Catalog

One 、 The header file 、 structure 、 function

Two 、 Function analysis ：

（1） initialization

（2） The destruction

（3） Insert

（4） Delete

（5） Stack top ID

（6） Judge the space capacity

（7） The size of the stack

（8） Operation of stack

3、 ... and 、 Running results ：

---

---

One 、 The header file 、 structure 、 function

The header files that need to be used are ：

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

Type of structure ：

typedef int STDataType;// It is convenient to change the structure type （int  char double...）
typedef struct stack
{
	STDataType *a;// Integer data 
	int top;// Identify the position of the top of the stack 
	int capacity;// Capacity 
}ST;

The main functions used ：

void StackInit(ST* ps);// initialization 
void StackDestory(ST* ps);// The destruction 
void StackPush(ST* ps,STDataType x);// insert data 
void StackPop(ST* ps);// Delete 
STDataType StackTop(ST* ps);// Stack top ID 
bool StackEmpty(ST* ps);// Judge the space capacity 
int STackSize(ST* ps);// size 

Two 、 Function analysis ：

（1） initialization

First, the initial data is 0.

void StackInit(ST* ps)
{
	assert(ps);// Assertion , Judge ps Is it empty 
	ps->a = NULL;// initialization 
	ps->top = 0;// initialization 
	ps->capacity = 0;// initialization 
}

（2） The destruction

We must remember to destroy the dynamic space .

void StackDestory(ST* ps)
{
	free(ps->a);// Release space 
	ps->a = NULL;// The pointer becomes null 
	ps->top = ps->capacity = 0;// Zeroing 

}

（3） Insert

Insert data into it ： Because the stack is in the form of last in first out , Therefore, you can only insert them in sequence .

void StackPush(ST* ps, STDataType x)// insert data 
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;// If the capacity is zero, it will be opened up 4 Space , Each time 4 Multiple development 
		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newCapacity);// Open up space size 
		if (tmp == NULL)// Development failure reminder 
		{
			printf("realloc fail\n");
			exit(-1);

		}
		ps->a = tmp;
		ps->capacity = newCapacity;
	}
	ps->a[ps->top] = x;// Inserted data 
	ps->top++;// Every time you insert a data top+1
}

（4） Delete

Because the stack is in the form of last in first out , Therefore, you can only delete from the last data , So direct top-- That's it

void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	 ps->top--;
}

（5） Stack top ID

STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a[ps->top - 1];// Return data subscript position 
}

（6） Judge the space capacity

bool StackEmpty(ST* ps)
{
	assert(ps);
	
	return ps->top == 0;//top=0 by false, It's not equal to 0 That is to say true
}

（7） The size of the stack

Used to count the amount of data in the stack

int STackSize(ST* ps)
{
	assert(ps);
	return ps->top;// The total number of data in the stack 
}

（8） Operation of stack

Add and change the stack through the following code .

void TestStack()
{
	ST st;
	StackInit(&st);// initialization 
// Insert 
	StackPush(&st, 1);
	StackPush(&st, 2);
	StackPush(&st, 3);
	
    printf("%d ", StackTop(&st));// Print the last entered data 
	StackPop(&st);// Delete the last data 
	printf("%d ", StackTop(&st));// Print the last data after deletion 
	StackPop(&st);// Then delete the last data 
// Insert 
	StackPush(&st, 4);
	StackPush(&st, 5);
	StackPush(&st, 6);
    printf("\n");

// Print the rest of the stack 
	while (!StackEmpty(&st))
	{
		printf("%d ", StackTop(&st));
		StackPop(&st);
	}
	printf("\n");

	StackDestory(&st);
}

int main()
{
	TestStack();// call 
	return 0;
}

3、 ... and 、 Running results ：