Tabla de contenido
1. Estructura de almacenamiento
4. Determinar si la pila está llena.
5. Determinar si la pila está vacía.
8. Obtén el elemento superior de la pila.
Prefacio
Hemos aprendido los métodos relacionados de la pila de matrices antes (enlace: tabla lineal ----- pila (inicialización, establecimiento, inserción, extracción, recorrido, limpieza y otras operaciones de la pila) _Blog de Helletade-Blog CSDN ) Así que hoy Comenzará a aprender una nueva pila estructural: pila encadenada. Como sugiere el nombre, las operaciones del método relacionado de la pila se implementan a través de la estructura de la lista vinculada, incluida la creación, juzgando si está vacía o llena, haciendo estallar la pila. , empujando hacia la pila, atravesando y limpiando, etc. ¡Echemos un vistazo a la operación a continuación!
pila de cadena
El diagrama es el siguiente:
Método de operación
#include<stdio.h>
#include<stdlib.h>
#define Maxsize 20 //设置最大节点数量
create_node(ElemType data);//创建节点
stack_init(Stack* top);//初始化
isFull(Stack* top);//判断是否满栈
isEmpty(Stack* top);//判断是否空栈
push(Stack* top, ElemType data);//入栈
pop(Stack* top);//入栈
get_stacktop(Stack* top);//获取栈顶元素
show_stack(Stack* top);//遍历栈
clear_stack(Stack* top);//清空栈
1. Estructura de almacenamiento
Lo que se implementa hoy es el almacenamiento en cadena de la pila, que comúnmente se conoce como "pila en cadena". Dado que antes se implementó una lista vinculada individualmente, el principio del almacenamiento vinculado de la pila es el mismo, pero la operación de la pila vinculada es limitada: ¡la inserción y eliminación solo se pueden realizar en la parte superior de la pila! Sin más preámbulos, echemos un vistazo a la estructura de almacenamiento de la pila de cadenas.
//数据类型
typedef struct datatype {
int age;
char name[10];
int num;
}ElemType;
//节点
typedef struct node {
ElemType data;
struct node* next;
}Node;
//栈顶指示
typedef struct stack {
int count; //计数
Node* point;
}Stack;2.Inicialización
Inicialice la posición señalada por el puntero principal en NULL y el recuento de nodos en 0.
//初始化
void stack_init(Stack* top) {
top->count = 0;
top->point = NULL;
}3. Crear nodos
Para crear un nodo, cree el nodo a través de una lista vinculada y luego asigne el valor de los datos al nodo.
//创建节点
Node* create_node(ElemType data) {
Node* new_node = (Node*)malloc(sizeof(Node));
if (new_node) {
new_node->data = data;
new_node->next = NULL;
return new_node;
}
else
{
printf("ERROR\n");
}
}4. Determinar si la pila está llena.
Para determinar si la pila está llena, solo necesita verificar si el recuento alcanza el número máximo de nodos en este momento.
//判断是否满
int isFull(Stack* top) {
if (top->count > Maxsize) {
printf("The stack is full\n");
return 1;
}
return 0;
}5. Determinar si la pila está vacía.
En este momento, solo necesita verificar si el recuento es 0.
//判断是否为空
int isEmpty(Stack* top) {
if (top->count == 0) {
printf("The stack is empty\n");
return 1;
}
return 0;
}6.Empuje hacia la pila
La operación de empujar a la pila es similar a la operación de encadenamiento de una lista enlazada, es decir, simplemente conecta los nodos creados, la diferencia es que cada vez que se coloca un nodo, el puntero superior en la parte superior de la pila se moverá hasta la parte superior de la pila. Al moverse, el recuento también debe ser +1. El código es el siguiente:
//入栈
void push(Stack* top, ElemType data) {
Node* new_node = create_node(data);
if (new_node&&!isFull(top)) {
top->count++;
if (top->count == 1) {//如果入栈是第一个节点的话
top->point = new_node;
}
else
{
//以下两个步骤不能调过来！
new_node->next = top->point;
top->point = new_node;
}
}
else
return;
}7. Salir
Al abrir la pila, primero obtenga la posición pop_node señalada por el puntero superior de la pila en este momento, luego mueva el puntero superior de la pila hacia abajo en uno, disminuya el recuento en uno y luego devuelva el elemento pop_node:
//出栈
Node* pop(Stack* top) {
Node* pop_node=NULL;
if (!isEmpty(top)) {
pop_node = top->point;
top->point = pop_node->next;
pop_node->next = NULL;
top->count--;
}
return pop_node;
}8. Obtén el elemento superior de la pila.
Para obtener el elemento superior de la pila, no es necesario extraerlo, solo necesita devolver el elemento superior de la pila:
//获取栈顶元素
Node* get_stacktop(Stack* top) {
return top->point;
}9. Atraviesa la pila
Recorra la pila, comenzando desde la parte superior de la pila y atravesando los datos de salida hacia abajo:
//遍历栈
void show_stack(Stack* top) {
Node* cur = top->point;
while (cur) {
printf("%d %s %d\n", cur->data.age, cur->data.name, cur->data.num);
cur = cur->next;
}
printf("Print over!\n");
}10. Limpiar la pila
Para borrar la pila, debe liberar el espacio de cada nodo por turno y luego mover la parte superior de la pila hacia abajo hasta que se mueva a la posición original.
//清空栈
void clear_stack(Stack* top) {
Node* cur;
while (top->point) {
cur = top->point;
top->point = cur->next;
free(cur);
}
printf("Clear successfully!\n");
}código completo
#include<stdio.h>
#include<stdlib.h>
#define Maxsize 20 //设置最大节点数量
//链表栈
//数据类型
typedef struct datatype {
int age;
char name[10];
int num;
}ElemType;
//节点
typedef struct node {
ElemType data;
struct node* next;
}Node;
//栈顶指示
typedef struct stack {
int count; //计数
Node* point;
}Stack;
//创建节点
Node* create_node(ElemType data) {
Node* new_node = (Node*)malloc(sizeof(Node));
if (new_node) {
new_node->data = data;
new_node->next = NULL;
return new_node;
}
else
{
printf("ERROR\n");
}
}
//初始化
void stack_init(Stack* top) {
top->count = 0;
top->point = NULL;
}
//判断是否满
int isFull(Stack* top) {
if (top->count > Maxsize) {
printf("The stack is full\n");
return 1;
}
return 0;
}
//判断是否为空
int isEmpty(Stack* top) {
if (top->count == 0) {
printf("The stack is empty\n");
return 1;
}
return 0;
}
//入栈
void push(Stack* top, ElemType data) {
Node* new_node = create_node(data);
if (new_node&&!isFull(top)) {
top->count++;
if (top->count == 1) {//如果入栈是第一个节点的话
top->point = new_node;
}
else
{
new_node->next = top->point;
top->point = new_node;
}
}
else
return;
}
//出栈
Node* pop(Stack* top) {
Node* pop_node=NULL;
if (!isEmpty(top)) {
pop_node = top->point;
top->point = pop_node->next;
pop_node->next = NULL;
top->count--;
}
return pop_node;
}
//获取栈顶元素
Node* get_stacktop(Stack* top) {
return top->point;
}
//遍历栈
void show_stack(Stack* top) {
Node* cur = top->point;
while (cur) {
printf("%d %s %d\n", cur->data.age, cur->data.name, cur->data.num);
cur = cur->next;
}
printf("Print over!\n");
}
//清空栈
void clear_stack(Stack* top) {
Node* cur;
while (top->point) {
cur = top->point;
top->point = cur->next;
free(cur);
}
printf("Clear successfully!\n");
}
int main() {
Stack top;
stack_init(&top);//初始化
ElemType data[4] = { {15,"Jack",01},{16,"Leimu",02},{17,"Lamu",03},{18,"Ajx",04} };
for (int i = 0; i < 4; i++) {
push(&top, data[i]);//入栈操作
}
show_stack(&top);//遍历栈
Node* out_data=pop(&top);//出栈操作
printf("%d %s %d\n", out_data->data.age, out_data->data.name, out_data->data.num);
clear_stack(&top);//清空栈
}
Lo anterior es el contenido de este número. Si te gusta, ¡síguelo! ¡Hasta la próxima!