Question

我看到以下Java代码用于在单个阵列上实现三个堆栈。

1 int stackSize = 300;
2 int indexUsed = 0;
3 int[] stackPointer = {-1,-1,-1};
4 StackNode[] buffer = new StackNode[stackSize * 3];
5 void push(int stackNum, int value) {
6   int lastIndex = stackPointer[stackNum];
7   stackPointer[stackNum] = indexUsed;
8   indexUsed++;
9   buffer[stackPointer[stackNum]]=new StackNode(lastIndex,value);
10 }
11 int pop(int stackNum) {
12  int value = buffer[stackPointer[stackNum]].value;
13  int lastIndex = stackPointer[stackNum];
14  stackPointer[stackNum] = buffer[stackPointer[stackNum]].previous;
15  buffer[lastIndex] = null;
16  indexUsed--;
17  return value;
18 }
19 int peek(int stack) { return buffer[stackPointer[stack]].value; }
20 boolean isEmpty(int stackNum) { return stackPointer[stackNum] == -1; }
21
22 class StackNode {
23  public int previous;
24  public int value;
25  public StackNode(int p, int v){
26   value = v;
27   previous = p;
28  }
29 }

我的问题1是第4行为变量缓冲区分配了内存。为什么在第9行中，我们仍然需要分配新的StackNode。

我的问题2是：函数弹出帮助可以重新收集用过的内存吗？

例如，

Stack1_E1 => Stack1_E2 => Stack2_E1 => Stack2_E2 => Stack3_E1

当我们调用pop（0）//弹出Stack1时根据我的理解，下次调用push时，Stack1_E2使用的可用空间不会被重用。

功能弹出式设计是否正确？谢谢

注意：此问题已被修改，并包含pop功能。

Answer 1

问题1：第4行为变量缓冲区分配了内存。为什么在第9行中，我们仍然需要分配新的StackNode。

第4行为StackNode个对象创建引用数组。然后在第9行创建实际的StackNode个对象。

问题2：函数弹出帮助可以重新收集用过的内存吗？

pop函数从堆栈中获取下一个值对象（StackNode.value），并将数组中相应的StackNode引用设置为null。此StackNode使用的内存将被垃圾回收，因为StackNode不再被引用。当对象不再使用时（即调用者或其他对象不再引用），值对象本身使用的内存将被垃圾收集。

Answer 2

您似乎熟悉C ++。在Java中，声明变量为它初始化空间; “new”构造只需要调用构造函数。（这就是为什么没有“删除”。）

因此，第4行调用创建了一个StackNode对象形状空间数组，而第9行创建了实际对象。

Answer 3

//Array to implement 3 Stacks

#include<stdio.h>
#include<stdlib.h>
#define size 13

struct Stack{
    int arr[size];
    int top;
}st[3];


void push(int item, int sno){
    if(isFull(sno)){
        printf("Overflow....!!\n");

    }
    else{
       st[sno].top++;

        st[sno].arr[st[sno].top]=item;
      }
}

int isFull(int sno){
    if(sno==1&&st[sno].top==(size/3)-1){
        return 1;
    }
    else if(sno==2&& st[sno].top==(size/3)-1){
        return 1;
    }
    else if(sno==3 && st[sno].top==(size-1 -2*(size/3))){
        return 1;
    }
    else{
        return 0;
    }
}

int isEmpty(int sno){
    if(st[sno].top==-1){
        return 1;
    }
    else{
        return 0;
    }
}


int pop(int sno){
int item;
  if(isEmpty(sno)){
    printf("Underflow....!!\n");
  }
  else{

    item = st[sno].arr[st[sno].top];
    st[sno].top--;
    return item;
}
}

void display(int sno){
    int i;

    for(i=st[sno].top;i>=0;i--){
        printf("%d->",st[sno].arr[i]);
    }
}

int main(){

    st[1].top=-1;
    st[2].top=-1;
    st[3].top=-1;

    push(10,1);
    push(20,1);
    push(30,1);
    push(40,1);

    display(1);

    printf("\n");
    push(50,2);
    display(2);
    printf("\n");
    pop(2);
    pop(2);
    //display(2);

    push(60,3);
    push(70,3);
    push(80,3);
    push(90,3);
    push(100,3);
    printf("\n");
    display(3);
    push(110,3);





    return 0;
}

使用数组实现三个Stack

3 个答案: