将编号为0和1的两个栈存放于一个数组空间V[m]中，栈底分别处于数组的两端。当第0号栈的栈顶指针top[0]等于-1时该栈为空，当第1号栈的栈顶指针top[1]等于m时该栈为空。两个栈均从两端向中间增长。试编写双栈初始化，判断栈空、栈满、进栈和出栈等算法的函数。 双栈数据结构的定义如下： Typedef struct { int top[2],bot[2];//栈顶和栈底指针 SElemType *V;//栈数组 int m;//栈最大可容纳元素个数 }DblStack

以下是双栈初始化、判断栈空、栈满、进栈和出栈等算法的函数：

#include <stdio.h>
#include <stdlib.h>

#define ERROR -1
#define OK 1

typedef int SElemType;
typedef struct {
    int top[2], bot[2]; // 栈顶和栈底指针
    SElemType *V; // 栈数组
    int m; // 栈最大可容纳元素个数
} DblStack;

// 双栈初始化
int InitDblStack(DblStack *S, int m) {
    S->V = (SElemType *)malloc(m * sizeof(SElemType));
    if (!S->V) {
        return ERROR;
    }
    S->top[0] = -1;
    S->bot[0] = 0;
    S->top[1] = m;
    S->bot[1] = m - 1;
    S->m = m;
    return OK;
}

// 判断栈空
int IsDblStackEmpty(DblStack S, int i) {
    if (i == 0) {
        return S.top[0] == -1;
    } else if (i == 1) {
        return S.top[1] == S.m;
    } else {
        return ERROR;
    }
}

// 判断栈满
int IsDblStackFull(DblStack S) {
    return S.top[0] + 1 == S.top[1];
}

// 进栈
int PushDblStack(DblStack *S, int i, SElemType e) {
    if (IsDblStackFull(*S)) {
        return ERROR;
    }
    if (i == 0) {
        S->top[0]++;
        S->V[S->top[0]] = e;
    } else if (i == 1) {
        S->top[1]--;
        S->V[S->top[1]] = e;
    } else {
        return ERROR;
    }
    return OK;
}

// 出栈
int PopDblStack(DblStack *S, int i, SElemType *e) {
    if (IsDblStackEmpty(*S, i)) {
        return ERROR;
    }
    if (i == 0) {
        *e = S->V[S->top[0]];
        S->top[0]--;
    } else if (i == 1) {
        *e = S->V[S->top[1]];
        S->top[1]++;
    } else {
        return ERROR;
    }
    return OK;
}

int main() {
    DblStack S;
    int m = 10;
    InitDblStack(&S, m);
    PushDblStack(&S, 0, 1);
    PushDblStack(&S, 1, 2);
    SElemType e;
    PopDblStack(&S, 0, &e);
    printf("%d\n", e);
    PopDblStack(&S, 1, &e);
    printf("%d\n", e);
    return 0;
}

其中，InitDblStack函数用于初始化双栈，IsDblStackEmpty函数用于判断栈空，IsDblStackFull函数用于判断栈满，PushDblStack函数用于进栈，PopDblStack函数用于出栈。在主函数中，我们先初始化双栈，然后分别向两个栈中压入元素，再从两个栈中分别弹出元素并输出。