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
Definición de interfaz de función
Ejemplo de procedimiento de prueba de árbitro
I. Introducción
Cuando estaba escribiendo la tarea de la PTA que me dio el maestro hoy, me encontré con una pila muy diferente. Pensé que debería escribirla para que todos puedan brillar, expandir sus horizontes y también brindarme una comprensión más profunda.
2. Título
Requerir
Esta pregunta requiere implementar dos pilas en una matriz.
Definición de interfaz de función:
Stack CreateStack( int MaxSize ); //栈的创建 bool Push( Stack S, ElementType X, int Tag );//入栈 ElementType Pop( Stack S, int Tag );//出栈donde
Tagestá el número de pila, que es 1 o 2,MaxSizeel tamaño de la matriz de pila;
StackLa estructura se define de la siguiente manera:typedef int Position; struct SNode { ElementType *Data; Position Top1, Top2; int MaxSize; }; typedef struct SNode *Stack;Nota: Si la pila está llena,
Pushla función debe generar "Pila llena" y devolver falso; si una pila está vacía, la funciónPopdebe generar "Etiqueta de pila vacía" (donde Etiqueta es el número de la pila) y devolver ERROR.
Ejemplo de procedimiento de prueba de árbitro
#include <stdio.h> #include <stdlib.h> #define ERROR 1e8 typedef int ElementType; typedef enum { push, pop, end } Operation; typedef enum { false, true } bool; typedef int Position; struct SNode { ElementType *Data; Position Top1, Top2; int MaxSize; }; typedef struct SNode *Stack; Stack CreateStack( int MaxSize );//栈的创建 bool Push( Stack S, ElementType X, int Tag );//入栈 ElementType Pop( Stack S, int Tag );//出栈 Operation GetOp(); /* details omitted *///操作 void PrintStack( Stack S, int Tag ); /* details omitted *///打印 int main() { int N, Tag, X; Stack S; int done = 0; scanf("%d", &N); S = CreateStack(N); while ( !done ) { switch( GetOp() ) { case push: scanf("%d %d", &Tag, &X); if (!Push(S, X, Tag)) printf("Stack %d is Full!\n", Tag); break; case pop: scanf("%d", &Tag); X = Pop(S, Tag); if ( X==ERROR ) printf("Stack %d is Empty!\n", Tag); break; case end: PrintStack(S, 1); PrintStack(S, 2); done = 1; break; } } return 0; } /* 你的代码将被嵌在这里 */
Muestra de entrada
5 Push 1 1 Pop 2 Push 2 11 Push 1 2 Push 2 12 Pop 1 Push 2 13 Push 2 14 Push 1 3 Pop 2 End
Muestra de salida
Stack 2 Empty Stack 2 is Empty! Stack Full Stack 1 is Full! Pop from Stack 1: 1 Pop from Stack 2: 13 12 11
3. Análisis
Antes de escribir, debemos comprender qué significa implementar dos pilas en una matriz. La pila es fácil de entender, es una forma especial de tabla lineal.
La pila, a diferencia de una tabla de secuencia normal que puede completar operaciones de agregar, eliminar, modificar y verificar, solo puede realizar operaciones de inserción y extracción. Aunque hay menos formas de operaciones, la pila también tiene sus propias ventajas: la complejidad temporal de empujar y hacer estallar la pila es O (1) , que es mucho más rápida que la tabla de secuencia normal.
1.Características de la pila
1. El último en entrar, el primero en salir 2. La complejidad temporal de empujar y hacer estallar en la pila es O(1)
El tipo de datos general de la pila es:
#define MaxSize 1000
typedef int elemtype;
struct LNode
{
elemtype data[MaxSize];
int top;栈顶指针，存储的是栈顶上的下标
}2. Análisis de preguntas
Abra dos pilas basadas en una matriz mencionada en el título, como se muestra en la figura:
Las posiciones iniciales de los punteros superiores de la pila Top1 y Top2 son -1 y MaxSize respectivamente. La variable Tag en la pregunta almacena el número de pila. Cuando Tag==1, se refiere a la pila con el puntero superior Top1; cuando Tag==2, se refiere a la pila con el puntero superior Top2.
La pila con Top1 como puntero superior es una pila normal, y la pila con Top2 como puntero superior es una pila invertida. Al empujar la pila, preste atención a que el puntero superior se mueva hacia la izquierda. Al abrir la pila, el El puntero superior se mueve hacia la izquierda y hacia la derecha.
Preste atención a las condiciones cuando la pila está llena: Top1 + 1 == Top2, como se muestra en la figura:
3. Creación de pila
typedef int Position; struct SNode { ElementType *Data; Position Top1, Top2; int MaxSize; }; typedef struct SNode *Stack;Según el tipo de pila indicado en la pregunta: primero, se debe asignar espacio para el tipo de pila y espacio para el puntero Datos.
Luego debes asignar valores iniciales a dos variables diferentes en la parte superior de la pila. No olvide que a la variable MaxSize en el tipo de pila también se le debe asignar un valor inicial.
Stack CreateStack(int MaxSize) { Stack s = (Stack)malloc(sizeof(struct SNode)); s->Data = (int*)malloc(sizeof(ElementType) * MaxSize); s->Top1 = - 1; s->Top2 = MaxSize; s->MaxSize = MaxSize; return s; }
4. Empuje hacia la pila
Antes de empujar la pila, primero debe determinar si la pila está llena. De acuerdo con la explicación anterior, se puede ver que S->Top1+1 == S->Top2. Si no está lleno, determine si el puntero superior de la pila es Top1 o Top2 según la etiqueta. Finalmente, comience con el puntero superior Top1++ o Top2--; luego asigne el valor inicial.
bool Push(Stack S, ElementType X, int Tag) { if (S->Top1+1 == S->Top2) { printf("Stack Full\n"); return false; } if (Tag == 1) { S->Top1++; S->Data[S->Top1] = X; } if(Tag==2) { S->Top2--; S->Data[S->Top2] = X; } return true; }
5. Salir
Lo mismo ocurre con la extracción de la pila. Primero determine si la pila está vacía, si no, utilice el puntero superior Top1--o Top2++.
ElementType Pop(Stack S, int Tag) { if (Tag == 1) { if (S->Top1 == -1) { printf("Stack %d Empty\n", Tag); return ERROR; } return S->Data[S->Top1--]; } if (Tag == 2) { if (S->Top2 == S->MaxSize) { printf("Stack %d Empty\n", Tag); return ERROR; } return S->Data[S->Top2++]; } }
4. código total
Stack CreateStack(int MaxSize)
{
Stack s = (Stack)malloc(sizeof(struct SNode));
s->Data = (int*)malloc(sizeof(ElementType) * MaxSize);
s->Top1 = - 1;
s->Top2 = MaxSize;
s->MaxSize = MaxSize;
return s;
}
bool Push(Stack S, ElementType X, int Tag)
{
if (S->Top1+1 == S->Top2)
{
printf("Stack Full\n");
return false;
}
if (Tag == 1)
{
S->Top1++;
S->Data[S->Top1-1] = X;
}
if(Tag==2)
{
S->Top2--;
S->Data[S->Top2+1] = X;
}
return true;
}
ElementType Pop(Stack S, int Tag)
{
if (Tag == 1)
{
if (S->Top1 == -1)
{
printf("Stack %d Empty\n", Tag);
return ERROR;
}
return S->Data[S->Top1--];
}
if (Tag == 2)
{
if (S->Top2 == S->MaxSize)
{
printf("Stack %d Empty\n", Tag);
return ERROR;
}
return S->Data[S->Top2++];
}
}
¡gracias por su apoyo!