Pile de structure de données (langage C)

téléchargement de code github

code github:
https://github.com/Kyrie-leon/Data_Structures/tree/main/stack_queue

1. Le concept et la structure de la pile

Pile : une forme linéaire spéciale, dans laquelle une seule extrémité est fixée pour les opérations d' insertion et de suppression d' éléments.Une extrémité des opérations d'insertion et de suppression de données est appelée le haut de la pile et l'autre extrémité est appelée le bas de la pile. Les éléments de données de la pile obéissentLIFO (dernier entré, premier sorti)en principe.
Push : L'opération d'insertion de la pile est appelée push / push / push,Les données entrantes sont en haut de la pile.
Pop : l'opération de suppression de la pile est appelée pop.Les données sont également au sommet de la pile。

Deuxièmement, la mise en œuvre de la pile

L'implémentation de la pile peut généralement être implémentée à l'aide d' un tableau ou d'une liste chaînée , et la structure du tableau est relativement meilleure. Parce que le tableau est dansLe coût d'insertion des données sur la queue est relativement faible,Comme indiqué ci-dessous.

Cependant, si la structure suivante est utilisée pour implémenter la pile, l' insertion de queue doit déplacer les données , ce qui entraîne une surcharge de calcul importante.

2.1 Définition du stockage en pile

La pile de stockage statique est implémentée à l'
aide d'un tableau unidimensionnel statique a [N], mais cela entraînera un gaspillage d'espace ou un espace insuffisant

#define N 10
typedef int STDataType;
typedef struct Stack Stack;
struct Stack
{
    
    
	STDataType a[N];
	int _top;	//栈顶
};

Prend en charge la croissance dynamique de la pile
Utilisez un pointeur _a pour ouvrir dynamiquement la mémoire pour atteindre le stockage de pile

typedef int STDataType;
typedef struct Stack Stack;
//支持动态增长的栈
struct Stack
{
    
    
	STDataType * _a;
	int _top;			//栈顶
	int _capacity;		//容量
};

2.2 Initialisation de la pile

Initialisation: par défaut, quatre espaces de taille STDataType sont ouverts pour la pile

• capacité: la capacité de la pile , par défaut 4
• _top: indique le haut de la pile . Nous convenons que _top = 0 signifie que la pile est vide. Après cela, _top augmentera de 1 pour chaque élément poussé sur la pile.Autrement dit, le tableau suivant du tableau pointé par _top est toujours 1 plus grand que l'indice de l'élément supérieur de pile réel

//栈的初始化
void StackInit(Stack * ps)
{
    
    
	assert(ps);
	ps->_a = (STDataType *)malloc(sizeof(Stack) * 4);	//默认数组大小为4
	ps->_top = 0;		//栈为空，则栈顶为0
	ps->_capacity = 4;	//默认栈的容量为4
}

2.3 Pousser dans la pile

Il a été convenu que le tableau suivant du tableau pointé par _top est toujours 1 plus grand que l'index de l'élément supérieur de la pile. Il vous
suffit de stocker les données dans le tableau d'index _top, puis d'ajouter 1 à _top

//入栈
void StackPush(Stack * ps, STDataType data)
{
    
    
	assert(ps);
	//判断栈是否满了，满了则增容
	if (ps->_top == ps->_capacity)
	{
    
    
		ps->_capacity *= 2;	//每次扩容2倍
		STDataType * tmp = (STDataType *)realloc(ps->_a, sizeof(Stack)*ps->_capacity);
		//判断内存是否申请成功
		if (NULL == tmp)
		{
    
    
			printf("扩容失败\n");
			exit(-1);
		}
		ps->_a = tmp;
	}
	//入栈
	ps->_a[ps->_top] = data;	
	ps->_top++;
}

2.4 Pop

Le tableau suivant du tableau pointé par _top est toujours supérieur de 1 à l'indice de l'élément supérieur de pile réel
Par conséquent, il vous suffit de réduire _top de 1.

//出栈
void StackPop(Stack * ps)
{
    
    
	assert(ps);
	assert(ps->_top>0);
	ps->_top--;
}

2.5 Récupérez l'élément supérieur de la pile

Le tableau suivant du tableau pointé par _top est toujours supérieur de 1 à l'indice de l'élément supérieur de pile réel
L'indice de l'élément supérieur de la pile est donc _top-1

//获取栈顶元素
STDataType StackTop(Stack *ps)
{
    
    
	assert(ps);
	assert(ps->_top>0);

	return ps->_a[ps->_top-1];	
}

2.6 Obtenir le nombre d'éléments valides dans la pile

Étant donné que l'index des éléments du tableau commence à 0, _top représente le nombre d'éléments valides dans la pile

//获取栈中有效元素个数
int StackSize(Stack * ps)
{
    
    
	assert(ps);
	return ps->_top;
}

2.7 Vérifier si la pile est vide

La valeur de _top peut être utilisée pour déterminer si la pile est vide.
Si _top vaut 0, cela signifie qu'il est vide.
Si _top vaut 1, cela signifie qu'il n'est pas vide. Si _top vaut 1, cela signifie qu'il n'est pas vide. S'il est négatif, il renvoie 0.

//检测栈是否为空，如果为空返回非0，不为空返回0
int StackEmpty(Stack* ps)
{
    
    
	assert(ps);
	return !(ps->_top);
}

2.8 Détruire la pile

//销毁栈
void StackDestory(Stack * ps)
{
    
    
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_capacity = ps->_top = 0;
}

Trois, test de pile

#include "stack.h"

void TestStack()
{
    
    
	Stack ps;
	StackInit(&ps);
	StackPush(&ps, 1);
	StackPush(&ps, 2);
	StackPush(&ps, 3);
	StackPush(&ps, 4);
	StackPush(&ps, 5);
	while (!StackEmpty(&ps))
	{
    
    

		printf("%d, %d\n", StackTop(&ps),StackSize(&ps));
		StackPop(&ps);
	}

	
}

int main()
{
    
    
	TestStack();
	system("pause");
	return 0;
}

Quatrièmement, la liste de codes

4.1 pile.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<windows.h>

#define N 10
typedef int STDataType;
typedef struct Stack Stack;
//struct Stack
//{
    
    
//	STDataType a[N];
//	int _top;	//栈顶
//};

//支持动态增长的栈
struct Stack
{
    
    
	STDataType * _a;
	int _top;			//栈顶
	int _capacity;		//容量
};

//初始化栈
void StackInit(Stack * ps);

//入栈
void StackPush(Stack * ps, STDataType data);

//出栈
void StackPop(Stack * ps);

//获取栈顶元素
STDataType StackTop(Stack *ps);

//获取栈顶中有效元素个数
int StackSize(Stack * ps);

//检测栈是否为空，如果为空返回非0，不为空返回0
int StackEmpty(Stack* ps);

//销毁栈
void StackDestory(Stack * ps);

4.2 pile.c

#include "stack.h"

//栈的初始化
void StackInit(Stack * ps)
{
    
    
	assert(ps);
	ps->_a = (STDataType *)malloc(sizeof(Stack) * 4);	//默认数组大小为4
	ps->_top = 0;		//栈为空，则栈顶为0
	ps->_capacity = 4;	//默认栈的容量为4
}

//入栈
void StackPush(Stack * ps, STDataType data)
{
    
    
	assert(ps);
	//判断栈是否满了，满了则增容
	if (ps->_top == ps->_capacity)
	{
    
    
		ps->_capacity *= 2;	//每次扩容2倍
		STDataType * tmp = (STDataType *)realloc(ps->_a, sizeof(Stack)*ps->_capacity);
		//判断内存是否申请成功
		if (NULL == tmp)
		{
    
    
			printf("扩容失败\n");
			exit(-1);
		}
		ps->_a = tmp;
	}
	//入栈
	ps->_a[ps->_top] = data;	
	ps->_top++;
}

//出栈
void StackPop(Stack * ps)
{
    
    
	assert(ps);
	assert(ps->_top>0);
	ps->_top--;
}

//获取栈顶元素
STDataType StackTop(Stack *ps)
{
    
    
	assert(ps);
	assert(ps->_top>0);

	return ps->_a[ps->_top-1];	
}

//获取栈中有效元素个数
int StackSize(Stack * ps)
{
    
    
	assert(ps);
	return ps->_top;
}

//检测栈是否为空，如果为空返回非0，不为空返回0
int StackEmpty(Stack* ps)
{
    
    
	assert(ps);
	return !(ps->_top);
}

//销毁栈
void StackDestory(Stack * ps)
{
    
    
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_capacity = ps->_top = 0;
}

4.3 test.c

#include "stack.h"

void TestStack()
{
    
    
	Stack ps;
	StackInit(&ps);
	StackPush(&ps, 1);
	StackPush(&ps, 2);
	StackPush(&ps, 3);
	StackPush(&ps, 4);
	StackPush(&ps, 5);
	while (!StackEmpty(&ps))
	{
    
    

		printf("%d, %d\n", StackTop(&ps),StackSize(&ps));
		StackPop(&ps);
	}

	
}

int main()
{
    
    
	TestStack();
	system("pause");
	return 0;
}