Página principal
Columna de tema --- estructura de datos
Estructura de datos_Todavía hay blogs desconocidos esperando ser explorados-Blog CSDN
Tabla de contenido
2. Operaciones básicas (pila --- estructura de almacenamiento secuencial)
1. Inicialización de pila secuencial.
1. El primer tipo de datos de la pila.
2. El segundo tipo de datos de la pila.
2. Determine si la pila está vacía (luego escriba con el primer tipo de datos)
3. Determina si la pila está llena.
4. Encuentra la longitud de la pila.
I. Introducción
La pila es una tabla lineal especial. Las operaciones básicas de la pila son empujar y hacer estallar, según el principio de último en entrar, primero en salir . La pila solo se puede insertar y eliminar en un extremo. Este extremo de operación se denomina elemento superior de la pila, y el otro extremo de la pila se denomina elemento inferior de la pila, y se utiliza un puntero en la parte superior de la pila para almacenar. el subíndice del elemento superior de la pila. Cuando no hay elementos en la pila, se le llama pila vacía.
2. Operaciones básicas (pila --- estructura de almacenamiento secuencial)
1. Inicialización de pila secuencial.
La inicialización de la pila secuencial consiste en construir una lista vacía.
El primer tipo de datos de pila no necesita abrir espacio para que la matriz almacene los datos. El segundo tipo abre espacio para la matriz en el montón y se asigna dinámicamente , lo que puede mejorar la utilización de la matriz.
1. El primer tipo de datos de la pila.
El tipo de pila más básico se escribe de la siguiente manera:
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. El segundo tipo de datos de la pila.
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. Determine si la pila está vacía (luego escriba con el primer tipo de datos)
Determine el valor del puntero superior de la pila. Si es -1, devuelve 0; si no es -1, devuelve 1.
int SequenStack_Empty(struct LNode1* s) { if (s->top == -1)//判断栈顶指针的值，为-1，返回0；不为-1，返回1 { printf("栈空\n"); return 0; } return 1; }
3. Determina si la pila está llena.
Determine el valor del puntero superior de la pila, que es MaxSize-1, y devuelva 0; de lo contrario, devuelva 1
int SequenStack_Full(struct LNode1* s)//判满函数 { if (s->top == s->MaxSize - 1) { printf("栈满\n"); return 0; } return 1; }
4. Encuentra la longitud de la pila.
int SequenStack_Length(struct LNode1* s)//长度函数 { return s->top + 1; }
5.Empuje hacia la pila
Primero, asegúrese de que la pila no esté llena, primero ++ el puntero superior de la pila y luego realice la operación de asignación.
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. Salir
Para asegurarse de que la pila no esté vacía primero, cambie el puntero superior de la pila a -- y luego realice la operación de asignación.
int SequenStack_Pop(struct LNode1* s)//出栈函数 { int flag = SequenStack_Empty(s); if (flag == ERROR) { return 0; } else { return s->data[s->top--]; } }
3. Ventajas
La complejidad temporal de todas las operaciones anteriores es O (1)
4. código 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;
}¡gracias por su apoyo! ! !