Hola a todos, mucho tiempo sin vernos! ! ! ¡Realmente lo extraño! ! !
Ha pasado mucho tiempo desde que actualizamos nuestra estructura de datos y la columna de algoritmos. Xiao Yalan ha aprendido mucho recientemente y no puedo esperar para compartirlo con mis amigos en la estación C. Ahora, entremos en el mundo de las pilas.
la pila
El concepto y la estructura de la pila.
Pila: una lista lineal especial que solo permite la inserción y eliminación de elementos en un extremo fijo.
El extremo donde se realizan las operaciones de inserción y eliminación de datos se denomina parte superior de la pila, y el otro extremo se denomina parte inferior de la pila.
Los elementos de datos en la pila siguen el principio de LIFO (Last In First Out).
Push stack: la operación de inserción de la pila se llama push/push/push, y los datos entrantes se encuentran en la parte superior de la pila.
Popping: La operación de eliminación de la pila se llama popping. Los datos de salida también están en la parte superior de la pila.
algunos ejercicios
1. El estado inicial de una pila está vacío. Ahora coloque los elementos 1, 2, 3, 4, 5, A, B, C, D y E en la pila en secuencia, y luego sáquelos en secuencia, luego el orden en que se extraen los elementos es ( B ).
A 12345 ABCDE
B EDCBA54321
ABCDE12345
D 54321EDCBA
2. Si la secuencia de inserción es 1, 2, 3, 4 y la pila se puede abrir durante el proceso de inserción, entonces la siguiente secuencia de inserción imposible es (C)
Un 1,4,3,2
B 2,3,4,1
C 3,1,4,2
D 3,4,2,1
Opción A: Avanzado 1, luego inmediatamente sale 1, luego entra 2 3 4, luego sale 4 3 2
Opción B: avanzado 1 2, luego sale 2, luego entra 3, sale 3, entra 4, sale 4 y finalmente sale 1
Opción C: No importa cómo ingrese y salga, tal combinación no aparecerá, porque: no hay dos números consecutivos
Opción D: avanzada 1 2 3, luego salida 3, luego entrada 4, salida 4, luego salida 2, finalmente salida 1
Implementación de la pila
La implementación de la pila generalmente se puede implementar usando una matriz o una lista enlazada.Relativamente hablando, la estructura de la matriz es mejor. Porque el costo de insertar datos al final de la matriz es relativamente pequeño.
A continuación, comenzamos a implementarlo con código:
typedef int STDataType; typedef struct Stack { STDataType* a; int top;//栈顶 int capacity;//容量 }Stack;Esto ya es una operación de rutina, usando estructuras y typedefs para definir una pila
Inicializar la pila:
// 初始化栈 void StackInit(Stack* pst) { assert(pst); pst->a = NULL; pst->top = 0; pst->capacity = 0; }
Destruye la pila:
// 销毁栈 void StackDestroy(Stack* pst) { assert(pst); free(pst->a); pst->a = NULL; pst->top = pst->capacity = 0; }
En la pila:
El operador ternario se usa aquí
https://xiaoyalan.blog.csdn.net/article/details/128941939
https://xiaoyalan.blog.csdn.net/article/details/128993533
Este es el punto de conocimiento relevante del operador escrito por Xiao Yalan. Si está interesado, puede echar un vistazo.
// 入栈 void StackPush(Stack* pst, STDataType x) { assert(pst); //扩容 if (pst->top == pst->capacity) { int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2; STDataType* tmp = (STDataType*)realloc(pst->a, newcapacity * sizeof(STDataType)); if (tmp == NULL) { perror("realloc fail"); return; } pst->a = tmp; pst->capacity = newcapacity; } pst->a[pst->top] = x; pst->top++; }
Compruebe si la pila está vacía:
// 检测栈是否为空 bool StackEmpty(Stack* pst) { assert(pst); if (pst->top == 0) { return true; } else { return false; } }Por supuesto, esta es una forma relativamente sencilla de escribir, echemos un vistazo a esta forma de escribir:
// 检测栈是否为空 bool StackEmpty(Stack* pst) { return pst->top==0; }Esta forma de escribir es tan concisa, y además da cuenta de las funciones que debe tener, ¿no sería mejor?
Estallido:
// 出栈 void StackPop(Stack* pst) { assert(pst); assert(!StackEmpty(pst)); pst->top--; }
Obtenga el elemento superior de la pila:
// 获取栈顶元素 STDataType StackTop(Stack* pst) { assert(pst); assert(!StackEmpty(pst)); return pst->a[pst->top - 1]; }
Obtenga el número de elementos válidos en la pila:
// 获取栈中有效元素个数 int StackSize(Stack* pst) { assert(pst); return pst->top; }
Stack (pila), también conocida como pila, es una tabla lineal con operaciones limitadas. Una lista lineal que restringe las inserciones y eliminaciones solo al final de la lista. Este extremo se llama la parte superior de la pila y el otro extremo se llama la parte inferior de la pila. Insertar un nuevo elemento en una pila también se denomina empujar, empujar o empujar. Consiste en colocar el nuevo elemento en la parte superior del elemento superior de la pila para convertirlo en un nuevo elemento superior de la pila; eliminar un elemento de una pila también se le llama apilar o apilar Desapilar, consiste en eliminar el elemento superior de la pila, de modo que el elemento adyacente se convierta en el nuevo elemento superior de la pila.
Para entender este concepto, primero debemos entender el significado original de "pila", para captar la esencia. Stack, un lugar de almacenamiento de mercancías o alojamiento para pasajeros, puede extenderse a almacenes y estaciones de transferencia, por lo que cuando se introduce en el ámbito informático, se refiere al lugar donde se almacenan temporalmente los datos, por lo que existe un dicho de ingreso y saliendo de la pila.
En primer lugar, leer e insertar (empujar) empujar y extraer el contenido de datos en el sistema o la pila de estructura de datos son dos cosas diferentes.Empujar es agregar datos y hacer estallar es eliminar datos.Estas operaciones solo se pueden realizar desde la parte superior de la pila, que es la dirección más baja, como la interfaz de interfaz de restricción, pero leer los datos en la pila es casual, y no no hay tal cosa como restricciones de interfaz. Muchas personas malinterpretan este concepto y, por lo tanto, se confunden con la pila. La pila del sistema también juega el papel de un área de medios de interacción de componentes cruzados en la arquitectura de la computadora, es decir, el canal de comunicación entre la CPU y la memoria.La CPU solo lee y ejecuta linealmente desde la entrada de la pila especificada por el sistema para nuestro propio programa de aplicación Instrucciones, usando una palabra vívida para describirlo es tubería (tubería, tubería). Para obtener detalles sobre la interacción interna de la CPU, consulte la introducción al concepto de UE y BIU.
Como estructura de datos, una pila es una tabla lineal especial que solo puede realizar operaciones de inserción y eliminación en un extremo. Almacena datos de acuerdo con el principio de último en entrar, primero en salir. Los datos que ingresan primero se empujan al final de la pila, y los últimos datos están en la parte superior de la pila. Cuando es necesario leer los datos, los datos se extrae de la parte superior de la pila (los últimos datos se leen primero). La pila tiene una función de memoria y no es necesario cambiar el puntero inferior de la pila durante las operaciones de inserción y eliminación de la pila.
Las pilas son listas lineales especiales que permiten la inserción y eliminación en el mismo extremo. El extremo que permite las operaciones de inserción y eliminación se denomina parte superior de la pila (top), y el otro extremo es la parte inferior de la pila (bottom); la parte inferior de la pila es fija , mientras que la parte superior de la pila es flotante ; cuando el número de elementos en la pila es cero, se llama pila vacía . La inserción generalmente se denomina push (PUSH) y la eliminación se denomina pop (POP). Una pila también se denomina lista de primeros en entrar, últimos en salir.
La pila se puede usar para almacenar puntos de interrupción cuando se llama a una función, y la pila se usa cuando se hace recursividad.Las definiciones anteriores son interpretaciones en informática clásica.
En un sistema informático, una pila es un área de memoria dinámica con las propiedades anteriores. Los programas pueden insertar datos en la pila o extraer datos de la parte superior de la pila. En las máquinas i386, la parte superior de la pila está ubicada en un registro llamado esp. La operación de empujar la pila reduce la dirección de la parte superior de la pila, y la operación de abrir aumenta la dirección de la parte superior de la pila.
La pila juega un papel importante en el funcionamiento del programa. Lo más importante es que la pila guarda la información de mantenimiento necesaria para una llamada de función, que a menudo se denomina marco de pila o registro activo. Un marco de pila generalmente contiene la siguiente información:
1. La dirección de retorno y los parámetros de la función
2. Variables temporales: incluidas variables locales no estáticas de funciones y otras variables temporales generadas automáticamente por el compilador.
Prueba la funcionalidad de este código:
void testStack1()
{
Stack st;
StackInit(&st);
StackPush(&st, 1);
StackPush(&st, 2);
StackPush(&st, 3);
StackPush(&st, 4);
printf("栈顶元素：%d\n", StackTop(&st));
printf("栈中元素个数：%d\n", StackSize(&st));
StackPop(&st);
printf("栈顶元素：%d\n", StackTop(&st));
StackPush(&st, 5);
StackPush(&st, 6);
while (!StackEmpty(&st))
{
printf("栈顶元素：%d\n", StackTop(&st));
StackPop(&st);
}
StackDestroy(&st);
}
int main()
{
testStack1();
return 0;
}
El código fuente es el siguiente:
Contenido de Stack.h:
#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>
typedef int STDataType;
typedef struct Stack
{
STDataType* a;
int top;//栈顶
int capacity;//容量
}Stack;
// 初始化栈
void StackInit(Stack* pst);
// 销毁栈
void StackDestroy(Stack* pst);
// 入栈
void StackPush(Stack* pst, STDataType x);
// 出栈
void StackPop(Stack* pst);
// 获取栈顶元素
STDataType StackTop(Stack* pst);
// 获取栈中有效元素个数
int StackSize(Stack* pst);
// 检测栈是否为空
bool StackEmpty(Stack* pst);
Contenido de Stack.c:
#include"Stack.h"
// 初始化栈
void StackInit(Stack* pst)
{
assert(pst);
pst->a = NULL;
pst->top = 0;
pst->capacity = 0;
}
// 销毁栈
void StackDestroy(Stack* pst)
{
assert(pst);
free(pst->a);
pst->a = NULL;
pst->top = pst->capacity = 0;
}
// 入栈
void StackPush(Stack* pst, STDataType x)
{
assert(pst);
//扩容
if (pst->top == pst->capacity)
{
int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
STDataType* tmp = (STDataType*)realloc(pst->a, newcapacity * sizeof(STDataType));
if (tmp == NULL)
{
perror("realloc fail");
return;
}
pst->a = tmp;
pst->capacity = newcapacity;
}
pst->a[pst->top] = x;
pst->top++;
}
// 检测栈是否为空
bool StackEmpty(Stack* pst)
{
assert(pst);
if (pst->top == 0)
{
return true;
}
else
{
return false;
}
//return pst->top==0;
}
// 出栈
void StackPop(Stack* pst)
{
assert(pst);
assert(!StackEmpty(pst));
pst->top--;
}
// 获取栈顶元素
STDataType StackTop(Stack* pst)
{
assert(pst);
assert(!StackEmpty(pst));
return pst->a[pst->top - 1];
}
// 获取栈中有效元素个数
int StackSize(Stack* pst)
{
assert(pst);
return pst->top;
}
Muy bien, este es el final del conocimiento de la pila compartido por Xiao Yalan hoy, ¡continuemos aprendiendo estructuras de datos y algoritmos! ! !
