blocks|key|2699017|text|第一个堆栈从左到右增长。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2699018|第二个堆栈从右向左增长。|2699019|第三个堆栈从中间开始。为简单起见，假设数组大小为奇数。然后第三个堆栈就会像这样增长：|2699020|*+*+*+*+*+*+*+*+*+*+*
++++++5+3+1+2+4|code-block|syntax|javascript|2699021|允许第一个和第二个堆栈在数组大小的一半时最大增长。第三个堆栈可以增长到最大值填充整个数组。|2699022|最坏的情况是前两个阵列中的一个以阵列的50%25的速度增长。那么就会有50%25的阵列浪费。为了优化效率，必须将第三个阵列选择为比其他两个阵列增长更快的阵列。|2699023|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|T|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

First stack grows from left to right.

Second stack grows from right to left.

Third stack starts from the middle. Suppose odd sized array for simplicity. Then third stack grows like this:

<pre><code>* * * * * * * * * * *
 5 3 1 2 4
</code></pre>

First and second stacks are allowed to grow maximum at the half size of array. The third stack can grow to fill in the whole array at a maximum.

Worst case scenario is when one of the first two arrays grows at 50% of the array. Then there is a 50% waste of the array. To optimise the efficiency the third array must be selected to be the one that grows quicker than the other two.

blocks|key|2699039|text|第一个堆栈增长速度为3n，第二个堆栈增长速度为3n%2B1，第三个堆栈增长速度为3n%2B2|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2699040|对于n={0...N}|2699041|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

first stack grows at 3n,
second stack grows at 3n+1,
third grows at 3n+2

for n={0...N}

blocks|key|4812049|text|您可以使用实现三个堆栈：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4812050|4812051|你需要一个指向下一个自由元素的指针。另外三个指针返回每个堆栈的最后一个元素(如果堆栈是空的，则返回null+)。|unordered-list-item|4812052|当堆栈添加另一个元素时，它必须使用第一个空闲元素并将空闲指针设置为下一个空闲元素(否则将引发溢出错误)。它自己的指针必须指向新的元素，从那里回到堆栈中的下一个元素。|4812053|当堆栈移除一个元素时，它会把它交回空闲元素的列表中。堆栈的自身指针将重定向到堆栈中的下一个元素。|4812054|4812055|链表可以在数组中实现。|4812056|这(空间)效率如何？|4812057|通过为每个列表元素(值%2B指针)使用数组的两个单元来构建链表是没有问题的。根据规范的不同，你甚至可以将指针和值放入一个数组元素中(例如，数组很长，而值和指针只是整型的)。|4812058|将其与kgiannakakis的解决方案进行比较...损失高达50%25+(仅在最坏的情况下)。但我认为我的解决方案更清晰一些(也许更学术，这对于面试问题%5E%5E应该没有什么坏处)。|offset|length|4812059|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/3060104/how-to-implement-three-stacks-using-a-single-array/3060138#3060138^0|0|0|0|0|0|0|0|0|0|3|C|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|13|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|14|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|15|8|@]|9|@]|A|$]]|$1|H|3|I|5|E|7|16|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|17|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|18|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|19|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1B|8|@]|9|@$S|1C|T|1D|1|1E]]|A|$]]|$1|U|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]]]

You can implement three stacks with a <a href="http://en.wikipedia.org/wiki/Linked_list" rel="nofollow noreferrer">linked list</a>: 

<ul>
<li>You need a pointer pointing to the next free element. Three more pointers return the last element of each stack (or null, if the stack is empty).</li>
<li>When a stack gets another element added, it has to use the first free element and set the free pointer to the next free element (or an overflow error will be raised). Its own pointer has to point to the new element, from there back to the next element in the stack.</li>
<li>When a stack gets an element removed it will hand it back into the list of free elements. The own pointer of the stack will be redirected to the next element in the stack.</li>
</ul>

A linked list can be implemented within an array.

How (space) efficent is this? 
It is no problem to build a linked list by using two cells of an array for each list element (value + pointer). Depending on the specification you could even get pointer and value into one array element (e.g. the array is long, value and pointer are only int). 
Compare this to the solution of <a href="https://stackoverflow.com/questions/3060104/how-to-implement-three-stacks-using-a-single-array/3060138#3060138">kgiannakakis</a> ... where you lose up to 50% (only in the worst case). But I think that my solution is a bit cleaner (and maybe more academic, which should be no disadvantage for an interview question ^^).

blocks|key|2699116|text|这是一个有趣的难题，我没有真正的答案，但稍微跳出了框框……|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2699117|这可能取决于堆栈中的每个元素由什么组成。如果它是三个真/假标志堆栈，那么你可以使用整数元素的前三位。即。位0是第一堆栈的值，位1是第二堆栈的值，位2是第三堆栈的值。然后，每个堆栈可以独立增长，直到该堆栈的整个数组已满。这甚至更好，因为即使第一个堆栈已满，其他堆栈也可以继续增长。|2699118|我知道这有点作弊，并没有真正回答问题，但它确实适用于非常特定的情况，堆栈中的条目不会被浪费。我正在兴致勃勃地观察，看看是否有人能提出一个适用于更通用元素的正确答案。|2699119|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

This is an interesting conundrum, and I don't have a real answer but thinking slightly outside the box...

it could depend on what each element in the stack consists of. If it's three stacks of true/false flags, then you could use the first three bits of integer elements. Ie. bit 0 is the value for the first stack, bit 1 is the value for the second stack, bit 2 is the value for the third stack. Then each stack can grow independently until the whole array is full for that stack. This is even better as the other stacks can also continue to grow even when the first stack is full.

I know this is cheating a bit and doesn't really answer the question but it does work for a very specific case and no entries in the stack are wasted. I am watching with interest to see whether anyone can come up with a proper answer that works for more generic elements.

blocks|key|1965131|text|假设所有的数组位置都应该用来存储值-我猜这取决于你对效率的定义。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1965132|如果使用双堆栈解决方案，将第三个堆栈放在中间的某个位置，并跟踪其底部和顶部，那么大多数操作将继续有效，只要发生冲突，代价就是代价高昂的移动操作(将第三个堆栈移动到剩余可用空间的位置，移动到空闲空间的中点)。|1965133|它肯定会很快地编码和理解。我们的效率目标是什么？|1965134|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Assuming that all array positions should be used to store values - I guess it depends on your definition of efficiency.

If you do the two stack solution, place the third stack somewhere in the middle, and track both its bottom and top, then most operations will continue to be efficient, at a penalty of an expensive Move operation (of the third stack towards wherever free space remains, moving to the half way point of free space) whenever a collision occurs.

It's certainly going to be quick to code and understand. What are our efficiency targets?

blocks|key|2699183|text|请参阅Knuth,+The+Art+of+Computer+Programming,+Volume+1，第2.2.2节。标题为“顺序分配”。讨论在单个数组中分配多个队列/堆栈，以及处理溢出的算法等。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2699184|entityMap|0|LINK|mutability|MUTABLE|url|https://rads.stackoverflow.com/amzn/click/com/0201896834^0|3|1C|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

See <a href="https://rads.stackoverflow.com/amzn/click/com/0201896834" rel="noreferrer" rel="nofollow noreferrer">Knuth, The Art of Computer Programming, Volume 1</a>, Section 2.2.2. titled "Sequential allocation". Discusses allocating multiple queues/stacks in a single array, with algorithms dealing with overflows, etc.

blocks|key|59535|text|我们可以使用长位数组来表示第i个数组单元属于哪个堆栈。我们可以取模3的值(00+-空，01+-+A，10+-+B，11+-+C)。对于N大小的数组，需要N/2位或N/4字节的额外内存。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|59536|例如，对于1024个长整型元素(4096字节)，只需要256个字节或6%25。|59537|这个位数组映射可以放在相同的数组中，在开始或结束时，只需将给定数组的大小缩小6%25！|59538|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

We can use long bit array representing to which stack the i-th array cell belongs to.
We can take values by modulo 3 (00 - empty, 01 - A, 10 - B, 11 - C). It would take N/2 bits or N/4 bytes of additional memory for N sized array. 

For example for 1024 long int elements (4096 bytes) it would take only 256 bytes or 6%.

This bit array map can be placed in the same array at the beginning or at the end, just shrinking the size of the given array by constant 6%!

blocks|key|1971120|text|在这种方法中，只要数组中有空闲空间，任何堆栈都可以增长。我们按顺序将空间分配给堆栈，并将新块链接到前一个块。这意味着堆栈中的任何新元素都会保留指向该特定堆栈的前一个顶部元素的指针。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1971121|int+stackSize+=+300;
int+indexUsed+=+0;
int[]+stackPointer+=+{-1,-1,-1};
StackNode[]+buffer+=+new+StackNode[stackSize+*+3];

void+push(int+stackNum,+int+value)+{
++++int+lastIndex+=+stackPointer[stackNum];
++++stackPointer[stackNum]+=+indexUsed;
++++indexUsed%2B%2B;
++++buffer[stackPointer[stackNum]]=new+StackNode(lastIndex,value);
}

int+pop(int+stackNum)+{
++++int+value+=+buffer[stackPointer[stackNum]].value;
++++int+lastIndex+=+stackPointer[stackNum];
++++stackPointer[stackNum]+=+buffer[stackPointer[stackNum]].previous;
++++buffer[lastIndex]+=+null;
++++indexUsed--;
++++return+value;
}

int+peek(int+stack)+{+return+buffer[stackPointer[stack]].value;+}

boolean+isEmpty(int+stackNum)+{+return+stackPointer[stackNum]+==+-1;+}

class+StackNode+{
++++public+int+previous;
++++public+int+value;

++++public+StackNode(int+p,+int+v){
++++++++value+=+v;
++++++++previous+=+p;
++++}
}|code-block|syntax|javascript|1971122|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

In this approach, any stack can grow as long as there is any free space in the array.
We sequentially allocate space to the stacks and we link new blocks to the previous block. This means any new element in a stack keeps a pointer to the previous top element of that particular stack.

<pre><code>int stackSize = 300;
int indexUsed = 0;
int[] stackPointer = {-1,-1,-1};
StackNode[] buffer = new StackNode[stackSize * 3];

void push(int stackNum, int value) {
 int lastIndex = stackPointer[stackNum];
 stackPointer[stackNum] = indexUsed;
 indexUsed++;
 buffer[stackPointer[stackNum]]=new StackNode(lastIndex,value);
}

int pop(int stackNum) {
 int value = buffer[stackPointer[stackNum]].value;
 int lastIndex = stackPointer[stackNum];
 stackPointer[stackNum] = buffer[stackPointer[stackNum]].previous;
 buffer[lastIndex] = null;
 indexUsed--;
 return value;
}

int peek(int stack) { return buffer[stackPointer[stack]].value; }

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

class StackNode {
 public int previous;
 public int value;

 public StackNode(int p, int v){
 value = v;
 previous = p;
 }
}
</code></pre>

blocks|key|2699329|text|这段代码在单个数组中实现了3个堆栈。它负责处理空白空间，并填充数据之间的空白空间。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2699330|2699331|+#包含结构堆栈节点{|blockquote|2699332|2699333|1个整数值；|2699334|1.+int+prev；|2699335|}；struct+stacknode+stacklist50；|2699336|int+top3+=+{-1，-1，-1}；|2699337|int+freelist50；|2699338|int+stackindex=0；|2699339|int+freeindex=-1；void+push(int+stackno，int+value)+{|2699340|int索引；|2699341|*+if(freeindex+>=+0)+{|2699342|*+index+=freelistfreeindex+index；|2699343|*+freeindex--；|2699344|*}其他{|2699345|*+index+=+stackindex；|2699346|*+stackindex%2B%2B；|2699347|}|2699348|*+stacklistindex.value+=值；|2699349|*+if(topstackno-1+!=+-1)+{|2699350|*+stacklistindex.prev+=+topstackno-1；|2699351|2699352|*+stacklistindex.prev+=+-1；|2699353|2699354|*+topstackno-1+=索引；|2699355|**+printf("%25d被推入堆栈%25d中的%25d\n"，value，stackno，index)；|2699356|}+int+pop(int+stackno)+{|2699357|整数索引，值；|2699358|*+if(topstackno-1+==+-1)+{|2699359|*printf(“堆栈中没有元素%25d\n"，value，stackno)；|2699360|*+return+-1；|2699361|2699362|*+index+=+topstackno-1；|2699363|**+freeindex%2B%2B；|2699364|**+freelistfreeindex+index=+index；|2699365|*值=+stacklistindex.value；|2699366|*+topstackno-1+=+stacklistindex.prev；|2699367|**+printf("%25d+is+popped+put+from+stack+%25d+at+%25d\n"，value，stackno，index)；|2699368|2.返回值；|2699369|}+int+main()+{|2699370|*推送(1，1)；|2699371|*推送(1，2)；|2699372|*推送(3，3)；|2699373|*推送(2，4)；|2699374|*流行音乐(3)；|2699375|2699376|2699377|*推送(2，3)；|2699378|2699379|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|2W|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|2X|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|2Y|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|2Z|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|30|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|31|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|32|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|33|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|34|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|35|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|36|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|37|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|38|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|39|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|3A|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|3B|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|3C|8|@]|9|@]|A|$]]|$1|16|3|17|5|6|7|3D|8|@]|9|@]|A|$]]|$1|18|3|19|5|6|7|3E|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|6|7|3F|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|6|7|3G|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|6|7|3H|8|@]|9|@]|A|$]]|$1|1G|3|13|5|6|7|3I|8|@]|9|@]|A|$]]|$1|1H|3|1I|5|6|7|3J|8|@]|9|@]|A|$]]|$1|1J|3|19|5|6|7|3K|8|@]|9|@]|A|$]]|$1|1K|3|1L|5|6|7|3L|8|@]|9|@]|A|$]]|$1|1M|3|1N|5|6|7|3M|8|@]|9|@]|A|$]]|$1|1O|3|1P|5|6|7|3N|8|@]|9|@]|A|$]]|$1|1Q|3|1R|5|6|7|3O|8|@]|9|@]|A|$]]|$1|1S|3|1T|5|6|7|3P|8|@]|9|@]|A|$]]|$1|1U|3|1V|5|6|7|3Q|8|@]|9|@]|A|$]]|$1|1W|3|1X|5|6|7|3R|8|@]|9|@]|A|$]]|$1|1Y|3|19|5|6|7|3S|8|@]|9|@]|A|$]]|$1|1Z|3|20|5|6|7|3T|8|@]|9|@]|A|$]]|$1|21|3|22|5|6|7|3U|8|@]|9|@]|A|$]]|$1|23|3|24|5|6|7|3V|8|@]|9|@]|A|$]]|$1|25|3|26|5|6|7|3W|8|@]|9|@]|A|$]]|$1|27|3|28|5|6|7|3X|8|@]|9|@]|A|$]]|$1|29|3|2A|5|6|7|3Y|8|@]|9|@]|A|$]]|$1|2B|3|2C|5|6|7|3Z|8|@]|9|@]|A|$]]|$1|2D|3|2E|5|6|7|40|8|@]|9|@]|A|$]]|$1|2F|3|2G|5|6|7|41|8|@]|9|@]|A|$]]|$1|2H|3|2I|5|6|7|42|8|@]|9|@]|A|$]]|$1|2J|3|2K|5|6|7|43|8|@]|9|@]|A|$]]|$1|2L|3|2M|5|6|7|44|8|@]|9|@]|A|$]]|$1|2N|3|2O|5|6|7|45|8|@]|9|@]|A|$]]|$1|2P|3|2O|5|6|7|46|8|@]|9|@]|A|$]]|$1|2Q|3|2K|5|6|7|47|8|@]|9|@]|A|$]]|$1|2R|3|2S|5|6|7|48|8|@]|9|@]|A|$]]|$1|2T|3|19|5|6|7|49|8|@]|9|@]|A|$]]|$1|2U|3|-4|5|6|7|4A|8|@]|9|@]|A|$]]]|2V|$]]

This code implements 3 stacks in single array. It takes care of empty spaces and fills the empty spaces in between the data. 
 

<blockquote>
 #include &lt;stdio.h> 
 
 struct stacknode { 
 &nbsp;&nbsp; int value; 
 &nbsp;&nbsp; int prev; 
 }; 
 
 struct stacknode stacklist[50]; 
 int top[3] = {-1, -1, -1}; 
 int freelist[50]; 
 int stackindex=0; 
 int freeindex=-1; 
 
 void push(int stackno, int value) { 
 &nbsp;&nbsp; int index; 
 &nbsp;&nbsp; if(freeindex >= 0) { 
 &nbsp;&nbsp;&nbsp;&nbsp; index = freelist[freeindex]; 
 &nbsp;&nbsp;&nbsp;&nbsp; freeindex--; 
 &nbsp;&nbsp; } else { 
 &nbsp;&nbsp;&nbsp;&nbsp; index = stackindex; 
 &nbsp;&nbsp;&nbsp;&nbsp; stackindex++; 
 &nbsp;&nbsp; } 
 &nbsp;&nbsp; stacklist[index].value = value; 
 &nbsp;&nbsp; if(top[stackno-1] != -1) { 
 &nbsp;&nbsp;&nbsp;&nbsp; stacklist[index].prev = top[stackno-1]; 
 &nbsp;&nbsp; } else { 
 &nbsp;&nbsp;&nbsp;&nbsp; stacklist[index].prev = -1; 
 &nbsp;&nbsp; } 
 &nbsp;&nbsp; top[stackno-1] = index; 
 &nbsp;&nbsp; printf("%d is pushed in stack %d at %d\n", value, stackno, index); 
 } 
 
 int pop(int stackno) { 
 &nbsp;&nbsp; int index, value; 
 &nbsp;&nbsp; if(top[stackno-1] == -1) { 
 &nbsp;&nbsp;&nbsp;&nbsp; printf("No elements in the stack %d\n", value, stackno); 
 &nbsp;&nbsp;&nbsp;&nbsp; return -1; 
 &nbsp;&nbsp; } 
 &nbsp;&nbsp; index = top[stackno-1]; 
 &nbsp;&nbsp; freeindex++; 
 &nbsp;&nbsp; freelist[freeindex] = index; 
 &nbsp;&nbsp; value = stacklist[index].value; 
 &nbsp;&nbsp; top[stackno-1] = stacklist[index].prev; 
 &nbsp;&nbsp; printf("%d is popped put from stack %d at %d\n", value, stackno, index); 
 &nbsp;&nbsp; return value; 
 } 
 
 int main() { 
 &nbsp;&nbsp; push(1,1); 
 &nbsp;&nbsp; push(1,2); 
 &nbsp;&nbsp; push(3,3); 
 &nbsp;&nbsp; push(2,4); 
 &nbsp;&nbsp; pop(3); 
 &nbsp;&nbsp; pop(3); 
 &nbsp;&nbsp; push(3,3); 
 &nbsp;&nbsp; push(2,3); 
 } 
</blockquote>

blocks|key|1965231|text|在PYTHON中的另一个解决方案，请让我知道它是否如您所想的那样工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1965232|++++class+Stack(object):

++++def+__init__(self):
++++++++self.stack+=+list()

++++++++self.first_length+=+0
++++++++self.second_length+=+0
++++++++self.third_length+=+0

++++++++self.first_pointer+=+0
++++++++self.second_pointer+=+1

++++def+push(self,+stack_num,+item):

++++++++if+stack_num+==+1:
++++++++++++self.first_pointer+%2B=+1
++++++++++++self.second_pointer+%2B=+1
++++++++++++self.first_length+%2B=+1
++++++++++++self.stack.insert(0,+item)

++++++++elif+stack_num+==+2:
++++++++++++self.second_length+%2B=+1
++++++++++++self.second_pointer+%2B=+1
++++++++++++self.stack.insert(self.first_pointer,+item)
++++++++elif+stack_num+==+3:
++++++++++++self.third_length+%2B=+1
++++++++++++self.stack.insert(self.second_pointer+-+1,+item)
++++++++else:
++++++++++++raise+Exception('Push+failed,+stack+number+%25d+is+not+allowd'+%25+stack_num)

++++def+pop(self,+stack_num):
++++++++if+stack_num+==+1:
++++++++++++if+self.first_length+==+0:
++++++++++++++++raise+Exception('No+more+element+in+first+stack')
++++++++++++self.first_pointer+-=+1
++++++++++++self.first_length+-=+1
++++++++++++self.second_pointer+-=+1
++++++++++++return+self.stack.pop(0)
++++++++elif+stack_num+==+2:
++++++++++++if+self.second_length+==+0:
++++++++++++++++raise+Exception('No+more+element+in+second+stack')
++++++++++++self.second_length+-=+1
++++++++++++self.second_pointer+-=+1
++++++++++++return+self.stack.pop(self.first_pointer)
++++++++elif+stack_num+==+3:
++++++++++++if+self.third_length+==+0:
++++++++++++++++raise+Exception('No+more+element+in+third+stack')
++++++++++++self.third_length+-=+1
++++++++++++return+self.stack.pop(self.second_pointer+-+1)

++++def+peek(self,+stack_num):
++++++++if+stack_num+==+1:
++++++++++++return+self.stack[0]
++++++++elif+stack_num+==+2:
++++++++++++return+self.stack[self.first_pointer]
++++++++elif+stack_num+==+3:
++++++++++++return+self.stack[self.second_pointer]
++++++++else:
++++++++++++raise+Exception('Peek+failed,+stack+number+%25d+is+not+allowd'+%25+stack_num)

++++def+size(self):
++++++++return+len(self.items)

s+=+Stack()

#+push+item+into+stack+1
s.push(1,+'1st_stack_1')
s.push(1,+'2nd_stack_1')
s.push(1,+'3rd_stack_1')
#
##+push+item+into+stack+2
s.push(2,+'first_stack_2')
s.push(2,+'second_stack_2')
s.push(2,+'third_stack_2')
#
##+push+item+into+stack+3
s.push(3,+'FIRST_stack_3')
s.push(3,+'SECOND_stack_3')
s.push(3,+'THIRD_stack_3')
#
print+'Before+pop+out:+'
for+i,+elm+in+enumerate(s.stack):
++++print+'\t\t%25d)'+%25+i,+elm

#
s.pop(1)
s.pop(1)
#s.pop(1)
s.pop(2)
s.pop(2)
#s.pop(2)
#s.pop(3)
s.pop(3)
s.pop(3)
#s.pop(3)
#
print+'After+pop+out:+'
#
for+i,+elm+in+enumerate(s.stack):
++++print+'\t\t%25d)'+%25+i,+elm|code-block|syntax|javascript|1965233|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Another solution in PYTHON, please let me know if that works as what you think.

<pre><code> class Stack(object):

 def __init__(self):
 self.stack = list()

 self.first_length = 0
 self.second_length = 0
 self.third_length = 0

 self.first_pointer = 0
 self.second_pointer = 1

 def push(self, stack_num, item):

 if stack_num == 1:
 self.first_pointer += 1
 self.second_pointer += 1
 self.first_length += 1
 self.stack.insert(0, item)

 elif stack_num == 2:
 self.second_length += 1
 self.second_pointer += 1
 self.stack.insert(self.first_pointer, item)
 elif stack_num == 3:
 self.third_length += 1
 self.stack.insert(self.second_pointer - 1, item)
 else:
 raise Exception('Push failed, stack number %d is not allowd' % stack_num)

 def pop(self, stack_num):
 if stack_num == 1:
 if self.first_length == 0:
 raise Exception('No more element in first stack')
 self.first_pointer -= 1
 self.first_length -= 1
 self.second_pointer -= 1
 return self.stack.pop(0)
 elif stack_num == 2:
 if self.second_length == 0:
 raise Exception('No more element in second stack')
 self.second_length -= 1
 self.second_pointer -= 1
 return self.stack.pop(self.first_pointer)
 elif stack_num == 3:
 if self.third_length == 0:
 raise Exception('No more element in third stack')
 self.third_length -= 1
 return self.stack.pop(self.second_pointer - 1)

 def peek(self, stack_num):
 if stack_num == 1:
 return self.stack[0]
 elif stack_num == 2:
 return self.stack[self.first_pointer]
 elif stack_num == 3:
 return self.stack[self.second_pointer]
 else:
 raise Exception('Peek failed, stack number %d is not allowd' % stack_num)

 def size(self):
 return len(self.items)

s = Stack()

# push item into stack 1
s.push(1, '1st_stack_1')
s.push(1, '2nd_stack_1')
s.push(1, '3rd_stack_1')
#
## push item into stack 2
s.push(2, 'first_stack_2')
s.push(2, 'second_stack_2')
s.push(2, 'third_stack_2')
#
## push item into stack 3
s.push(3, 'FIRST_stack_3')
s.push(3, 'SECOND_stack_3')
s.push(3, 'THIRD_stack_3')
#
print 'Before pop out: '
for i, elm in enumerate(s.stack):
 print '\t\t%d)' % i, elm

#
s.pop(1)
s.pop(1)
#s.pop(1)
s.pop(2)
s.pop(2)
#s.pop(2)
#s.pop(3)
s.pop(3)
s.pop(3)
#s.pop(3)
#
print 'After pop out: '
#
for i, elm in enumerate(s.stack):
 print '\t\t%d)' % i, elm
</code></pre>

blocks|key|59596|text|一个相当愚蠢但有效的解决方案可能是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|59597|59598|将第一个堆栈元素存储在i*3位置:+0,3,6，...|unordered-list-item|offset|length|style|CODE|59599|将第二个堆栈元素存储在i*3%2B1位置:1，4，7...|59600|和第三个堆栈元素存储在i*3%2B2位置。<代码>H29<代码>F210|59601|59602|这种解决方案的问题是，使用的内存总是最深堆栈大小的三倍，即使数组中有可用的位置，也可能会溢出。|59603|entityMap^0|0|0|B|3|0|B|5|0|B|5|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|T|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|U|8|@$F|V|G|W|H|I]]|9|@]|A|$]]|$1|J|3|K|5|E|7|X|8|@$F|Y|G|Z|H|I]]|9|@]|A|$]]|$1|L|3|M|5|E|7|10|8|@$F|11|G|12|H|I]]|9|@]|A|$]]|$1|N|3|-4|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|14|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|R|$]]

A rather silly but effective solution could be:

<ul>
<li>Store the first stack elements at <code>i*3</code> positions: 0,3,6,...</li>
<li>Store the second stack elements at <code>i*3+1</code> positions: 1,4,7...</li>
<li>And third stack elements at <code>i*3+2</code> positions.</li>
</ul>

The problem with this solution is that the used memory will be always three times the size of the deepest stack and that you can overflow even when there are available positions at the array.

blocks|key|2699417|text|这可能会对你有一点帮助……我自己写的:)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2699418|​|2699419|//+by+ashakiran+bhatter
//+compile:+g%2B%2B+-std=c%2B%2B11+test.cpp
//+run++++:+./a.out
//+sample+output+as+below
//+adding:++1+2+3+4+5+6+7+8+9
//+array+contents:++9+8+7+6+5+4+3+2+1
//+popping+now...
//+array+contents:++8+7+6+5+4+3+2+1


#include+<iostream>
#include+<cstdint>

#define+MAX_LEN+9
#define+LOWER+++0
#define+UPPER+++1
#define+FULL+++-1
#define+NOT_SET+-1

class+CStack
{
private:
+++++int8_t+array[MAX_LEN];
+++++int8_t+stack1_range[2];
+++++int8_t+stack2_range[2];
+++++int8_t+stack3_range[2];
+++++int8_t+stack1_size;
+++++int8_t+stack2_size;
+++++int8_t+stack3_size;
+++++int8_t+stack1_cursize;
+++++int8_t+stack2_cursize;
+++++int8_t+stack3_cursize;
+++++int8_t+stack1_curpos;
+++++int8_t+stack2_curpos;
+++++int8_t+stack3_curpos;
public:
+++++CStack();
++++~CStack();

+++++void+push(int8_t+data);
+++++void+pop();
+++++void+print();
};

CStack::CStack()
{
+++++stack1_range[LOWER]+=+0;
+++++stack1_range[UPPER]+=+MAX_LEN/3+-+1;
+++++stack2_range[LOWER]+=+MAX_LEN/3;
+++++stack2_range[UPPER]+=+(2+*+(MAX_LEN/3))+-+1;
+++++stack3_range[LOWER]+=+2+*+(MAX_LEN/3);
+++++stack3_range[UPPER]+=+MAX_LEN+-+1;

+++++stack1_size+=+stack1_range[UPPER]+-+stack1_range[LOWER];
+++++stack2_size+=+stack2_range[UPPER]+-+stack2_range[LOWER];
+++++stack3_size+=+stack3_range[UPPER]+-+stack3_range[LOWER];

+++++stack1_cursize+=+stack1_size;
+++++stack2_cursize+=+stack2_size;
+++++stack3_cursize+=+stack3_size;

+++++stack1_curpos+=+stack1_cursize;
+++++stack2_curpos+=+stack2_cursize;
+++++stack3_curpos+=+stack3_cursize;
}

CStack::~CStack()
{
}

void+CStack::push(int8_t+data)
{
+++++if(stack3_cursize+!=+FULL)+
+++++{
++++++++++array[stack3_range[LOWER]+%2B+stack3_curpos--]+=+data;
++++++++++stack3_cursize--;
+++++}+else+if(stack2_cursize+!=+FULL)+{
++++++++++array[stack2_range[LOWER]+%2B+stack2_curpos--]+=+data;
++++++++++stack2_cursize--;
+++++}+else+if(stack1_cursize+!=+FULL)+{+++
++++++++++array[stack1_range[LOWER]+%2B+stack1_curpos--]+=+data;
++++++++++stack1_cursize--;
+++++}+else+{
++++++++++std::cout<<"\tstack+is+full...!"<<std::endl;
+++++}
}

void+CStack::pop()
{
+++++std::cout<<"popping+now..."<<std::endl;
+++++if(stack1_cursize+<+stack1_size)
+++++{
++++++++++array[stack1_range[LOWER]+%2B+%2B%2Bstack1_curpos]+=+0;+
++++++++++stack1_cursize%2B%2B;
+++++}+else+if(stack2_cursize+<+stack2_size)+{
++++++++++array[stack2_range[LOWER]+%2B+%2B%2Bstack2_curpos]+=+0;
++++++++++stack2_cursize%2B%2B;
+++++}+else+if(stack3_cursize+<+stack3_size)+{
++++++++++array[stack3_range[LOWER]+%2B+%2B%2Bstack3_curpos]+=+0;
++++++++++stack3_cursize%2B%2B;
+++++}+else+{
++++++++++std::cout<<"\tstack+is+empty...!"<<std::endl;
+++++}
}

void+CStack::print()
{
+++++std::cout<<"array+contents:+";
+++++for(int8_t+i+=+stack1_range[LOWER]+%2B+stack1_curpos+%2B+1;+i+<=++stack1_range[UPPER];+i%2B%2B)
++++++++++std::cout<<"+"<<static_cast<int>(array[i]);
+++++for(int8_t+i+=+stack2_range[LOWER]+%2B+stack2_curpos+%2B+1;+i+<=++stack2_range[UPPER];+i%2B%2B)
++++++++++std::cout<<"+"<<static_cast<int>(array[i]);
+++++for(int8_t+i+=+stack3_range[LOWER]+%2B+stack3_curpos+%2B+1;+i+<=++stack3_range[UPPER];+i%2B%2B)
++++++++++std::cout<<"+"<<static_cast<int>(array[i]);
+++++std::cout<<"\n";++++
}

int+main()
{
+++++CStack+stack;

+++++std::cout<<"adding:+";
+++++for(uint8_t+i+=+1;+i+<+10;+i%2B%2B)+
+++++{
++++++++++std::cout<<"+"<<static_cast<int>(i);
++++++++++stack.push(i);
+++++}
+++++std::cout<<"\n";

+++++stack.print();

+++++stack.pop();

+++++stack.print();


+++++return+0;
}|code-block|syntax|javascript|2699420|2699421|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

May be this can help you a bit...i wrote it by myself
:)

<div class="snippet" data-lang="js" data-hide="false">
<div class="snippet-code">
<pre class="snippet-code-html lang-html prettyprint-override"><code>// by ashakiran bhatter
// compile: g++ -std=c++11 test.cpp
// run : ./a.out
// sample output as below
// adding: 1 2 3 4 5 6 7 8 9
// array contents: 9 8 7 6 5 4 3 2 1
// popping now...
// array contents: 8 7 6 5 4 3 2 1


#include &lt;iostream&gt;
#include &lt;cstdint&gt;

#define MAX_LEN 9
#define LOWER 0
#define UPPER 1
#define FULL -1
#define NOT_SET -1

class CStack
{
private:
 int8_t array[MAX_LEN];
 int8_t stack1_range[2];
 int8_t stack2_range[2];
 int8_t stack3_range[2];
 int8_t stack1_size;
 int8_t stack2_size;
 int8_t stack3_size;
 int8_t stack1_cursize;
 int8_t stack2_cursize;
 int8_t stack3_cursize;
 int8_t stack1_curpos;
 int8_t stack2_curpos;
 int8_t stack3_curpos;
public:
 CStack();
 ~CStack();

 void push(int8_t data);
 void pop();
 void print();
};

CStack::CStack()
{
 stack1_range[LOWER] = 0;
 stack1_range[UPPER] = MAX_LEN/3 - 1;
 stack2_range[LOWER] = MAX_LEN/3;
 stack2_range[UPPER] = (2 * (MAX_LEN/3)) - 1;
 stack3_range[LOWER] = 2 * (MAX_LEN/3);
 stack3_range[UPPER] = MAX_LEN - 1;

 stack1_size = stack1_range[UPPER] - stack1_range[LOWER];
 stack2_size = stack2_range[UPPER] - stack2_range[LOWER];
 stack3_size = stack3_range[UPPER] - stack3_range[LOWER];

 stack1_cursize = stack1_size;
 stack2_cursize = stack2_size;
 stack3_cursize = stack3_size;

 stack1_curpos = stack1_cursize;
 stack2_curpos = stack2_cursize;
 stack3_curpos = stack3_cursize;
}

CStack::~CStack()
{
}

void CStack::push(int8_t data)
{
 if(stack3_cursize != FULL) 
 {
 array[stack3_range[LOWER] + stack3_curpos--] = data;
 stack3_cursize--;
 } else if(stack2_cursize != FULL) {
 array[stack2_range[LOWER] + stack2_curpos--] = data;
 stack2_cursize--;
 } else if(stack1_cursize != FULL) { 
 array[stack1_range[LOWER] + stack1_curpos--] = data;
 stack1_cursize--;
 } else {
 std::cout&lt;&lt;"\tstack is full...!"&lt;&lt;std::endl;
 }
}

void CStack::pop()
{
 std::cout&lt;&lt;"popping now..."&lt;&lt;std::endl;
 if(stack1_cursize &lt; stack1_size)
 {
 array[stack1_range[LOWER] + ++stack1_curpos] = 0; 
 stack1_cursize++;
 } else if(stack2_cursize &lt; stack2_size) {
 array[stack2_range[LOWER] + ++stack2_curpos] = 0;
 stack2_cursize++;
 } else if(stack3_cursize &lt; stack3_size) {
 array[stack3_range[LOWER] + ++stack3_curpos] = 0;
 stack3_cursize++;
 } else {
 std::cout&lt;&lt;"\tstack is empty...!"&lt;&lt;std::endl;
 }
}

void CStack::print()
{
 std::cout&lt;&lt;"array contents: ";
 for(int8_t i = stack1_range[LOWER] + stack1_curpos + 1; i &lt;= stack1_range[UPPER]; i++)
 std::cout&lt;&lt;" "&lt;&lt;static_cast&lt;int&gt;(array[i]);
 for(int8_t i = stack2_range[LOWER] + stack2_curpos + 1; i &lt;= stack2_range[UPPER]; i++)
 std::cout&lt;&lt;" "&lt;&lt;static_cast&lt;int&gt;(array[i]);
 for(int8_t i = stack3_range[LOWER] + stack3_curpos + 1; i &lt;= stack3_range[UPPER]; i++)
 std::cout&lt;&lt;" "&lt;&lt;static_cast&lt;int&gt;(array[i]);
 std::cout&lt;&lt;"\n"; 
}

int main()
{
 CStack stack;

 std::cout&lt;&lt;"adding: ";
 for(uint8_t i = 1; i &lt; 10; i++) 
 {
 std::cout&lt;&lt;" "&lt;&lt;static_cast&lt;int&gt;(i);
 stack.push(i);
 }
 std::cout&lt;&lt;"\n";

 stack.print();

 stack.pop();

 stack.print();


 return 0;
}</code></pre>
</div>
</div>

blocks|key|2699457|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2699458|使用开始和结束位置的键创建一个值，例如<+"B1“，0+>，<"E1”，n/3+>|ordered-list-item|2699459|for+each+Push(值)添加一个条件，以检查Bx的位置是否在Ex之前，或者在其间是否有其他"By“。--让我们称之为condition+(2)+|2699460|，如果上面(2)为真//如果B1和E1按顺序{+if+(+S1.Push())，则E1+%2B%2B；else+//溢出的条件，{在E2或E3的末尾开始推送(以空格为准)，并将E1更新为E2--或E3--；}}|2699461|2699462|如果上述(2)为false+{+if+(+S1.Push())，则E1+--；else+//溢出条件，{从E2或E3+(以空格为准)末尾开始推送，并将E1更新为E2--或E3--；}+}|2699463|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|M|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|N|7|@]|8|@]|9|$]]|$1|D|3|E|4|C|6|O|7|@]|8|@]|9|$]]|$1|F|3|G|4|C|6|P|7|@]|8|@]|9|$]]|$1|H|3|-4|4|5|6|Q|7|@]|8|@]|9|$]]|$1|I|3|J|4|5|6|R|7|@]|8|@]|9|$]]|$1|K|3|-4|4|5|6|S|7|@]|8|@]|9|$]]]|L|$]]

<ol>
<li>Make a HashMap with keys to the begin and end positions e.g. &lt; "B1" , 0 >, &lt;"E1" , n/3 ></li>
<li>for each Push(value) add a condition to check if position of Bx is previous to Ex or there is some other "By" in between. -- lets call it condition (2)</li>
<li>with above condition in mind, 
if above (2) is true // if B1 and E1 are in order 
 { if ( S1.Push()), then E1 ++ ;
 else // condition of overflow , 
 { start pushing at end of E2 or E3 (whichever has a space) and update E1 to be E2-- or E3-- ; }
 }

if above (2) is false
 { if ( S1.Push()), then E1 -- ;
 else // condition of overflow , 
 { start pushing at end of E2 or E3 (whichever has a space) and update E1 to be E2-- or E3-- ; }
 }</li>
</ol>

blocks|key|4812444|text|假设你只有整数索引。如果使用FILO+(First+In+Last+Out，先入后出)处理，并且不引用单个，并且仅使用数组作为数据。使用它的6个空间作为堆栈引用应该会有所帮助：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4812445|4812446|+head-1，last-1，head-2，last-2，head-3，head-3，last-3，+_data，数据，...，data_|blockquote|offset|length|style|BOLD|4812447|4812448|4812449|您可以简单地使用4个空格，因为head-1+=0，last-3+=数组长度。如果使用FIFO+(先进先出)，则需要重新索引。|4812450|我正在努力提高我的英语水平。|4812451|entityMap^0|0|0|1|1D|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|S|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|T|8|@$F|U|G|V|H|I]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|W|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|X|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|Y|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|Z|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|Q|$]]

Assume you only has integer index. if it's treated using FILO (First In Last Out) and not referencing individual, and only using an array as data. Using it's 6 space as stack reference should help:

<blockquote>
 [head-1, last-1, head-2, last-2, head-3, last-3, data, data, ... ,data]
</blockquote>

you can simply using 4 space, because head-1 = 0 and last-3 = array length. If using FIFO (First In First Out) you need to re-indexing. 

nb: I’m working on improving my English.

blocks|key|59100|text|也许您可以在单个数组中实现N个堆栈或队列。我对使用单个数组的定义是，我们使用单个数组来存储单个数组中所有堆栈和队列的所有数据，无论如何，我们可以使用其他N个数组来跟踪特定堆栈或队列的所有元素的索引。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|59101|解决方案:在将数据插入任何堆栈或队列期间，将数据顺序存储到数组中。并将其各自的索引存储到该特定堆栈或队列的索引保持数组中。|59102|例如:你有3个栈(s1，s2，s3)，你想用一个数组(dataArray[])来实现它。因此，我们将分别为s1、s2和s3创建另外3个数组(a1[]，a2[]，a3[])，它们将通过保存它们各自的索引来跟踪它们在dataArray[]中的所有元素。|59103|insert(s1,+10)+at+dataArray[0]+a1[0]+=+0;
insert(s2,+20)+at+dataArray[1]+a2[0]+=+1;
insert(s3,+30)+at+dataArray[2]+a3[0]+=+2;
insert(s1,+40)+at+dataArray[3]+a1[1]+=+3;
insert(s3,+50)+at+dataArray[4]+a3[1]+=+4;
insert(s3,+60)+at+dataArray[5]+a3[2]+=+5;
insert(s2,+30)+at+dataArray[6]+a2[1]+=+6;|code-block|syntax|javascript|59104|以此类推。|59105|现在我们将使用dataArray[]中的a1、a2和a3对各自的堆栈和队列执行操作。|59106|要从s1中弹出元素，请返回a1，将所有元素左移|59107|对其他操作也采用类似的方法，您可以在单个数组中实现任意数量的堆栈和队列。|59108|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

Perhaps you can implement N number of stacks or queues in the single array. My defination of using single array is that we are using single array to store all the data of all the stacks and queues in the single array, anyhow we can use other N array to keep track of indices of all elements of particular stack or queue. 

solution : 
store data sequentially to in the array during the time of insertion in any of the stack or queue. and store it's respective index to the index keeping array of that particular stack or queue.

for eg : you have 3 stacks (s1, s2, s3) and you want to implement this using a single array (dataArray[]). Hence we will make 3 other arrays (a1[], a2[], a3[]) for s1, s2 and s3 respectively which will keep track of all of their elements in dataArray[] by saving their respective index. 

<pre><code>insert(s1, 10) at dataArray[0] a1[0] = 0;
insert(s2, 20) at dataArray[1] a2[0] = 1;
insert(s3, 30) at dataArray[2] a3[0] = 2;
insert(s1, 40) at dataArray[3] a1[1] = 3;
insert(s3, 50) at dataArray[4] a3[1] = 4;
insert(s3, 60) at dataArray[5] a3[2] = 5;
insert(s2, 30) at dataArray[6] a2[1] = 6;
</code></pre>

and so on ...

now we will perform operation in dataArray[] by using a1, a2 and a3 for respective stacks and queues.

to pop an element from s1 
 return a1[0]
 shift all elements to left

do similar approach for other operations too and you can implement any number of stacks and queues in the single array.

I came across this problem in an interview website. The problem asks for efficiently implement three stacks in a single array, such that no stack overflows until there is no space left in the entire array space. 

For implementing 2 stacks in an array, it's pretty obvious: 1st stack grows from LEFT to RIGHT, and 2nd stack grows from RIGHT to LEFT; and when the stackTopIndex crosses, it signals an overflow. 

Thanks in advance for your insightful answer.

How to implement three stacks using a single array

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我在一个面试网站上遇到了这个问题。该问题要求在单个数组中有效地实现三个堆栈，以便在整个数组空间中没有剩余空间之前没有堆栈溢出。对于在一个数组中实现两个堆栈，很明显:第一个堆栈从左到右增长，第二个堆栈从右到左增长；当stackTopIndex交叉时，它发出溢出信号。提前感谢你富有洞察力的回答。

问如何使用单个数组实现三个堆栈
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何使用单个数组实现三个堆栈EN