数据结构王道强化应用题打卡表【第二章】（代码部分）

代码更贴近伪代码，未经过调试，仅用于回答初试题目准备

2.1 栈

1. 顺序栈（数组）

1. 写代码：定义顺序存储的栈（数组实现），数据元素是 int 型
2. 实现“出栈、入栈、判空、判满”四个基本操作

#define Maxsize 50

typedef struct{
    int data[Maxsize];
    int top; //栈顶指针，所指为栈顶元素
}stack;

//初始化
void Init(stack &s){
    s.top = -1;
}

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

//判满
bool full(stack s){
    if(s.top == Maxsize - 1)
        return true;
    else 
        return false;
}

//入栈
bool push(stack &s, int x){
    if(full(s) == false){
        s.data[++s.top] = x; //栈顶指针先移动一位，再赋值
        return true;
    }
    else
        return false;      
}

//出栈
bool pop(stack &s){
    if(empty(s) == false){
        x = s.data[top--]; //取出栈顶元素，指针再移动
        return true;
    }
    else false;
}

2. 链式栈(单链)

写代码：定义链式存储的栈（单链表实现）

栈顶在链头，实现“出栈、入栈、判空、判满”四个基本操作

//节点定义
typedef struct node{
    int data;
    struct node *next;
}*stack, node;

//初始化
//带头结点
bool init(stack &s){
    s = (stack)malloc(sizeof(node));
    if(s == NULL) return false; //申请失败
    S->next = NULL; //此时栈为空
    return true;
}

//判空
bool empty(stack s){
    if(s->next == NUll) 
        return true;
    else
        false;
}

//无判满

//入栈
//头插法（头一直是不动的）
bool push(stack &s, int x){
    node *p;
    p = (node*)malloc(sizeof(node)); //申请一个新结点
    if(p == NULL) return false; //申请结点失败返回
    p->data = x;
    p->next = s->next;
    s->next = p;
    return true; //插入成功
}

//出栈
//弹出头结点后的第一个结点
///int pop(stack &s){ //万一为空返回值不好确定，故舍弃这种方法
bool pop(stack &s, int &x){
    if(empty(s) == true) return false; //栈空则无法弹栈
    node *p; 
    p = s->next; //记录要弹出的结点
    s->next = p->next; //头结点指向下下一个结点
    x = p->data; //记录结点权值
    free(p); //释放弹出的结点的空间
    return true;
}

3. 链式栈（双链）

1. 定义链栈
2. 实现基本操作（要求双链表实现，栈顶在链尾）

//定义栈结点
typedef struct node{
    int data;					//保存int型元素
    struct node *front, *next; //向前的指针和向后的指针
}node;

//定义链式栈（双链）
typedef struct stack{
    struct node *head, *rear; //定义两个指向链头和链尾的指针
}stack, *stackpo;

//初始化双向链栈
bool init(stackpo &s){
	s = (stack *)malloc(sizeof(stack)); //初始化一个链栈
    node *p = (node *)malloc(sizeof(node)); //新建一个头结点
    p->next = NULL; //此时栈空
    p->front