Pila de estructura de datos de Big Talk
Definición de pila
Una pila es una tabla lineal que solo se inserta y elimina al final de la tabla. Un extremo que permite la inserción y eliminación se llama la parte superior de la pila y el otro extremo se llama la parte inferior de la pila.
- La pila también se denomina tabla lineal de último en entrar, primero en salir, denominada estructura LIFO
- La operación de inserción de la pila es empujar y empujar dentro de la pila; la operación de eliminación de la pila está apareciendo
typedef int SElemType; /*SElemType类型根据实际情况而定，这里假设为int*/
typedef struct
{
SElemType data[MAXSIZE];
int top; /*空栈top=-1，栈满etc*/
}SqStack;
Estructura de almacenamiento secuencial de la pila.
/*进栈操作 插入元素e为新的栈顶元素*/
Status Push(SqStack *S,SElemType e)
{
if(S->top == MAXSIZE -1) /*栈满*/
{
return ERROR;
}
S->top++; /*栈顶指针增加一*/
S->data[S->top] = e; /*将新插入元素赋值给栈顶空间*/
return OK;
}
/*出栈操作：若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR*/
Status Pop(SqStack *S,SElemType *e)
{
if(S->top == -1)
return ERROR;
*e=S->data[S->top]; /*将要删除的栈顶元素赋值给e*/
S->top--; /*栈顶指针减一*/
return OK;
}
Espacio compartido de dos pilas: use una matriz para almacenar dos pilas
- Técnicas de diseño para el mismo tipo de pila
- top1 + 1 == top2 (pila llena); la pila 1 está vacía, top2 = 0, la pila 2 está llena; la pila 2 está vacía, la parte superior1 de la pila 1 es n-1 y la pila 1 está llena.
/*两栈共享空间结构*/
typedef struct
{
SElemType data[MAXSIZE];
int top1; /*栈1栈顶指针*/
int top2; /*栈2栈顶指针*/
}SqDoubleStack;
Status Push(SqDoubleStack *S,SElemType e, int stacklNumber)
{
if(S->top1+1==S->top2) /*栈满*/
return ERROR;
/* ****自增、自减
* ++i/--i， i自增/减1后再参与其他的运算；i++/i--，i参与运算后，i的值域再自增/减1*/
if(stacklNumber==1) /*若栈1有元素进栈*/
S->data[++S->top1] = e; /*若栈1给top1+1后给数组元素赋值*/
else if (stacklNumber ==2)/*若栈2有元素进栈*/
S->data[--S->top2]=e; /*若栈2给top2-1后给数组元素赋值*/
return OK;
}
/*若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR*/
Status Pop(SqDoubleStack *S,SElemType *e, int stackNumber)
{
if (stackNumber == 1) {
if (S->top1 == -1) /*空栈，溢出*/
return ERROR;
*e = S->data[S->top1--]; /*栈1的栈顶元素出栈*/
}
if (stackNumber == 2)
{
if(S->top2==MAXSIZE) /*空栈，溢出*/
return ERROR;
*e = S->data[S->top2++]; /*栈2的栈顶元素出栈*/
// data[s--]等价于data[s]；s--；
// data[++s]等价于++s；data[s]；
// data[++s],++s入栈；先取出data[s]，s--会删除栈顶的元素
}
}
La estructura de almacenamiento en cadena y la implementación de la pila.
- La lista enlazada individualmente tiene un puntero principal, y el puntero superior de la pila también es necesario, así que coloque la parte superior de la pila al principio de la lista enlazada individualmente (nodo principal -> parte superior de la pila)
- La pila de la cadena básicamente no existe cuando la pila está llena; para una pila vacía, la lista vinculada originalmente definió el puntero principal para apuntar a vacío, entonces el vacío de la pila de la cadena es top = NULL
typedef struct StackNode
{
ElemType data;
struct StackNode *next;
}StackNode, *LinkStackPtr;
typedef struct LinkStack
{
LinkStackPtr top;
int count
}LinkStack;
/*
进栈操作：单链表有头指针，而栈顶指针也是必须的，因此把栈顶放在单链表的头部（头结点->栈顶）：相当于头插法；插入新元素e为新的栈顶元素
*/
Status Push(LinkStack *S,SElemType e)
{
LinkStackPtr s=(LinkStackPtr) malloc(sizeof(StackNode)); /*声明新结点*/
s->data = e;
s->next = S->top; /*把当前的栈顶元素赋值给新结点的直接后继*/
S->top = s; /*将新的结点s赋值给栈顶指针*/
S->count++;
return OK;
}
/*出栈操作：用p存储被删除的栈顶结点，将栈顶指针下移一位，最后释放p*/
#include <stdbool.h>
bool StackEmpty(LinkStack S)
{
if(S.top ==NULL) /*如果是空栈，则top为*/
return TRUE;
}
Status Pop(LinkStack *S,SElemType *e)
{
LinkStackPtr p;
if (StackEmpty(*S))
return ERROR;
*e = S->top->data;
p = S->top;
S->top = S->top->next;
free(p);
S->count--;
return OK;
}
Aplicación de pila
- La recursividad, una función que se llama a sí misma directamente o indirectamente a través de una serie de instrucciones de llamada se denomina función recursiva. Preste atención a la definición del comando condicional que no cumple con la salida cuando se realiza la llamada
. etapa, para cada capa de recursividad, la función Las variables locales, los valores de los parámetros y las direcciones de retorno de la se insertarán en la pila.
b. En la fase de retirada, aparecen las variables locales, los valores de los parámetros y la dirección de retorno en la parte superior de la pila, que se utilizan para volver al resto del código ejecutado en la jerarquía de llamadas y restaurar el estado de la llamada. - Las cuatro expresiones regulares se evalúan
a. La expresión entre paréntesis va de izquierda a derecha, la pila va de vacío al elemento y finalmente se convierte en una pila vacía después de que todas las coincidencias tienen éxito
. B. Expresión de sufijo y expresión de infijo (cuatro expresiones aritméticas estándar ))
cola
Cuando se pueda determinar la longitud máxima de la cola, se recomienda utilizar una cola circular; cuando no se pueda estimar la longitud de la cola, utilice una cola en cadena
- Tabla lineal que solo permite la operación de inserción en un extremo y la operación de eliminación en el otro extremo -> FIFO primero en entrar, primero en salir
- La cola se obtiene en base a la estructura de almacenamiento secuencial de la tabla lineal. Al salir de la cola, se deben mover todos. Los elementos de la cola deben almacenarse en las primeras n unidades del arreglo, y el rendimiento de la eliminación de la cola aumentará considerablemente .
- Para evitar que cuando solo hay un elemento, la cabeza y la cola del equipo se superpongan y causen problemas, use dos punteros al frente (señalar el elemento de la cabeza) y atrás (señalar al elemento de la cola)
3.1. Pregunta 1: Frente ( apuntar al elemento principal), posterior (apuntando al elemento al final de la cola), pero conducirá a la situación en la que el
final de la cola no tiene posición pero el jefe de la cola tiene una posición -> Utilice el estructura de almacenamiento secuencial de la cola de extremo a extremo, registrada como una cola circular
3.2. Pregunta 2: Para determinar si la cola está vacía, usamos front == rear, pero la condición también se cumple cuando la cola está llena
-> Método 1 : Establecer la variable de la bandera, cuando la bandera = 0, la cola está vacía; cuando la bandera = 1, la cola está llena
-> Método 2: Cuando la cola está llena, mantenga un elemento Espacio
a. Condición de la cola llena: (trasero + 1 )% QueueSize == front (la parte trasera puede estar en el lado derecho del frente o en el lado izquierdo del frente)
b. Longitud de la cola: (posterior-frontal + QueueSize)
Estructura de almacenamiento secuencial de cola circular
typedef int QElemType; //视情况而定
typedef struct
{
QElemType data[MAXSIZE];
int front; /*头指针*/
int rear; /*尾指针，若队列不空，指向队列元素的下一个位置*/
}SqQueue;
/*初始化一个空队列*/
Status InitQueue(SqQueue *Q)
{
Q->front= 0;
Q->rear=0;
return OK;
}
/*返回Q的元素个数，也就是队列的当前长度*/
int QueueLength(SqQueue Q)
{
return (Q.rear - Q.front+MAXSIZE)%MAXSIZE;
}
/*循环队列的入队列操作代码*/
Status EnQueue(SqQueue *Q,QElemType e) {
if ((Q->rear + 1) % MAXSIZE == Q->front) /*队列满的判断*/
return ERROR;
Q->data[Q->rear] = e; //将元素e赋值给队尾
Q->rear = (Q->rear + 1) % MAXSIZE; //rear指针向后移一个位置，在末尾则转到数组头部
}
/*循环队列的出队列操作代码*/
Status DeQueue(SqQueue *Q,QElemType *e)
{
if (Q->front == Q->rear)
return ERROR;
*e= Q->data[Q->front]; //将队头元素赋值给e
Q->front=(Q->front+1)%MAXSIZE; //front指针向后移一位置，若到最后转到数组头部
}
Cola de cadena
Lista de un solo enlace de tabla lineal, final de entrada y salida, estructura de almacenamiento en cadena y realización de la cola
typedef int QElemType;
typedef struct QNode
{
QElemType data;
struct QNode *next;
}QNode,*QueuePtr;
typedef struct //队列的链表结构
{
QueuePtr front,rear; //对头、队尾指针
}LinkQueue;
/*插入元素e为Q的新的队尾元素*/
#include <math.h>
Status EnQueue(LinkQueue *Q,QElemType e)
{
QueuePtr s = (QueuePtr) malloc(sizeof(QNode));
if (!s) //存储分配失败
exit(OVERFLOW);
s->data=e;
s->next=NULL;
Q->rear->next=s; //把拥有yuansue新结点s赋值为原队尾结点的后继
Q->rear=s; //把当前的s设置为队尾结点，rear指向s
return OK;
}
Status DeQueue(LinkQueue *Q,QElemType *e)
{
QueuePtr p;
if (Q->front == Q->rear)
return ERROR;
p= Q->front->next; //将要删除的队头结点暂存给p
*e = p->data; // 将要删除的队头结点的值赋值给*e
Q->front->next = p->next; //将原队头结点后继赋值给头结点后继
if (Q->rear == p)
Q->rear = Q->front; //若队头是队尾，则删除后将rear指向头结点（只有头结点和一个元素）
free(p);
return OK;
}