和臭弟弟一起学数据结构的第一天（6-1 Two Stacks In One Array (20 分)）

嘿嘿，标题党了。没有臭弟弟喔，只有笨姐姐~

刚刚学数据结构，学到堆栈，真的很不熟练，希望通过这种方式让自己能够好好掌握叭。

6-1 Two Stacks In One Array (20 分)

Write routines to implement two stacks using only one array. Your stack routines should not declare an overflow unless every slot in the array is used.

Format of functions:

Stack CreateStack( int MaxElements );
int IsEmpty( Stack S, int Stacknum );
int IsFull( Stack S );
int Push( ElementType X, Stack S, int Stacknum );
ElementType Top_Pop( Stack S, int Stacknum );

where int Stacknum is the index of a stack which is either 1 or 2; int MaxElements is the size of the stack array; and Stack is defined as the following:

typedef struct StackRecord *Stack;
struct StackRecord  {
    int Capacity;       /* maximum size of the stack array */
    int Top1;           /* top pointer for Stack 1 */
    int Top2;           /* top pointer for Stack 2 */
    ElementType *Array; /* space for the two stacks */
}

Note: Push is supposed to return 1 if the operation can be done successfully, or 0 if fails. If the stack is empty, Top_Pop must return ERROR which is defined by the judge program.

Sample program of judge:

#include <stdio.h>
#include <stdlib.h>
#define ERROR 1e8
typedef int ElementType;
typedef enum { push, pop, end } Operation;

typedef struct StackRecord *Stack;
struct StackRecord  {
    int Capacity;       /* maximum size of the stack array */
    int Top1;           /* top pointer for Stack 1 */
    int Top2;           /* top pointer for Stack 2 */
    ElementType *Array; /* space for the two stacks */
};

Stack CreateStack( int MaxElements );
int IsEmpty( Stack S, int Stacknum );
int IsFull( Stack S );
int Push( ElementType X, Stack S, int Stacknum );
ElementType Top_Pop( Stack S, int Stacknum );

Operation GetOp();  /* details omitted */
void PrintStack( Stack S, int Stacknum ); /* details omitted */

int main()
{
    int N, Sn, X;
    Stack S;
    int done = 0;

    scanf("%d", &N);
    S = CreateStack(N);
    while ( !done ) {
        switch( GetOp() ) {
        case push: 
            scanf("%d %d", &Sn, &X);
            if (!Push(X, S, Sn)) printf("Stack %d is Full!\n", Sn);
            break;
        case pop:
            scanf("%d", &Sn);
            X = Top_Pop(S, Sn);
            if ( X==ERROR ) printf("Stack %d is Empty!\n", Sn);
            break;
        case end:
            PrintStack(S, 1);
            PrintStack(S, 2);
            done = 1;
            break;
        }
    }
    return 0;
}

/* Your function will be put here */

Sample Input:

5
Push 1 1
Pop 2
Push 2 11
Push 1 2
Push 2 12
Pop 1
Push 2 13
Push 2 14
Push 1 3
Pop 2
End

结尾无空行

Sample Output:

Stack 2 is Empty!
Stack 1 is Full!
Pop from Stack 1: 1
Pop from Stack 2: 13 12 11

结尾无空行

哎，英文题，居然是英文题（这对我来说就是遭天谴的程度惹），还是我女神陈越奶奶出的，呜呜呜，我一定会好好学哒！！！

思路

第一，这题其实就是让我们写五个和堆栈操作有关的函数，初始化，pop,push,空？，满？；

第二，千万不要因为是英文题就先产生恐惧心理，仔细看清关于函数的一些具体要求，返回值啊输出啥什么的；

第三，谨记，细节决定成败！

函数代码

Stack CreateStack(int MaxElements) { //初始化堆栈
    Stack S;
    S = (Stack) malloc(sizeof(struct StackRecord));
    S->Array=(int*)malloc(MaxElements*sizeof(int));//数组也是需要分配空间的，且不止一个哦！！这应该是我在前面学习中还没有遇到过的
    S->Capacity = MaxElements;
    S->Top1 = -1;//初始化标记为空的位置，也方便了等下判断为空
    S->Top2 = MaxElements;
    return S;
}

int IsEmpty(Stack S, int Stacknum) {
    if (Stacknum == 1) return (S->Top1 == -1); //这种写法真的好简洁好妙好喜欢啊，我也要学
    if (Stacknum == 2) return (S->Top2 == S->Capacity);//但注意思路不要断，分支这里很明确
}

int IsFull(Stack S) {
    return ((S->Top2 - S->Top1) == 1);//这种写法也就是为真直接return 1,假直接就return 0;
}

int Push(ElementType X, Stack S, int Stacknum) {
    if ((IsFull(S))) return 0;
    else {
        if (Stacknum == 1) {
            S->Array[(++S->Top1)] = X;//先加再用
        } else if (Stacknum == 2) {
            S->Array[(--S->Top2)] = X;//先减再用
        }
        return 1;
    }
}

ElementType Top_Pop(Stack S, int Stacknum) {
    if (IsEmpty(S, Stacknum)) return ERROR;
    else {
        if (Stacknum == 1) {
            return S->Array[S->Top1--];
        } else if (Stacknum == 2) {
            return S->Array[S->Top2++];  //两步合成一步就是S->Array[S->Top2--];也就是先赋值然后运算
        }
    }
}