【WIP_S4】栈

创建: 2018/01/15

更新: 2018/01/24 更改标题 [【WIP_S3】堆] => [【WIP_S4】堆]

继续添加内容

更新: 2018/05/13 更改标题  [【WIP_S4】堆] =>  [【WIP_S4】栈]

　　　　　　　　　　　　   所有[堆]替换成[栈]

 栈

 特点

一种数据结构

后入后处(LIFO)

放入: push

取出(最后一个): pop

 什么时候用栈

 后入后厨，就是新来的事务更重要，要先处理的情况

 栈的ADT

主要的栈运算	● push(int data) :插入栈
	● int pop() :获取最后的元素并从栈删除
辅助的栈运算	● int top() : 不取出，只是获取最后的元素
	● int size() : 获取栈内元素个数
	● int isEmptyStatck() ：是否为空
	● int isFullStatck() : 是否已满
例外	pop空栈 push满栈

 应用

● 记号的平衡？# TODO: check [p82意思]

● 中置式变换为后置式 # TODO: check [p82意思]

● (包含递归的)函数呼出的实现

● 跨度运算 # TODO: check [p82意思]

● 浏览器的访问历史(返回按钮)

● 文本编辑器的返回功能

● HTML和XML的标签匹配吧

 实现1

 纯数组实现

//------------------------------------------------
//                    型声明
//------------------------------------------------
#define PRO_STACK_SIZE_V1 100
struct arrayStack {
    int top; //开头的索引
    int capacity; // 容量
    int *array;
};
//------------------------------------------------
//                   函数声明
//------------------------------------------------
struct arrayStack *createStack(void);// 创建栈
int isEmptyStack(struct arrayStack *s); // 判断是否为空
int isFullStack(struct arrayStack *s);// 判断是否已满
void push(struct arrayStack *s, int data); // push
int pop(struct arrayStack *s); //pop
void deleteStack(struct arrayStack *s); // 删除栈
//------------------------------------------------
//
//
//------------------------------------------------
struct arrayStack *createStack() { // 创建栈
    struct arrayStack *s = (struct arrayStack *)malloc(sizeof(struct arrayStack));
    if (s == NULL) {
        puts("单纯数组版,栈初始化失败");
        return NULL;
    }
    s->capacity = PRO_STACK_SIZE_V1;
    s->top = -;
    s->array = malloc(s->capacity * sizeof(int));
    if (s->array == NULL) {
        puts("单纯数组版, 栈数据初始化失败");
        return NULL;
    }
    return s;
}

int isEmptyStack(struct arrayStack *s) { // 判断是否为空
    return (s->top == -); // 条件成立返回1(真), 不成立返回0(否)
}

int isFullStack(struct arrayStack *s) { // 判断是否已满
    return (s->top >= (s->capacity -));
}

void push(struct arrayStack *s, int data) { // push
    if (isFullStack(s)) {
        puts("栈已满");
        return;
    } else {
        s->array[++s->top] = data; //插入到最后一个的后面
    }
}

int pop(struct arrayStack *s) { //pop
    if (isEmptyStack(s)) {
        puts("栈为空");
        return ;
    }else {
        return s->array[s->top--]; // 返回最后一个并把top-1
    }
}

void deleteStack(struct arrayStack *s) { // 删除栈
    if (s) {
        if (s->array) {
            free(s->array);
        }
        free(s);
    }
}

 实现2

 动态数组实现

数组满了就换一个两倍长度的

//------------------------------------------------
//                    型声明
//------------------------------------------------
#define PRO_STACK_SIZE_V2 100
struct dynArrayStack {
    int top;
    int capacity;
    int *array;
};
//------------------------------------------------
//                   函数声明
//------------------------------------------------
struct dynArrayStack *createStackDyn(void);// 创建栈
int isEmptyStackDyn(struct dynArrayStack *s); // 判断是否为空
int isFullStackDyn(struct dynArrayStack *s);// 判断是否已满
void doubleStackDyn(struct dynArrayStack *s); // 双倍栈数据容量
void pushDyn(struct dynArrayStack *s, int data); // push
int topDyn(struct dynArrayStack *s); // 查看最后一个元素
int popDyn(struct dynArrayStack *s); //pop
void deleteStackDyn(struct dynArrayStack *s); // 删除栈
//------------------------------------------------
//                   函数实现
//------------------------------------------------
struct dynArrayStack *createStackDyn(void) { // 创建栈
    struct dynArrayStack *s = (struct dynArrayStack *)malloc(sizeof(struct dynArrayStack));
    if (s == NULL) {
        puts("动态数组版, 初始化失败");
        return NULL;
    }
    s->capacity = PRO_STACK_SIZE_V2;
    s->top = -;
    s->array = (int *)malloc(s->capacity * sizeof(int));
    if (s->array == NULL) {
        puts("动态数组版，栈数据初始化失败");
        return NULL;
    }
    return s;
}
int isEmptyStackDyn(struct dynArrayStack *s) { // 判断是否为空
    return s->top == -;
}
int isFullStackDyn(struct dynArrayStack *s) { // 判断是否已满
    return (s->top == s->capacity-);
}
void doubleStackDyn(struct dynArrayStack *s) { // 双倍栈数据容量
    s->capacity = s->capacity*;
    s->array = realloc(s->array, s->capacity);
    if (s->array == NULL) {
        puts("动态数组版，加长栈容量失败");
        return;
    }
}
void pushDyn(struct dynArrayStack *s, int data) { // push
    if (isFullStackDyn(s)) {
        doubleStackDyn(s);
    }
    s->array[++s->top] = data;
}

int topDyn(struct dynArrayStack *s) { // 查看最后一个元素
    if (isEmptyStackDyn(s)) {
        return INT_MIN; // 在limits.h里
    }
    return s->array[s->top];
}
int popDyn(struct dynArrayStack *s) { // pop
    if (isEmptyStackDyn(s)) {
        return INT_MIN;
    }
    return s->array[s->top--];
}
void deleteStackDyn(struct dynArrayStack *s) { // 删除栈
    if (s) {
        if (s->array) {
            free(s->array);
        }
        free(s);
    }
}

实现3

链表实现

 

//------------------------------------------------
//                    型声明
//------------------------------------------------
struct listNodeStack {
    int data;
    struct listNodeStack *next;
};
//------------------------------------------------
//                   函数声明
//------------------------------------------------
//struct listNodeStack *createStackList(void);// 不用创建
int isEmptyStackList(struct listNodeStack *s); // 判断是否为空
//int isFullStackList(struct listNodeStack *s);// 永不满
void pushList(struct listNodeStack **s, int data); // push
int topList(struct listNodeStack *s); // top 查看最后一个元素
int popList(struct listNodeStack **s); //pop
void deleteStackList(struct listNodeStack **s); // 删除栈
//------------------------------------------------
//                   函数实现
//------------------------------------------------
int isEmptyStackList(struct listNodeStack *s) { // 判断是否为空
    return s == NULL;
}
void pushList(struct listNodeStack **s, int data) { // push
    struct listNodeStack *temp;
    temp = (struct listNodeStack *)malloc(sizeof(struct listNodeStack));
    if (temp == NULL) {
        puts("链表版， push， 生成新节点失败");
        return;
    }
    temp->data = data;
    temp->next = *s;
    *s = temp;
}
int topList(struct listNodeStack *s) { // top 查看最后一个元素
    if (isEmptyStackList(s)) {
        return INT_MIN;
    }
    return s->data;
}
int popList(struct listNodeStack **s) { //pop
    struct listNodeStack *temp;
    int data;
    if (isEmptyStackList(*s)) {
        return INT_MIN;
    }
    temp = *s;
    *s = temp->next;
    data = temp->data;
    free(temp);
    return data;

}
void deleteStackList(struct listNodeStack **s) { // 删除栈
    struct listNodeStack *current, *temp;
    current = *s;
    while (current) {
        temp = current;
        current = current->next;
        free(temp);
    }
    *s = NULL;
}