スタック操作のみを使用してスタックをソートする方法は？
この質問をウェブで見つけました。
スタックSが与えられた場合、Cプログラムを記述してスタックを（昇順で）ソートします。スタックの実装方法を想定することはできません。使用される関数は次のとおりです。
Push
Pop
Top
IsEmpty
IsFull
ヒープを構築してソートできると思います。これに対する最適な解決策は何ですか？
ここで許可されている唯一のデータ構造がスタックであると仮定すると、2つのスタックを使用できます。
元のスタックが空になるまで繰り返し、各繰り返しで元のスタックから要素をポップします。2番目のスタックの一番上の要素は削除された要素よりも大きく、2番目のスタックをポップして元のスタックにプッシュします。これで、元々スタックからポップした要素を2番目のスタックにプッシュできます。
このアプローチの時間の複雑さはO（N ^ 2）です。
このアルゴリズムを実装するCコードは次のようになります（私のさびたCのスキルは失礼します）。
void SortStack(struct Stack * orig_stack)
{
struct Stack helper_stack;
while (!IsEmpty(orig_stack))
{
int element = Pop(orig_stack);
while (!IsEmpty(&helper_stack) && Top(&helper_stack) < element)
{
Push(orig_stack, Pop(&helper_stack));
}
Push(&helper_stack, element);
}
while (!IsEmpty(&helper_stack))
{
Push(orig_stack, Pop(&helper_stack));
}
}
これらのスタック操作を前提として、再帰的な挿入ソートを作成できます。
void sort(stack s) {
if (!IsEmpty(s)) {
int x = Pop(s);
sort(s);
insert(s, x);
}
}
void insert(stack s, int x) {
if (!IsEmpty(s)) {
int y = Top(s);
if (x < y) {
Pop(s);
insert(s, x);
Push(s, y);
} else {
Push(s, x);
}
} else {
Push(s, x);
}
}
同じスタックを使用して再帰的に行うことができます。 O（n ^ 2）C++でコーディングしましたが、Cへの変換は簡単です。私はテンプレートが好きで、あなたはあなたの質問にC++のタグを付けました
template<typename T>
void Insert(const T& element, Stack<T>& stack)
{
if(element > stack.Top())
{
T top = stack.Pop();
Insert(element, stack);
stack.Push(top);
}
else
{
stack.Push(element);
}
}
template<typename T>
void StackSort(Stack<T>& stack)
{
if(!stack.IsEmpty())
{
T top = stack.Pop();
StackSort(stack);
Insert(top, stack);
}
}
投票を取り戻すために編集されました！：））
パンケーキソートは、これを行うもう1つの興味深い方法です。 http://en.wikipedia.org/wiki/Pancake_sorting#cite_note-4 。
T33Cの回答からの変更されたコード
（Svanteが言語タグを c ++ から c ）に修正する前に指定：stack.top()は、!stack.empty()の場合にのみチェックできます
void insert(int element, stack<int> &stack) {
if (!stack.empty() && element > stack.top()) {
int top = stack.top();
stack.pop();
insert(element, stack);
stack.Push(top);
}
else {
stack.Push(element);
}
}
void sortStack(stack<int> & stack) {
if (!stack.empty()) {
int top = stack.top();
stack.pop();
sortStack(stack);
insert(top, stack);
}
}
多相マージソートを使用した3スタックソート
これは、3スタックソートを実装する最も速い方法です。目的は、ソートされたスタックからアイテムがポップされるときに、昇順のシーケンスになることです。
多相マージソート（配列を使用）に関するWiki記事：
http://en.wikipedia.org/wiki/Polyphase_merge_sort
ポインター、各スタックのスタックポインターとしてのポインター、各実行の終了と各スタックの終了へのポインターを使用した、3スタックの多相ソートのC++コードの例。実行サイズポインタは、実行サイズが中間スタックを増分または減分するタイミングを追跡するために使用されます。スタック間でデータが転送されるときにシーケンスが降順または昇順である場合、降順シーケンスフラグを使用して追跡します。開始時に初期化され、実行のすべてのペアがマージされた後に交互に実行されます。
typedef unsigned int uint32_t;
static size_t fibtbl[48] =
{ 0, 1, 1, 2, 3, 5,
8, 13, 21, 34, 55, 89,
144, 233, 377, 610, 987, 1597,
2584, 4181, 6765, 10946, 17711, 28657,
46368, 75025, 121393, 196418, 317811, 514229,
832040, 1346269, 2178309, 3524578, 5702887, 9227465,
14930352, 24157817, 39088169, 63245986, 102334155, 165580141,
267914296, 433494437, 701408733,1134903170,1836311903,2971215073};
// binary search: return index of largest fib() <= n
size_t flfib(size_t n)
{
size_t lo = 0;
size_t hi = sizeof(fibtbl)/sizeof(fibtbl[0]);
while((hi - lo) > 1){
size_t i = (lo + hi)/2;
if(n < fibtbl[i]){
hi = i;
continue;
}
if(n > fibtbl[i]){
lo = i;
continue;
}
return i;
}
return lo;
}
// poly phase merge sort array using 3 arrays as stacks, a is source
uint32_t * ppmrg3s(uint32_t a[], uint32_t b[], uint32_t c[], size_t n)
{
if(n < 2)
return a+n;
uint32_t *asp = a; // a stack ptr
uint32_t *aer; // a end run
uint32_t *aes = a + n; // a end
uint32_t *bsp = b + n; // b stack ptr
uint32_t *ber; // b end run
uint32_t *bes = b + n; // b end
uint32_t *csp = c + n; // c stack ptr
uint32_t *ces = c + n; // c end
uint32_t *rsp = 0; // run size change stack ptr
size_t ars = 1; // run sizes
size_t brs = 1;
size_t scv = 0-1; // size change increment / decrement
bool dsf; // == 1 if descending sequence
{ // block for local variable scope
size_t f = flfib(n); // fibtbl[f+1] > n >= fibtbl[f]
dsf = ((f%3) == 0); // init compare flag
if(fibtbl[f] == n){ // if exact fibonacci size, move to b
for(size_t i = 0; i < fibtbl[f-1]; i++)
*(--bsp) = *(asp++);
} else { // else move to b, c
// update compare flag
dsf ^= (n - fibtbl[f]) & 1;
// move excess elements to b
aer = a + n - fibtbl[f];
while (asp < aer)
*(--bsp) = *(asp++);
// move dummy count elements to c
aer = a + fibtbl[f - 1];
while (asp < aer)
*(--csp) = *(asp++);
rsp = csp; // set run size change ptr
}
} // end local variable block
while(1){ // setup to merge pair of runs
if(asp == rsp){ // check for size count change
ars += scv; // (due to dummy run size == 0)
scv = 0-scv;
rsp = csp;
}
if(bsp == rsp){
brs += scv;
scv = 0-scv;
rsp = csp;
}
aer = asp + ars; // init end run ptrs
ber = bsp + brs;
while(1){ // merging pair of runs
if(dsf ^ (*asp <= *bsp)){ // if a <= b
*(--csp) = *(asp++); // move a to c
if(asp != aer) // if not end a run
continue; // continue back to compare
do // else move rest of b run to c
*(--csp) = *(bsp++);
while (bsp < ber);
break; // and break
} else { // else a > b
*(--csp) = *(bsp++); // move b to c
if(bsp != ber) // if not end b run
continue; // continue back to compare
do // else move rest of a run to c
*(--csp) = *(asp++);
while (asp < aer);
break; // and break
}
} // end merging pair of runs
dsf ^= 1; // toggle compare flag
if(bsp == bes){ // if b empty
if(asp == aes) // if a empty, done
break;
std::swap(bsp, csp); // swap b, c
std::swap(bes, ces);
brs += ars; // update run size
} else { // else b not empty
if(asp != aes) // if a not empty
continue; // continue back to setup next merge
std::swap(asp, csp); // swap a, c
std::swap(aes, ces);
ars += brs; // update run size
}
}
return csp; // return ptr to sorted array
}
例Javaスワップ関数を含むカスタムスタッククラス（xstack）を使用してソートするためのコード。
static final int[] FIBTBL =
{ 0, 1, 1, 2, 3, 5,
8, 13, 21, 34, 55, 89,
144, 233, 377, 610, 987, 1597,
2584, 4181, 6765, 10946, 17711, 28657,
46368, 75025, 121393, 196418, 317811, 514229,
832040, 1346269, 2178309, 3524578, 5702887, 9227465,
14930352, 24157817, 39088169, 63245986, 102334155, 165580141,
267914296, 433494437, 701408733,1134903170,1836311903};
// return index of largest fib() <= n
static int flfib(int n)
{
int lo = 0;
int hi = 47;
while((hi - lo) > 1){
int i = (lo + hi)/2;
if(n < FIBTBL[i]){
hi = i;
continue;
}
if(n > FIBTBL[i]){
lo = i;
continue;
}
return i;
}
return lo;
}
// poly phase merge sort using 3 stacks
static void ppmrg3s(xstack a, xstack b, xstack c)
{
if(a.size() < 2)
return;
int ars = 1; // init run sizes
int brs = 1;
int asc = 0; // no size change
int bsc = 0;
int csc = 0;
int scv = 0-1; // size change value
boolean dsf; // == 1 if descending sequence
{ // block for local variable scope
int f = flfib(a.size()); // FIBTBL[f+1] > size >= FIBTBL[f]
dsf = ((f%3) == 0); // init compare flag
if(FIBTBL[f] == a.size()){ // if exact fibonacci size,
for (int i = 0; i < FIBTBL[f - 1]; i++) { // move to b
b.Push(a.pop());
}
} else { // else move to b, c
// update compare flag
dsf ^= 1 == ((a.size() - FIBTBL[f]) & 1);
// i = excess run count
int i = a.size() - FIBTBL[f];
// j = dummy run count
int j = FIBTBL[f + 1] - a.size();
// move excess elements to b
do{
b.Push(a.pop());
}while(0 != --i);
// move dummy count elements to c
do{
c.Push(a.pop());
}while(0 != --j);
csc = c.size();
}
} // end block
while(true){ // setup to merge pair of runs
if(asc == a.size()){ // check for size count change
ars += scv; // (due to dummy run size == 0)
scv = 0-scv;
asc = 0;
csc = c.size();
}
if(bsc == b.size()){
brs += scv;
scv = 0-scv;
bsc = 0;
csc = c.size();
}
int arc = ars; // init run counters
int brc = brs;
while(true){ // merging pair of runs
if(dsf ^ (a.peek() <= b.peek())){
c.Push(a.pop()); // move a to c
if(--arc != 0) // if not end a
continue; // continue back to compare
do{ // else move rest of b run to c
c.Push(b.pop());
}while(0 != --brc);
break; // and break
} else {
c.Push(b.pop()); // move b to c
if(0 != --brc) // if not end b
continue; // continue back to compare
do{ // else move rest of a run to c
c.Push(a.pop());
}while(0 != --arc);
break; // and break
}
} // end merging pair of runs
dsf ^= true; // toggle compare flag
if(b.empty()){ // if end b
if(a.empty()) // if end a, done
break;
b.swap(c); // swap b, c
brs += ars;
if (0 == asc)
bsc = csc;
} else { // else not end b
if(!a.empty()) // if not end a
continue; // continue back to setup next merge
a.swap(c); // swap a, c
ars += brs;
if (0 == bsc)
asc = csc;
}
}
a.swap(c); // return sorted stack in a
}
3スタックのゲーム
3つのスタックS（ソーススタック、要素が並べ替えられていないスタック）、A、Bを使用すると、マージソートと同様のゲームをプレイできます。
AとBで要素を（同じ方向に、両方とも昇順または両方とも降順で）順序付けした場合、Sを使用してソートAとBをマージし、結果をBなどに移動できることは明らかだと思います。
A、B、Sにいくつかの要素があるという事実は、A、B、Sの現在のサイズのマーカーがあり、オーバーシュートしない）。手順がSに順序付けられた要素をもたらす場合、AおよびBを使用して、AまたはBへのソートされた部分を任意の方向に削除するのは簡単ではありません。AまたはBに逆順で直接配置することも、たとえば、 、すべての要素をAに配置してから、もう一度Bに反転します。
Aに4つのソート済みエレメント、Bに16個、Sに未ソートのエレメントがあると想定します。
A.Push（S.pop）を実行して、2要素のソートされたマージを作成します。再びB.Push（S.pop）を実行して、別の1つの2要素ソートマージを作成します。マージが分離されていないか、同じ方向でない場合は、B（またはS）で4要素のソートされたマージに到達するまで、エレメントを好きなように操作できます。次に、Aからの最初の4要素のソートされたマージとBのその部分を、8要素のソートされたマージに達するまでマージします。
別の8要素のソート済みマージを作成するまで、すべてを繰り返します。それをB（またはS）に正しい順序で配置し、16要素でソートされたマージを取得するためにマージします。次に、それをA（またはS）に配置し、Bで行っていた16要素のマージとマージします。
あるスタックから別のスタックへのソート済みマージの移動（復帰）を減らす必要があるため、最適化された実装はトリッキーです。ただし、A、B、およびSを使用して何を修正するかを決定し、たとえば、Aに降順で小さいマージされた部分とB大きいマージされた部分を含めるように強制した場合、アルゴリズムはより単純になります。
あるスタックから別のスタックにいくつかの上位要素を移動する必要があるという事実は、一定の係数を複雑さに追加していますが、2を超えることはありません。それ以外は、複雑度はn * log（n）です（2n要素に到達します） 2つのn要素のソートされたマージをマージすることによるソートされたマージ、およびマージに必要なステップは2n以下です。
C＃での実装（他の同様の言語は明らかです）
void Stacking(Stack<int> sourceStack, Stack<int> mainStack, Stack<int> childStack, int n)
{
if (n == 0) return;
if (n == 1)
{
mainStack.Push(sourceStack.Pop());
return;
}
int mainSize = n/2;
int childSize = n - n/2;
Stacking(sourceStack, mainStack, childStack, mainSize);
Stacking(sourceStack, childStack, mainStack, childSize);
while (true)
{
while (mainSize > 0 && mainStack.Peek() >= childStack.Peek())
{
sourceStack.Push(mainStack.Pop());
mainSize--;
}
if (mainSize == 0) break;
while (childSize > 0 && childStack.Peek() >= mainStack.Peek())
{
sourceStack.Push(childStack.Pop());
childSize--;
}
if (childSize == 0) break;
}
while (mainSize > 0)
{
sourceStack.Push(mainStack.Pop());
mainSize--;
}
while (childSize > 0)
{
sourceStack.Push(childStack.Pop());
childSize--;
}
for (int i = 0; i < n; i++)
mainStack.Push(sourceStack.Pop());
}
void SortStack(Stack<int> sourceStack)
{
int n = sourceStack.Count();
// possible optimization: if (n < 2) return;
Stack<int> mainStack = new Stack<int>();
Stack<int> childStack = new Stack<int>();
Stacking(sourceStack, mainStack, childStack, n);
for (int i = 0; i < n; i++)
sourceStack.Push(mainStack.Pop());
}
Log（n）スタックのゲーム
ほとんどのlog（n）スタックの使用が許可されている場合、上記の手順は簡略化できます。このスタック数は、nの次数よりも大きい追加のスペースを使用することを意味するものではありません。 1、2、4 ...要素のマージに使用されるスタックをマークするだけです。この場合、2 ^ nのマージ部分は常に同じ方向にソートされるため、順序は気にしません。ただし、このソリューションは、プッシュとポップ操作の使用に制限されているという事実を回避するだけです。それ以外は、すべての面でマージソートと同等です。本質的に、スタックの数が制限されていなければ、クイックソートも簡単にエミュレートできます。
class Program
{
static void Main(string[] args)
{
Stack<int> stack = new Stack<int>();
stack.Push(8);
stack.Push(5);
stack.Push(3);
stack.Push(4);
stack.Push(7);
stack.Push(9);
stack.Push(5);
stack.Push(6);
Stack<int> tempStack = new Stack<int>();
while (stack.Count > 0)
{
int temp = stack.Pop();
while(tempStack.Count>0 && tempStack.Peek() > temp)
{
stack.Push(tempStack.Pop());
}
tempStack.Push(temp);
}
while (tempStack.Count > 0)
{
Console.Write(tempStack.Pop() + " ");
}
Console.ReadLine();
}
}
バブルソートは再帰的にスタックで機能すると思います。
void sortStack(stack<int>& st){
bool flag = true;
int n = st.size();
for(int i = 1; i <= n - 1 && flag; i++){
flag = false;
bubbleSortStack(st, flag, i);
}
}
void bubbleSortStack(stack<int>& st, bool& flag, int endSize){
if(st.size() == endSize)
return;
int val = st.top();
st.pop();
if(val > st.top()){
flag = true;
int tmp = st.top();
st.Push(val);
val = tmp;
}
bubbleSortStack(st, flag);
st.Push(val);
}
使用できる追加のスタックの数については何も述べられていないため、並べ替えの問題を可能な限り効率的に解決するために、任意の数のスタックを使用できると想定しています。
ここでスタック制約を忘れて、これが通常のソートの問題であると仮定した場合。では、どうすればそれを解決できますか？ （ヒント：マージソート）
補助スタックを使用して、スタックで通常のマージソートを実行します。時間の複雑さ-N * log（n）。
注マイケルJ.バーバーの回答（上記を参照）は正しくありません。空の場合、要素をスタックにプッシュし忘れます。正しいバージョンは次のとおりです。
void sort(stack s) {
if (!IsEmpty(s)) {
int x = Pop(s);
sort(s);
insert(s, x);
}
}
void insert(stack s, int x) {
if (!IsEmpty(s)) {
int y = Top(s);
if (x < y) {
Pop(s);
insert(s, x);
Push(s, y);
} else {
Push(s, x);
}
} else {
Push(s, x); // !!! must step, otherwise, the stack will eventually be empty after sorting !!!
}
}
@OrenDによって与えられた答えに基づくJavascriptでのソリューションは次のとおりです
var org = [4,67,2,9,5,11,3];
var helper = [];
while(org.length > 0){
var temp = org.pop();
while((helper.length > 0) && (helper[helper.length-1] < temp)){
org.Push(helper.pop());
}
helper.Push(temp);
}
while(helper.length > 0){
org.Push(helper.pop());
}
/* the basic idea is we go on
* popping one element (o) from the original stack (s) and we
* compare it with the new stack (temp)
* if o (the popped element from original stack)
* is < the peek element from new stack temp
* then we Push the new stack element to original stack
* and recursively keep calling till temp is not empty
* and then Push the element at the right place.
* else we Push the element to the new stack temp
* (o >= new temp stack.
*
* Entire logic is recursive.
*/
public void sortstk( Stack s )
{
Stack<Integer> temp = new Stack<Integer>();
while( !s.isEmpty() )
{
int s1 = (int) s.pop();
while( !temp.isEmpty() && (temp.peek() > s1) )
{
s.Push( temp.pop() );
}
temp.Push( s1 );
}
// Print the entire sorted stack from temp stack
for( int i = 0; i < temp.size(); i++ )
{
System.out.println( temp.elementAt( i ) );
}
}
スタックの内容に関する追加情報がない場合は、すべてのデータを取り出し、並べ替えて、元に戻すだけでかなり困っています。クイックソートやイントロソートと同様に、ここではヒープソートが最適です。
他のデータ構造の使用に制限がない場合は、最小ヒープと言います。スタックから要素をポップするときはいつでも、ヒープに入れます。ポップが完了したら、要素をヒープの最上部（残りの最小値）から取得してスタックにプッシュします。ヒープが空になるまでこのようなプロセスを繰り返します。
ヒープを作成する場合、平均時間はO（nlogn）です。ヒープから要素を削除し、要素を昇順に戻す場合、平均時間もO(nlogn)です。
それはどのように見えますか？