数据结构 两栈共享

将编号0和1两个栈存放于一个数组空间V[m]中，栈底分别位于数组的两端。当0号栈的栈顶指针top[0] = -1时该栈为空，当1号栈的栈顶指针top[1]等于m时，该栈为空。两个栈均从两端向中间增长
#include <stdio.h>

#include <stdlib.h>



#define InitMaxsize 3//栈最大可容纳元素个数



typedef int elem;



typedef struct

{

int top[2], bot[2];//定义栈顶和栈底指针

elem *V; //栈数组

int m; //栈最大可容纳元素个数

}DblStack;



//初始化双栈

void InitDblStack(DblStack &stack)

{

elem *arr = (elem*)malloc(sizeof(elem));//申请空间

stack.V = arr; //将V指针指向申请的空间

stack.m = InitMaxsize; //初始化栈最大可容纳最大元素个数

stack.top[0] = -1; //左栈栈顶指针初始化

stack.top[1] = stack.m - 1; //右栈栈顶指针初始化

stack.bot[0] = 0; //左栈栈底指针初始化

stack.bot[1] = stack.m-1; //右栈栈底指针初始化





}



//判断总体是否为空栈

int EmptyDblStack(DblStack stack)

{

if(stack.top[0] == -1 && stack.top[1] == stack.m-1)

return 1; //若是返回1

return 0; //否则返回0

}



//判断左栈是否为空栈

int EmptyLeft(DblStack stack)

{

if(stack.top[0] == -1)

return 1; //若是返回1

return 0; //否则返回0

}



//判断右栈是否为空栈

int EmptyRight(DblStack stack)

{

if(stack.top[1] == stack.m-1)

return 1; //若是返回1

return 0; //否则返回0

}



//判断是否为满栈

int FullDblStack(DblStack stack)

{

if(stack.top[1] == stack.top[0] || stack.top[0] >= stack.m || stack.top[1] < 0 )

//三种满栈情况左右两栈中间相遇，左栈满，右栈满

return 1;//满栈返回1

return 0;//否则返回0

}



//左栈进栈

int pushLeft(DblStack &stack, elem e)

{

    if (FullDblStack(stack) == 1)//判断是否为满栈

{

printf("栈已满不能进行进栈操作\n");

return 0; //满栈返回0

}

    stack.top[0]++; //左栈栈顶指针加一

stack.V[stack.top[0]] = e; //将数据元素进栈

    return 1; //完成操作返回1

}



//右栈进栈

int pushRight(DblStack &stack, elem e)

{

    if (FullDblStack(stack) == 1)//判断是否为满栈

{

printf("栈已满，无法进行进栈操作\n");

return 0; //满栈返回0

}

    stack.V[stack.top[1]] = e; //将数据元素进栈

    stack.top[1]--; //右栈栈顶指针加一

    return 1;

}



//左栈出栈

elem popLeft(DblStack &stack)

{

    if (EmptyLeft(stack) == 1)//判断是否为空栈

{

printf("左栈已空，无法进行出栈操作\n");

return 0; //空栈返回0

}

    elem e = stack.V[stack.top[0]]; //取出栈顶数据元素

    stack.top[0]--; //左栈栈顶元素减一

    return e; //返回原栈顶元素

}



//右栈出栈

elem popRight(DblStack &stack)

{

    if (EmptyRight(stack) == 1) //判断是否为空栈

{

printf("右栈已空，无法进行出栈操作\n");

return 0; //空栈返回0

}

stack.top[1]++; //右栈栈顶指针加一

    elem e = stack.V[stack.top[1]]; //取出右栈栈顶元素

    return e; //返回原栈顶元素

}



//遍历双栈

void printDblStack(DblStack stack) 

{

    for (int i = 0; i <= stack.top[0]; i++) //输出左栈

{

        printf("|%d| ", stack.V[i]);

    }

for(int i = ++stack.top[1]; i < stack.m; i++)//输出右栈

{

printf("|%d| ", stack.V[i]);

}

    printf("\n");

}





//调试

int main()

{

DblStack stack;

InitDblStack(stack); //初始化双栈

printf("双栈%s空栈\n", EmptyDblStack(stack) == 1?"是":"不是"); //判断总体是否为空栈

pushLeft(stack, 1); //左栈进栈

pushLeft(stack, 2); //左栈进栈

pushRight(stack, 3); //右栈进栈

printf("双栈%s满栈\n", FullDblStack(stack) == 1?"已":"未");//判断是否为满栈

popLeft(stack);

popRight(stack);

popRight(stack);

printDblStack(stack);

return 0;

}

王鹏霄 21:15:19

#include <iostream>
#include <string>
#include <iomanip>

using namespace std;

class SElemType {
public:
int data;
SElemType(int data=0): data(data) {}
};

typedef struct
{
int top[2], bot[2];
SElemType* V;
int m;
} DblStack;


void init(DblStack& dblStack, int size) {
dblStack.m = size;
dblStack.V = new SElemType[size];
dblStack.bot[0] = 0;
dblStack.bot[1] = size - 1;
dblStack.top[0] = -1;
dblStack.top[1] = size;
}


void release(DblStack& dblStack) {
delete[] dblStack.V;
}


void display(const DblStack& dblStack) {
for (int i = dblStack.bot[0]; i <= dblStack.top[0]; i++) {
cout << (dblStack.V[i].data) << " ";
}
cout << " <> ";
for (int i = dblStack.bot[1]; i >= dblStack.top[1]; i--) {
cout << (dblStack.V[i].data) << " ";
}
cout << endl;
}


bool isEmpty(DblStack& dblStack, int id) {
if (id == 0) {
return dblStack.top[0] == -1;
}
else if (id == 1) {
return dblStack.top[1] == dblStack.m;
}
else {
return true;
}
}


bool isFull(DblStack& dblStack){
return (dblStack.top[1] - dblStack.top[0] == 1);
}


void push(DblStack& dblStack, int id, SElemType elem) {
if (!isFull(dblStack)) {
if (id == 0) {
dblStack.V[++dblStack.top[0]] = elem;
}
else if (id == 1) {
dblStack.V[--dblStack.top[1]] = elem;
}
}
}


void pop(DblStack& dblStack, int id) {
if (!isEmpty(dblStack, id)) {
if (id == 0) {
dblStack.top[0] --;
}
else if (id == 1) {
dblStack.top[1] ++;
}
}
}


int main() { 
DblStack stack;
init(stack, 10);
push(stack, 0, SElemType(1));
push(stack, 0, SElemType(2));
push(stack, 0, SElemType(3));
push(stack, 0, SElemType(4));
push(stack, 1, SElemType(5));
push(stack, 1, SElemType(6));
push(stack, 1, SElemType(7));
push(stack, 1, SElemType(8));
push(stack, 1, SElemType(9));
push(stack, 1, SElemType(10));
push(stack, 1, SElemType(11));
push(stack, 0, SElemType(12));
display(stack);
pop(stack, 0);
pop(stack, 1);
pop(stack, 1);
display(stack);
pop(stack, 0);
pop(stack, 0);
pop(stack, 0);
pop(stack, 0);
pop(stack, 1);
pop(stack, 1);
pop(stack, 1);
pop(stack, 1);
pop(stack, 1);
display(stack);
release(stack);
    return 0;
}