双栈排序

题目描述

请编写一个程序，按升序对栈进行排序（即最大元素位于栈顶），要求最多只能使用一个额外的栈存放临时数据，但不得将元素复制到别的数据结构中。
给定一个int[] numbers(C++中为vector&ltint>)，其中第一个元素为栈顶，请返回排序后的栈。请注意这是一个栈，意味着排序过程中你只能访问到第一个元素。
测试样例：
[1,2,3,4,5]
返回：[5,4,3,2,1]

思路：迫于题目要求，只能使用两个栈，可以想到一个栈存放有序数列，另一个栈buffer存放无序的其它数列，，可以另外定义一个整形变量tmp，用排序时的数据交换，
排序：
》》1 ，从buffer中取出（pop）一个元素，放到tmp，和有序栈栈顶的元素比较（每次只能访问栈的栈顶元素）；若小于栈顶元素，则有序栈栈顶元素出栈 到 buffer，同时记下出栈元素个数，依次继续比较，直到小于不成立，
》》2，根据出栈元素个数，将buffer中元素 返回到有序栈，一次循环结束

Java

import java.util.*;public class TwoStacks {    public ArrayList<Integer> twoStacksSort(int[] numbers) {        // write code here        if(numbers == null && numbers.length==0)return null;        ArrayList<Integer> arrlist=new ArrayList<Integer>(numbers.length);         Stack<Integer> sta = new Stack<Integer>();        Stack<Integer> buffer = new Stack<Integer>();        int  i=0,tmp=0;         while( i < numbers.length )            {            buffer.push(numbers[i]);            i++;         }         while(buffer.isEmpty()!=true){            tmp = buffer.pop();//一定要pop 不能peek（）            int count=0;  //while(tmp < sta.peek()&&sta.isEmpty()!=true)//这样会出异常，一定要判断在前，比较在后             while(sta.isEmpty() != true && tmp < sta.peek())              {                 buffer.push(sta.peek());                sta.pop();                count++;//出栈元素数 统计，，然后依此数逐个返回原栈              }                sta.push(tmp);             for(i = 0;i < count;i++) {                 sta.push(buffer.pop());                }         }        for( i = 0;i < numbers.length;i++){            arrlist.add(sta.pop());           // sta.pop();        }        return arrlist;    }}

C/C++
思路一样，，只是采取了vector 容器的方式，vector顺序容器的基本操作，访问、添加、删除等。push_back(t) ,push_front(t) , back（），pop_back(),,等
说明
　　vector是一种动态数组，是基本数组的类模板。其内部定义了很多基本操作。
　　＃include 注意：头文件没有“.h”
构造：
　　这个构造函数还有一个可选的参数，这是一个类型为T的实例，描述了各个向量种各成员的初始值；
　　如：vectorv2(init_size,0); 如果预先定义了：intinit_size;他的成员值都被初始化为0；
　　· 复制构造函数，构造一个新的向量，作为已存在的向量的完全复制;
　　如：vectorv3(v2);
　　· 带两个常量参数的构造函数，产生初始值为一个区间的向量。区间由一个半开区间first,last来指定。
　　如：vectorv4（first,last） vector v1;
　　vectorv2(init_size,0);
　　vectorv3(v2);
方法：
　　c.assign(beg,end)c.assign(n,elem)　将(beg; end)区间中的数据赋值给c。将n个elem的拷贝赋值给c。
　　c. at(idx)　传回索引idx所指的数据，如果idx越界，抛出out_of_range。
　　c.back()　传回最后一个数据，不检查这个数据是否存在。
　　c.begin()　传回迭代器中的第一个数据地址。
　　c.capacity()　返回容器中数据个数。
　　c.clear()　移除容器中所有数据。
　　c.empty()　判断容器是否为空。
　　c.end() // 指向迭代器中末端元素的下一个，指向一个不存在元素。
　　c.erase(pos)// 删除pos位置的数据，传回下一个数据的位置。
　　c.erase(beg,end)　删除[beg,end)区间的数据，传回下一个数据的位置。
　　c.front()　传回第一个数据。
　　get_allocator　使用构造函数返回一个拷贝。
　　c.insert(pos,elem)// 在pos位置插入一个elem拷贝，传回新数据位置　
　　c.insert(pos,n,elem)// 在pos位置插入n个elem数据,无返回值　
　　c.insert(pos,beg,end)// 在pos位置插入在[beg,end)区间的数据。无返回值　
　　c.max_size()　返回容器中最大数据的数量。　
　　c.pop_back()　删除最后一个数据。　
　　c.push_back(elem)　在尾部加入一个数据。　
　　c.rbegin()　传回一个逆向队列的第一个数据。　
　　c.rend()　传回一个逆向队列的最后一个数据的下一个位置。　
　　c.resize(num)　重新指定队列的长度。　
　　c.reserve()　保留适当的容量。　
　　c.size()　返回容器中实际数据的个数。　
　　c1.swap(c2)// 将c1和c2元素互换
　　参考链接

class TwoStacks {public:    vector<int> twoStacksSort(vector<int> numbers) {        // write code here           vector<int> forSort;            if(numbers.size() <= 1) return numbers;            forSort.push_back(numbers.back());            numbers.pop_back();            while(numbers.size() > 0)            {                int temp = numbers.back();                numbers.pop_back();                int count = 0;  // 出栈元素的数量                while(!forSort.empty() && temp < forSort.back()){                    numbers.push_back(forSort.back());                    forSort.pop_back();                    count++;                }                forSort.push_back(temp);                for(int i = 0 ; i < count ;i ++ ){                    forSort.push_back(numbers.back());//不可以直接pop_back()，，类似于C里面的pop()                    numbers.pop_back();                }            }            reverse(forSort.begin(),forSort.end());            return forSort;    }};

这个是网上的另外一种解法，，可以减少循环次数，，

public ArrayList<Integer> twoStacksSort(int[] numbers) {    /*     * 思路：     * 只用两个栈排序，一个是有序的asc，另一个是无序的buffer就可以实现对一个栈的排序。如何有序，当原始栈只有一个时就有序了     * numbers中第一个为栈顶     * 主要是解决buffer栈顶元素放在asc的位置     * 1. buffer栈顶大于等于asc栈顶或asc空     *  直接放     * 2. buffer栈顶小于asc栈顶     *  buffer栈顶值出栈，临时变量存放buffer栈顶值     *  循环从asc中拿出值放到buffer直至asc空或满足1条件     */    if(numbers == null || numbers.length == 0){        return null;    }    int length = numbers.length;    ArrayList<Integer> res = new ArrayList<Integer>(length);    Stack<Integer> buffer = new Stack<Integer>();    Stack<Integer> ascStack = new Stack<Integer>();    //初始状态，buffer中放了length-1个与numbers逆序的数串，asc只剩栈底元素    for(int i = 0; i < length-1; i++){        buffer.push(numbers[i]);    }    ascStack.push(numbers[length-1]);    //排序    int bufTop = 0;    while(buffer.size() > 0){        if(ascStack.isEmpty() || buffer.peek() >= ascStack.peek()){            ascStack.push(buffer.pop());        }        else{//这里一定要加else ，            bufTop = buffer.pop();            int count_curBuffer = buffer.size();            while(!ascStack.isEmpty() && bufTop < ascStack.peek()){                buffer.push(ascStack.pop());            }            ascStack.push(bufTop);            int count_numsFromAsc = buffer.size()-count_curBuffer;            for(int i = 0; i < count_numsFromAsc; i++){                ascStack.push(buffer.pop());            }        }    }    for(int i = 0; i < length; i++){        res.add(ascStack.pop());    }    return res;}