Cracking the coding interview--Q3.1

原文：

Describe how you could use a single array to implement three stacks.

译文：

你如何只用一个数组实现三个栈？

如果实现使用一个数组表示一个栈就简单很多，一个指针指向当前栈顶元素位置，初始top=-1，表示栈为空

如果入栈则top++，并元素入栈即可，出栈也只需要top--，top指向栈顶元素。

方法一：

如果用一个数组代表三个栈的操作，假设前天不知道每个栈所需要的空间大小，则可以使用数组等分，每个栈使用

三分之一空间，各个栈都有自己的栈顶指针来操作自己的空间。

package chapter_3_StacksandQueues;

class Stack_1 {
private int stack[];
private int size;

// 分别记录三个栈顶指针位置，栈顶指针指向当前栈最高元素
private int top[] = new int[3];
private int bottom[] = new int[3];

public Stack_1(int size) {
stack = new int[size * 3];
this.size = size;
top[0] = bottom[0] = -1;
top[1] = bottom[1] = size * 1 -1;
top[2] = bottom[2] = size * 2 -1;
}

public boolean isEmpty(int stackNum) {
return top[stackNum] == (stackNum * size -1);
}

public boolean isFull(int stackNum) {
return top[stackNum] == ((stackNum+1) *size - 1);
}

public void push(int stackNum, int value) {
if(isFull(stackNum)) {
System.out.println("Stack num :" + stackNum + " is full!");
return;
}
stack[++ top[stackNum]] = value;
}

public int top(int stackNum) {
if(isEmpty(stackNum)) {
System.out.println("Stack num :" + stackNum + " is empty!");
return -1;
}
return stack[top[stackNum]];
}

public void pop(int stackNum) {
if(isEmpty(stackNum)) {
System.out.println("Stack num :" + stackNum + " is empty!");
return;
}

top[stackNum]--;
}
// 清空并输出
public String getSatckandClear(int stackNum) {
StringBuilder result = new StringBuilder();
// 当前不空
while(!isEmpty(stackNum)) {
result.append(" " + top(stackNum));
pop(stackNum);
}
return result.toString();
}
}

/**
*
* 你如何只用一个数组实现三个栈？
*
*/
public class Question_3_1 {
public static void main(String args[]) {
Stack_1 stack = new Stack_1(5);
int stackNum = 0;
System.out.println("stackNum " + stackNum + " is Empty :" + stack.isEmpty(stackNum));

for(int i=0; i<3; i++) {
for(int j=i*10, k=1; k<=10; k++,j++) {
stack.push(i, j);
}
}

for(int i=0; i<3; i++) {
String result = stack.getSatckandClear(i);
System.out.format("stack %d : %s\n", i, result);
}
}
}


方法二：

如果考虑三个栈直接使用同一个数组，这个可以灵活各个栈空间大小，不约束于三分之一。这样连续使用则每个栈都有自己的栈顶指针

但是同时由于站内数据混在一起，则需要每个栈当前栈顶元素，如果出栈，则需要找到其前一个元素，此时需要记录每个元素的前继元

素在数组中的下标，所以数组元素就不能单纯使用基本类型了，可以使用c++的结构体，java中则使用类

class Node {
public int data;
public int pre;
}

此时对于操作流程中则需要注意每个栈的出栈和入栈，如果只是单纯各管自己的，每次出栈去数组最高位，则考虑如果栈1一直出栈，最终为空

而此时栈2入栈则单纯只考虑数组最高位则浪费了栈1出栈的位置空间，所以每次都需要有一个全部栈空间指针stack_top，随时指针当前最低位空闲位置

每次有元素需要出栈的时候，元素出栈，如果元素位置比全部stack_top要低位，则更新stack_top为当前出栈位置，如果要高则无需变动，这样实时保证

下次入栈时候能利用最低位空闲位置。

每次有元素需要入栈，则stack_top记录最低位入栈，但是stack_top的下一个高位比一定是空闲位置，所以需要往高位扫描直到找到下一个空闲位置，此时

也是整个数组最低位空闲位置。

package chapter_3_StacksandQueues;

class Node {
public int data;
public int pre;
}

class Stack_1_2 {
private Node[] stack;
// 整个栈的大小
private int size;
private int top[] = new int[3];
// 记录当前全局栈顶可存放位置
private int stack_top;

public Stack_1_2(int size) {
stack = new Node[size];
this.size = size;
top[0] = top[1] = top[2] = -1;
stack_top = 0;

for(int i=0; i<size; i++) {
stack[i] = new Node();
stack[i].pre = -2;
}
}

public boolean isEmpty(int stackNum) {
return top[stackNum] == -1;
}

public boolean isFull() {
return stack_top == (size -1);
}
// 入栈
public void push(int stackNum, int data) {
if(isFull()) {
System.out.println("Stack :" + " is full!");
return;
}
int pre = top[stackNum];
stack[stack_top].pre = pre;
stack[stack_top].data = data;
top[stackNum]
c870
= stack_top;
// 寻找下一个空闲栈位置
for(int i=stack_top;i<size; i++) {
if(stack[i].pre == -2) {
stack_top = i;
break;
}
}
// 如果没有空闲栈位置，则指向栈顶下一个位置
}

public int top(int stackNum) {
if(isEmpty(stackNum)) {
System.out.println("Stack num :" + stackNum + " is empty!");
return -1;
}
return stack[top[stackNum]].data;
}
// 出栈
public void pop(int stackNum) {
if(isEmpty(stackNum)) {
System.out.println("Stack num :" + stackNum + " is empty!");
return;
}
int now = top[stackNum];
Node node = stack[now];
if(now < stack_top) {
stack_top = now;
}

int pre = node.pre;
top[stackNum] = pre;
node.pre = -2; // 标记为空闲位置
}

public String getSatckData(int stackNum) {
StringBuilder result = new StringBuilder();

int cur = top[stackNum];
while(cur != -1) {
result.append(" " + stack[cur].data);
cur = stack[cur].pre;
}
return result.toString();
}
}
/**
*
* 你如何只用一个数组实现三个栈？
*
*/
public class Question_3_1_2 {
public static void main(String args[]) {
Stack_1_2 stack = new Stack_1_2(20);
int stackNum = 0;
System.out.println("stackNum " + stackNum + " is Empty :" + stack.isEmpty(stackNum));

int stackStart[] = {0, 100, 1000};

// 3 * 3
for(int i=0; i<3; i++) {
for(int k=1; k<=3; k++) {
stack.push(i, stackStart[i] ++);
}
}
// 3 * 3
for(int i=2; i>=0; i--) {
for(int k=1; k<=3; k++) {
stack.push(i, stackStart[i] ++);
}
}
// 3 * 1
for(int i=0; i<3; i++) {
for(int k=1; k<=1; k++) {
stack.push(i, stackStart[i] ++);
}
}
// 输出各个栈的内容
for(int i=0; i<3; i++) {
String result = stack.getSatckData(i);
System.out.format("stack %d : %s\n", i, result);
}

// 栈1出栈5个元素
for(int i=0; i<5;i++) {
System.out.format("stack 0 出栈 top pop : %d\n", i, stack.top(0));
stack.pop(0);
}

// 栈2、3入栈元素
for(int i=1; i<3; i++) {
for(int k=1; k<=3; k++) {
stack.push(i, stackStart[i] ++);
}
}

// 输出各个栈的内容
for(int i=0; i<3; i++) {
String result = stack.getSatckData(i);
System.out.format("stack %d : %s\n", i, result);
}
}
}


参考自：http://hawstein.com/posts/3.1.html