栈的概念和顺序栈实现

栈

一，基本概念

可以看做是 只能在一端进行插入或者删除 的线性表

重要术语：栈顶，栈底，空栈。

特点：后进先出。插入，删除只能操作在栈顶的元素

二，实现与存储（静态顺序数组结构）

1）定义与初始化

#define MaxSize 10   //定义栈中元素的最大值

//初始化栈
void InitStack(SqStack& S) {
    S.top = -1;
}
//声明一个栈
void testStack() {
    SqStack S;  //声明一个顺序栈
    InitStack(S);

}

 

 2）插入，删除，读取

//新元素入栈
bool Push(SqStack& S, int x) {  //在栈S中插入一个新元素 x
    if (S.top == MaxSize - 1) {   //栈满，报错
        return false;
    }
    S.top = S.top + 1;
    S.data[S.top] = x;
    return true;
}

//出栈操作
bool Pop(SqStack& S, int& x) {   
    if (S.top == -1) {
        return false;      //栈空，报错
    }
    x = S.data[S.top];    
    S.top = S.top - 1;
    return true;
    //数据仍然残留在内存中，只是逻辑上被删除了。
}
//读取栈顶元素
bool GetTop(SqStack& S, int x) {  //
    if (S.top == - 1) {
        return false;
    }
    x = S.data[S.top];
    return true;
}

 

*共享栈

三，栈的链式存储结构

本质上是一个单链表，但增删查只在第一个结点进行。

基本操作

 

#include <stdlib.h>
typedef struct LNode {
    int data;              //数据域
    struct LNode* next;    //指针域
}LNode ,* LinkList;

//初始化链表
bool InitList(LinkList& L) {
    
    L = (LinkList)malloc(sizeof(LNode)); //动态分配
    if (L == NULL) {
        return false;
    }
    L->next = NULL;      //头指针为空
    return true;
}
void test() {
    LinkList L;    //声明一个链表
    InitList(L);   //初始化一个链表
}

//判断表空
bool Judge(LinkList &L) {
    if (L->next == NULL) {
        return true;
    }
    else {
        return false;
    }
}

 

//插入操作。
bool Increase(LinkList &L,int e) {   //在链表中插入一个新元素e
    LNode* s = (LNode*)malloc(sizeof(LNode));   //创建一个新的结点
    
    s->data = e;
    s->next = L->next;
    L->next = s;

    return true;
}  
bool Delete(LinkList &L,int e)  {     //在链表中删除一个元素
    if (Judge(L)) {
        return false;
    }
    //创一个新的结点q
    LNode* q;
    q = L->next;
    L->next = q->next;
    e = q->data;
    free(q);
    return true;
}
//查找
int  Find(LinkList& L) {
    if (Judge(L)) {
        return false;
    }
    else
    {
        return L->next->data;
    }
}