数据结构入门学习系列-7（栈的结构以及存储方式和算法）

本章来讲一下线性表的特殊结构之一：栈

栈是只能在表的一段进行插入和删除的线性结构，所有具有后进先出的特点。

栈顶：top端，允许插入删除，表尾。

栈尾：bottom端，固定端，表头。如下图所示：                                 

    

栈结构分为三种存储方式：动态数组存储，静态数组存储，链表存储

动态一维数组方式如下图：

1.用bottom表示栈底指针，bottom是不变的；top表示栈顶指针表示当前栈顶位置，进行出栈操作和入栈操作。

2.用top=bottom表示栈空，top每次指向栈顶的下一个存储位置。

3.进栈：首先将元素保存到top指向当前位置，然后top+1，指向下一个存储位置。

4.出栈：top-1，然后取出top位置的元素。

具体参照代码：

//stack动态数组存储
#define STACK_SIZE 100
#define STACKINCREMENT 10
typedef int ElemType;
typedef struct _SqStack{
  ElemType *top;
  ElemType *bottom;
  int stacksize;
}SqStack;

BOOL Init_Stack(void)
{
    SqStack S;
    S.bottom = (ElemType *)malloc(STACK_SIZE*sizeof(ElemType));
    if(!S.bottom)
        return FALSE;
    S.top = S.Bottom;
    S.stacksize = STACK_SIZE;
    return OK;
}

BOOL Stack_Push(SqStack S, ElemType e)
{
    if(S.top - S.bottom > STACK_SIZE-1) {
        S.bottom = (ElemType *)realloc((STACK_SIZE+STACKINCREMENT)*sizeof(ElemType));
        if(!S.bottom)
            return ERROR;
        S.top = S.bottom + S.stacksize;
        S.stacksize = STACKINCREMENT+STACK_SIZE;
    }
    *S.top = e;
    s.top++;
    return OK;
}

BOOL Stack_Pop(SqStack S, ElemType *e)
{
    if(S.top == S.bottom)
        return ERROR;
    S.top--;
    *e = *S.top;
    return OK;
}

静态一维数组存储方式：

1.栈底bottom保持不变，栈顶top使用一个int型变量指示当前的栈顶位置。

2.栈顶top=0表示栈空，top表示栈顶在数组中的存储位置

3.进栈：top+1指向新的位置，然后top中存储进栈元素

4.出栈：取出top中的元素，top-1

//stack的静态数组存储方式
#define MAX_STACK_SIZE 100
typedef int ElemType;
typedef struct _SqSize{
    ElemType stack_array[MAX_STACK_SIZE];
    int top;
}SqStack;
//栈的初始化
SqStack Init_Stack(void)
{
    SqStack S;
    S.top = 0;
    return S;
}
//栈的进栈
BOOL Stack_Push(SqStack S,ElemType e)
{
    if(S.top = MAX_STACK_SIZE-1)
        return FALSE;
    S.top++;
    S.stack_array[S.top] = e;
    return OK;
}
//栈的出栈
Bool Stack_Pop(SqStack S, ElemType *e)
{
    if(S.top = 0)
        return ERROR;
    *e=S.stack_array[S.top];
    S.top--;
    return OK;
}

链式存储方式：

该链表只能在链表的头部进行插入和删除的操作，链表头指针就是top指针。

//stack的链式存储
#typedef int ElemType;
typedef struct Stack_Node{
    ElemType data;
    struct Stack_Node *next;
}Stack_Node；
//初始化
Stack_Node *Init_stack(void)
{
    Stack_Node *top;
    top = (Stack_Node *)malloc(sizeof(Stack_Node));
    top->next = NULL;
    return top;
}
//压栈操作，push
BOOL push(Stack_Node *top, ElemType e)
{
    Stack_Node *p;
    p = (Stack_Node*)malloc(sizeof(Stack_Node));
    if(!p)
        return ERROR;
    p->next = top->next;
    top->next = p;
    return OK;
}
//出栈操作
BOOL pop(Stack_Node *top, ElemType *e)
{
    Stack_Node *p;
    if(top->next == NULL)
        return ERROR;
    p=top->next;
    p->data = *e;//取栈顶指数据
    p->next = top->next;//移动栈顶指针
    free(p);
    return OK;
}