Page d'accueil
Colonne de sujet --- structure des données
Structure des données_Il y a encore des blogs inconnus qui attendent d'être explorés-CSDN Blog
Table des matières
2. Opérations de base (pile --- structure de stockage séquentielle)
1. Initialisation de la pile séquentielle
1. Le premier type de données de la pile
2. Le deuxième type de données de la pile
2. Déterminez si la pile est vide (puis écrivez avec le premier type de données)
3. Déterminez si la pile est pleine
4. Trouvez la longueur de la pile
Introduction
La pile est une table linéaire spéciale. Les opérations de base de la pile sont le push et le pop, selon le principe du dernier entré, premier sorti . La pile ne peut être insérée et supprimée qu'à une extrémité. Cette extrémité de l'opération est appelée l'élément supérieur de la pile. L'autre extrémité de la pile est appelée l'élément inférieur de la pile, et un pointeur supérieur de la pile est utilisé pour stocker l'élément indice de l'élément supérieur de la pile. Lorsqu’il n’y a aucun élément dans la pile, on parle de pile vide.
2. Opérations de base (pile --- structure de stockage séquentielle)
1. Initialisation de la pile séquentielle
L'initialisation de la pile séquentielle consiste à construire une liste vide.
Le premier type de type de données de pile n'a pas besoin d'ouvrir de l'espace pour que le tableau stocke les données. Le deuxième type ouvre de l'espace pour le tableau sur le tas, et il est alloué dynamiquement , ce qui peut améliorer l'utilisation du tableau !
1. Le premier type de données de la pile
Le type de pile le plus basique s’écrit comme suit :
typedef int elemtype; #define MAX 1000 //最基础的栈的数据类型 struct LNode1 { elemtype data[MAX];//存数据 int MaxSize;//存数组最大容量 int top;//存栈顶元素的数组下标 }; struct LNode1* Init_SequenStack2(int MaxSize) { struct LNode1* s = (struct LNode1*)malloc(sizeof(struct LNode1));//给整个类型开辟空间 s->top = -1; s->MaxSize = MaxSize; return s; }
2. Le deuxième type de données de la pile
typedef int elemtype; #define MAX 1000 //从PTA题中学到的站的数据类型定义 struct LNode2 { elemtype* data;//存数组空间的地址(需要自己开辟空间) int MaxSize;//存数组最大容量 int top;//存栈顶元素的数组下标 }; //初始化 struct LNode2* Init_SequenStack2(int MaxSize) { struct LNode2* s = (struct LNode2*)malloc(sizeof(struct LNode2));//给整个类型进行开辟空间 s->data = (elemtype*)malloc(sizeof(elemtype));//给数组开辟空间 s->top = -1; s->MaxSize = MaxSize; return s; }
2. Déterminez si la pile est vide (puis écrivez avec le premier type de données)
Déterminez la valeur du pointeur supérieur de la pile. S'il est -1, renvoie 0 ; s'il n'est pas -1, renvoie 1.
int SequenStack_Empty(struct LNode1* s) { if (s->top == -1)//判断栈顶指针的值，为-1，返回0；不为-1，返回1 { printf("栈空\n"); return 0; } return 1; }
3. Déterminez si la pile est pleine
Déterminez la valeur du pointeur supérieur de la pile, qui est MaxSize-1, et renvoyez 0 ; sinon, renvoyez 1.
int SequenStack_Full(struct LNode1* s)//判满函数 { if (s->top == s->MaxSize - 1) { printf("栈满\n"); return 0; } return 1; }
4. Trouvez la longueur de la pile
int SequenStack_Length(struct LNode1* s)//长度函数 { return s->top + 1; }
5.Push vers la pile
Tout d'abord, assurez-vous que la pile n'est pas pleine, ++ d'abord le pointeur supérieur de la pile, puis effectuez l'opération d'affectation.
int SequenStack_Push(struct LNode1* s,int X)//入栈函数 { int ret = SequenStack_Full(s); if (ret == 0)//入栈失败 { return 0; } else { s->data[++s->top] = X; return 1; } }
6. Sortez
Pour vous assurer que la pile n'est pas vide en premier, remplacez le pointeur supérieur de la pile par --, puis effectuez l'opération d'affectation.
int SequenStack_Pop(struct LNode1* s)//出栈函数 { int flag = SequenStack_Empty(s); if (flag == ERROR) { return 0; } else { return s->data[s->top--]; } }
3. Avantages
La complexité temporelle de toutes les opérations ci-dessus est O(1)
4. Code total
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
typedef int elemtype;
#define MAX 1000
#define ERROR 1e8
//从PTA题中学到的站的数据类型定义
struct LNode2
{
elemtype* data;//存数组空间的地址(需要自己开辟空间)
int MaxSize;//存数组最大容量
int top;//存栈顶元素的数组下标
};
//最基础的栈的数据类型
struct LNode1
{
elemtype data[MAX];//存数据
int MaxSize;//存数组最大容量
int top;//存栈顶元素的数组下标
};
struct LNode1* Init_SequenStack1(int MaxSize);//struct LNode1类型的创建
struct LNode2* Init_SequenStack2(int MaxSize);//struct LNode2类型的创建
int SequenStack_Empty(struct LNode1* s);//判空函数
int SequenStack_Full(struct LNode1* s);//判满函数
int SequenStack_Length(struct LNode1* s);//判满函数
int SequenStack_Push(struct LNode1* s,int X);//入栈函数
int SequenStack_Pop(struct LNode1* s);//出栈函数
int main()
{
int MaxSize;
scanf("%d", &MaxSize);
struct LNode1* s1 = Init_SequenStack1(MaxSize);
int len = SequenStack_Length(s1);
int X;
scanf("%d", &X);
if (SequenStack_Push(s1,X))
{
printf("入栈成功\n");
}
else
{
printf("入栈失败\n");
}
int ret = SequenStack_Pop(s1);
if (ERROR == ret)
{
printf("出栈失败\n");
}
else
{
printf("%d出栈成功",ret);
}
return 0;
}
int SequenStack_Pop(struct LNode1* s)//出栈函数
{
int flag = SequenStack_Empty(s);
if (flag == ERROR)
{
return 0;
}
else
{
return s->data[s->top--];
}
}
int SequenStack_Push(struct LNode1* s,int X)//入栈函数
{
int ret = SequenStack_Full(s);
if (ret == 0)//入栈失败
{
return 0;
}
else
{
s->data[++s->top] = X;
return 1;
}
}
int SequenStack_Length(struct LNode1* s)//长度函数
{
return s->top + 1;
}
int SequenStack_Full(struct LNode1* s)//判满函数
{
if (s->top == s->MaxSize - 1)
{
printf("栈满\n");
return 0;
}
return 1;
}
int SequenStack_Empty(struct LNode1* s)
{
if (s->top == -1)//判断栈顶指针的值，为-1，返回0；不为-1，返回1
{
printf("栈空\n");
return ERROR;
}
return 1;
}
struct LNode1* Init_SequenStack1(int MaxSize)
{
struct LNode1* s = (struct LNode1*)malloc(sizeof(struct LNode1));
s->top = -1;
s->MaxSize = MaxSize;
return s;
}
struct LNode2* Init_SequenStack2(int MaxSize)
{
struct LNode2* s = (struct LNode2*)malloc(sizeof(struct LNode2));
s->data = (elemtype*)malloc(sizeof(elemtype));
s->top = -1;
s->MaxSize = MaxSize;
return s;
}Merci pour votre aide! ! !