Estructuras de Datos y Algoritmos (ocho) - Pila

                                                                montón

pila definida: (Stack) sólo en una forma lineal inserción o eliminación.

  S = (a1, a2, a3, a4, a5)

                                                                                                         -------------------------> empuje el último en salir fin

El funcionamiento básico de la pila: InitStack (& ​​S): inicializar una pila vacía S

                         StackEmpty (S): Analizar pila vacía;

Push (& S): empuje (push), si no se completa la pila S, x se unirá como el elemento superior de la tapa nueva pila, encima necesidad un cambio

Pop (& S): una pila (pop), si la pila no está vacía, entonces aparecerá el elemento superior, regresa con x, la parte superior de un movimiento hacia abajo

GetTop (S, y x): leer el elemento superior, con los no vacíos rendimientos elemento x superior puntiagudo.

almacenamiento secuencial pila estructura

#define MaxSize 50
tydef struct{
    ElemType data[MaxSize];    //栈的数据域
    int top;    //栈顶指针
}SqStack;

Pila de las condiciones vacío: requisitos de longitud de pila S.top =-1 MaxSize:: S.top == -1 (la posición inicial de la pila) la pila de las condiciones completo S.top + 1

A principios apilar el funcionamiento básico

void InitStack(SqStack &s){        //初始化
    S.top == -1;
}

bool StackEmpty(SqStack s){    //判空
    if(s.top == -1)
        return true;
    else
        return false;
}

bool Push(SqStack &s, ElemType x){    //进栈操作
    if(s.top == MaxSize-1)        //栈满溢出
        return false;
    s.data[++top] = x;        //插入到栈顶，同时栈顶指针上移
    return true;
}

bool Pop(SqStack &s, ElemType &x){
    if(s.top == -1)
        return false;
    x = s.data[top--];       //x获取栈顶元素，同时top指针下移
    return true;
}

bool GetTop(SqStack &s, ElemType &x){
    if(s.top == -1)
        return false;
    x=data[s.top];    
    return true;
}

pila compartido: la parte inferior dos pilas dispuestas en ambos extremos del espacio compartido, la posición inicial de top0 proporcionado en la parte superior de la pila de la pila 1, una posición 0 TOP1 inicial proporcionada en la parte superior de la pila de la parte inferior de pila de la pila son No. 1, el máximo espacio de almacenamiento para la mitad de la pila original, cuando chocan con el puntero puntero top0 TOP1, la pila completa.

juicio en vacío: 0 Pila: top == -1 1 pila: top = MaxSize-1 pila se llena: TOP1-top == 1;

Shared pila ventaja: complejidad del tiempo de almacenamiento es O (1), una alta utilización del espacio.

La pila de almacenamiento de cadena: el puntero de pila enlace pila a través de elementos de enlace internos

Top-> siguientes puntos al elemento superior

typedef strcut LinkNode{      //定义链栈的结点
    ElemType data;
    struct LinkNode *next;
}LinkedStackNode,*LinkedStack；

typedef struct LStack{
    LinkedStackNode base;    //定义栈底指针
    LinkedStackNode top;     //定义栈顶指针
}LStack；

Todas las operaciones se llevan a cabo en el encabezado pila enlace (parte superior de la pila). top -> siguiente

El funcionamiento básico de la pila enlace:

LinkedStack Init_LinkedStack(){    //初始化链栈，为空栈
     //根据top指针的移动动态分配结点空间
    LinkedStack top = (LinkedStackNode *)malloc(sizeof(Node));   
    if(top ! = NULL)
        top ->next = null;   //开始为栈顶，指向空、
    return top;
}    

bool LinkeStack_Empty(LinkedStack top){    //判空
    if(top->next == null){
        return true;
    }else
        return false;
}

//入栈：将元素x插入链栈栈顶，设置头结点指针域指向新插入位置的，设置为栈顶元素
bool Push_LinkedStack (LinkedStack top ,ElemType x){
    LinkedStackNode *node = (LinkedStackNode)malloc (sizeof(LinkedStackNode));
    if(node == null)
        return false;
    else{
        node->data = x;
        node->next = top->next;   //设置为栈顶
        top ->next = node;    //原栈顶指向新结点 
    return true;
    }
}

//出栈：删除栈顶数据元素，通过x返回被删元素的数据值，设置top指向链栈中的下一个元素
int Pop_LinkedStack(LinkedStack top, ElemType &x){
    LinkedStackNode *node;       //不用分配空间，已存在目标结点
    if(top -> next == null){
        return 0;
    }else{
        node = top->next;    //找到栈顶结点
        *x = node->data;
        top->next = node->next;    //被删元素的指向赋值给top;
        free(node);        //释放结点空间
        return x;
    }
}

//读取栈顶元素
int Get_LinkedStack(LinkedStack top, ElemType &x){
    if(top->next == null)
        return 0;
    else{
        x = top->next->data;    //栈顶元素的数据域赋值给x
        return 1; 
    }
}