Question

语言没有数组作为数据类型，但它有堆栈作为数据类型，可以声明堆栈;并定义了push，pop和isempty操作那么我们如何使用两个堆栈及以上的操作来实现数组呢？

Answer 1

非常低效 - 但是：

堆栈1包含详细信息堆栈2是空的。

要浏览阵列Pop Stack 1，当你想要下一个阵列时，将前一个阵列推入堆栈2并再次弹出堆栈1。重复直到'isempty'。

如果您想要第N个值，请将非空堆栈弹出N次，同时将不需要的堆栈推入另一个堆栈。然后当你玩完它后，将它清空到另一个堆栈。请注意这一点; ll翻转顺序。

Answer 2

使用两个堆栈，您可以获得某种随机访问（这是您对数组感兴趣的内容），如下所示：

把所有东西放在堆叠上。
每当你必须访问不是堆栈顶部（pop）的东西时，你会弹出这个堆栈中的所有元素并将它们推送到第二个。

通过将元素从一个堆栈传递到另一个堆栈，您可以模拟迭代。

Answer 3

数组的第一个元素是stack1的底部;
数组的最后一个元素是stack2的底部;
数组的当前元素是stack1的顶部;
通过将stack1的元素移动到stack2（移动到开始），反之亦然（移动到结束）来遍历数组。

Answer 4

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

#define Type int
#define DefaultValue 0

#define bool int

typedef struct stack{
    Type *stack;
    Type *sp;
    size_t size;
} Stack;

Stack* Stack_make(size_t size){
    Stack *s;
    s = (Stack*)malloc(sizeof(Stack));
    s->stack = (Type*)malloc(sizeof(Type)*size);
    s->sp = s->stack -1;
    s->size = size;
    return s;
}

bool Stack_empty(Stack *s){//isempty
    return s->sp < s->stack;
}

void Stack_push(Stack *s, Type value){
    if(s->sp >= s->stack + s->size -1){
        fprintf(stderr, "stack over flow\n");
        exit(-1);
    }
    *(++s->sp) = value;
}

Type Stack_pop(Stack *s){
    if(Stack_empty(s)){
        fprintf(stderr, "stack is empty\n");
        exit(-2);
    }
    return *s->sp--;
}

void Stack_free(Stack *s){
    if(s!=NULL){
        free(s->stack);
        free(s);
    }
}

typedef struct array {
    Stack *front;
    Stack *back;
    size_t size;
    size_t index;
} Array;

Array* Array_make(size_t size){
    Array *a;
    int i;
    a = (Array*)malloc(sizeof(Array));
    a->front = Stack_make(size);
    a->back  = Stack_make(size);
    a->size = size;
    //initialize
    Stack_push(a->front, DefaultValue);
    for(i=0;i<size;++i){
        Stack_push(a->back, DefaultValue);
    }
    a->index = 0;
    return a;
}

void Array_pos_set(Array *a, size_t index){
    if(index < 0 || index >= a->size){
        fprintf(stderr, "out of range\n");
        exit(-11);
    }
    if(a->index < index){
        while(a->index < index){
            Stack_push(a->front, Stack_pop(a->back));
            ++a->index;
        }
    } else if(a->index > index){
        while(a->index > index){
            Stack_push(a->back, Stack_pop(a->front));
            --a->index;
        }
    }
}

Type Array_set(Array *a, size_t index, Type value){
    Array_pos_set(a, index);//a->index == index
    Stack_pop(a->front);
    Stack_push(a->front, value);

    return value;
}

Type Array_get(Array *a, size_t index){
    Type value;
    Array_pos_set(a, index);//a->index == index
    value = Stack_pop(a->front);
    Stack_push(a->front, value);

    return value;
}

void Array_free(Array *a){
    Stack_free(a->front);
    Stack_free(a->back);
    free(a);
}

int main(){
    Array *a;
    int i;

    a = Array_make(10);
    for(i=0;i<10;i++){
        Array_set(a, i, i+1);//a[i] = i+1;
    }
    for(i=0;i<10;i++){
        printf("%d\n", Array_get(a, i));// a[i];
    }
    Array_free(a);

    return 0;
}

使用堆栈的数组实现

4 个答案: