1 O conceito básico da pilha
A pilha é uma mesa especial que apenas insere e apaga na ponta da mesa. Portanto, o cabeçalho da mesa tem um significado especial para a pilha, que é chamado de topo da pilha. O fim da mesa é chamado de parte inferior da pilha. Uma pilha que não contém nenhum elemento é chamada de pilha vazia.
Assumindo que os elementos em uma pilha S são a (n), a (n-1), ..., a (1), então a (1) é chamado de elemento inferior da pilha, e a (n) é o elemento superior da pilha. Os elementos da pilha são colocados na pilha na ordem de a (1), a (2), ..., a (n). A qualquer momento, o elemento retirado da pilha é o elemento do topo da pilha . Em outras palavras, a modificação da pilha é realizada com base no princípio do último a entrar, primeiro a sair. Portanto, a pilha também é chamada de tabela Último a Entrar, Primeiro a Sair (Último a Entrar, Primeiro a Sair), ou tabela LIFO, abreviadamente .
A pilha também é um tipo de dado abstrato. As operações de pilha comumente usadas são as seguintes.
(1) StackEmpty (S): Teste se a pilha S está vazia.
(2) StackFull (S): Teste se a pilha S está cheia.
(3) StackTop (S): Retorna o elemento do topo da pilha S.
(4) Empurrar (x, S): Insira o elemento x no topo da pilha S, que é referido como empurrar o elemento x na pilha.
(5) Pop (S): exclui e retorna o elemento do topo da pilha S, conhecido como stack pop.
A aplicação da pilha é muito ampla, desde que o problema satisfaça o princípio LIFO, a pilha pode ser usada.
2 Use uma matriz para implementar uma pilha
Quando uma matriz de dados é usada para armazenar elementos da pilha, a parte inferior da pilha é fixada na parte inferior da matriz, ou seja, dados [0] é o primeiro elemento a ser colocado na pilha, e a pilha é expandida para o topo da matriz (na direção de aumentar o subscrito).
2.1 Estrutura de pilha implementada com array
A pilha é definida da seguinte maneira.
typedef struct astack *Stack;//栈指针类型
typedef struct astack;//栈结构
int top,//栈顶
maxtop;//栈空间上界
StackItem *data;//存储栈元素的数组
}Sstack;
O elemento da pilha é armazenado nos dados da matriz, com o topo apontando para a posição atual do topo da pilha, o elemento do topo da pilha é armazenado nos dados [topo] e a capacidade da pilha é maxtop.
2.2 Definição de tipo de elementos da pilha
Defina o tipo de elemento da pilha como int.
typedef int StackItem;//栈元素类型int
typedef StackItem *addr;//栈元素指针类型
2.3 Função StackInit (tamanho)
Crie uma pilha vazia com capacidade de tamanho.
Stack StackInit(int size)
{
Stack S=(Stack)malloc(sizeof *S);
S->data=(StackItem *)malloc(size*sizeof(StackItem));
S->maxtop=size;
S->top=-1;
return S;
}
2.4 Função StackEmpty (S)
Quando top = -1, a pilha atual está vazia.
int StackEmpty(Stack S)
{
return S->top<0;
}
2.5 Função StackFull (S)
Quando top = maxtop, a pilha atual está cheia.
int StackFull(Stack S)
{
return S->top>=S->maxtop;
}
2.6 Função StackTop (S)
O elemento do topo da pilha é armazenado em dados [topo].
StackItem StackTop(Stack S)
{
//前提栈为非空
if(StackEmpty(S)) exit(1);
return S->data[S->top];
}
2.7 Função Push (x, S)
O novo elemento superior x deve ser armazenado em dados [top + 1].
void Push(StackItem x,Stack S)
{
//前提栈未满
if(StackFull(S)) exit(1);
S->data[++S->top]=x;
}
2.8 Função Pop (S)
Depois de excluir o elemento do topo da pilha, o novo elemento do topo da pilha está nos dados [top-1].
StackItem Pop(Stack S)
{
//栈为非空
if(StackEmpty(S)) exit(1);
return S->data[S->top--];
}
2.9 Função StackFree (S)
Uma vez que os dados da matriz são alocados dinamicamente, StackFree deve liberar o espaço alocado para os dados no final do uso para evitar vazamentos de memória.
void StackFree(Stack S)
{
free(S->data);
free(S);
}
2.10 Usando várias pilhas
Ao usar pilhas em alguns algoritmos, geralmente é necessário usar várias pilhas ao mesmo tempo. Para evitar que cada pilha transborde durante a execução do algoritmo, um espaço de pilha maior é geralmente predefinido para cada pilha. Mas não é fácil fazer isso, porque o espaço máximo realmente usado por cada pilha no processo de operação do algoritmo é difícil de estimar . Por outro lado, o tamanho real de cada pilha muda constantemente durante a operação do algoritmo , e muitas vezes acontece que uma pilha está cheia e a outra vazia.
] Suponha que as duas pilhas no programa compartilhem uma matriz de dados [0: n]. Usando o recurso de que a posição inferior da pilha permanece inalterada, a parte inferior das duas pilhas pode ser definida nas duas extremidades dos dados da matriz e, em seguida, cada uma se estende em direção ao meio dos dados da matriz. Os valores iniciais dos topos das duas pilhas são 0 en respectivamente, e o estouro pode ocorrer quando os topos das duas pilhas se encontram. Uma vez que as duas pilhas podem se complementar, o espaço máximo real disponível para cada pilha costuma ser maior que n / 2.
Duas pilhas compartilhando o mesmo espaço de array
3 Implementar a pilha com ponteiros
Um ponteiro é usado para implementar uma pilha, chamada de pilha em cadeia, conforme mostrado na figura abaixo.
3.1 A definição do tipo de nó da pilha de cadeia
typedef struct snode *slink;//栈结点指针类型
typedef struct snode{
//栈结构
StackItem element;//栈元素
slink next;//下一结点指针
}StackNode;
slink NewStackNode()
{
return (slink)malloc(sizeof(StackNode));
}
Seu elemento de membro de dados armazena elementos de pilha, o próximo é um ponteiro para o próximo nó e a função NewStackNode () cria um novo nó.
3.2 Chain stack Stack implementado com ponteiros
typedef struct lstack *Stack;//栈指针类型
typedef struct lstack{
//栈结构
slink top;//栈顶指针
}Lstack;
top é um ponteiro para o nó superior da pilha.
3.3 Função StackInit (tamanho)
A função StackInit () define top para um ponteiro nulo e cria uma pilha vazia.
Stack StackInit()
{
Stack S=(Stack)malloc(sizeof *S);
S->top=0;
return S;
}
3.4 Função StackEmpty (S)
Verifique se o ponteiro do topo ao topo da pilha é um ponteiro nulo.
int StackEmpty(Stack S)
{
return S->top==0;
}
3.5 Função StackTop (S)
Retorne o elemento no nó superior da pilha S.
StackItem StackTop(Stack S)
{
//前提栈为非空
if(StackEmpty(S)) exit(1);
return S->top->element;
}
3.6 Função Push (x, S)
A função Push (x, S) primeiro cria um novo nó para o elemento x, e então modifica o ponteiro do nó da pilha de S para tornar o novo nó o novo nó do topo da pilha.
void Push(StackItem x,Stack S)
{
slink p=NewStackNode();
p->element=x;
p->next=S->top;
S->top=p;
}
3.7 Função Pop (S)
A função Pop (S) primeiro armazena o elemento do topo de S em x, em seguida, modifica o ponteiro do topo da pilha para apontar para o próximo elemento do elemento do topo da pilha, excluindo assim o elemento do topo da pilha, e finalmente retorna x.
StackItem Pop(Stack S)
{
//前提栈非空
if(StackEmpty(S)) exit(1);
StackItem x=S->top->element;
slink p=S->top;
S->top=p->next;
free(p);
return x;
}