#ifndef __STACK_SORT_H__

#define __STACK_SORT_H__
/*
优化说明:
1. 去掉递归
2. 排序栈可以由外部管理, 不需要每次都new delete
3. 支持双向排序
4. 排序携带数据类型
 
 
 
*/
template <class T, class datatype=void*>
struct sort_item
{
    T value;
    datatype d;
    inline bool operator < (const sort_item<T,datatype>& v)
    {
        return (value < v.value);
    }
    inline bool operator > (const sort_item<T,datatype>& v)
    {
        return (value > v.value);
    }
    inline bool operator ==(const sort_item<T,datatype>& v)
    {
        return (value == v.value);
    }
    inline bool operator <=(const sort_item<T,datatype>& v)
    {
        return (value <= v.value);
    }
    inline bool operator >=(const sort_item<T,datatype>& v)
    {
        return (value >= v.value);
    }
};
 
template <class T, class datatype>
inline void swap(sort_item<T, datatype>* a, sort_item<T, datatype>* b)
{
    if(a == b)
        return;
    sort_item<T, datatype> t;
    t = *a;
    *a = *b;
    *b = t;
}
 
template<class T>
class sort_stack
{
public:
    sort_stack(int size)
    {
        m_size = size;
        m_p = new T[m_size];
        m_index = -1;
    }
    ~sort_stack()
    {
        if(m_p)
        {
            delete m_p;
        }
        m_p = 0;
        m_size = 0;
        m_index = 0;
    }
    inline void pop()
    {
        if(m_index >= 0)
            m_index --;
    }
    inline T top()
    {
        if(m_index>=0)
            return m_p[m_index];
        T t;
        memset(&t, 0, sizeof(t));
        return t;
    }
    inline void push(T t)
    {
        if((m_index+1) < m_size)
        {
            m_index ++;
            m_p[m_index] = t;
        }
    }
    inline int size()
    {
        if(m_index>=0)
            return (m_index+1);
        return 0;
    }
    inline bool empty()
    {
        return (m_index<0);
    }
    inline void reset()
    {
        m_index = -1;
    }
private:
    T*  m_p;
    int m_size;
    int m_index;
};
 
template <class T, class datatype>
struct sort_param{
    sort_item<T,datatype>* a;
    int n;
};
 
template <class T, class datatype>
inline void stack_sort(sort_item<T,datatype>* a, int n, bool dir=true, sort_stack< sort_param<T,datatype> >* p_stack=0)
{
    sort_stack< sort_param<T,datatype> >* ptemp = 0;
    if(p_stack)
        ptemp = p_stack;
    else
        ptemp = new sort_stack< sort_param<T,datatype> >(n);
 
    sort_stack< sort_param<T,datatype> >& sp = *ptemp;
    sort_param<T,datatype> pm;
 
    if(dir)
    {
        for(;;){
            if( n<=2 ){
                if( n==2 && a[1] < a[0])
                    swap(a, a+1);
                if(sp.empty())
                    break;
                pm = sp.top();
                sp.pop();
                a = pm.a;
                n = pm.n;
                continue;
            }
            swap( a, a+(n>>1) );
            sort_item<T,datatype> pivot=*a;
            sort_item<T,datatype>* l=a+1;
            sort_item<T,datatype>* r=a+n-1;
            while( l<r )
            {
                while(l<r && *l<pivot)
                    l++;
                while( r>a && *r>=pivot)
                    r--;
                if( l<r )
                    swap( l, r );
            }
            if(*a > *r)
                swap( a, r );
            pm.a=r+1;
            pm.n=n-1-(r-a);
            sp.push(pm);
            n = r-a;
        }
    }
    else
    {
        for(;;){
            if( n<=2 ){
                if(n==2 && a[1] > a[0])
                    swap(a, a+1);
                if(sp.empty())
                    break;
                pm = sp.top();
                sp.pop();
                a = pm.a;
                n = pm.n;
                continue;
            }
            swap( a, a+(n>>1) );
            sort_item<T,datatype> pivot=*a;
            sort_item<T,datatype>* l=a+1;
            sort_item<T,datatype>* r=a+n-1;
            while(l < r)
            {
                while(l<r && *l>pivot)
                    l++;
                while( r>a && *r<=pivot)
                    r--;
                if( l<r )
                    swap( l, r );
            }
 
            if(*a < *r)
                swap( a, r );
            pm.a=r+1;
            pm.n=n-1-(r-a);
            sp.push(pm);
            n = r-a;
        }
    }
    if(!p_stack)
        delete ptemp;
    ptemp = 0;
}
 
template<class T, class datatype=void*>
class sort_buff_helper
{
public:
    sort_item<T,datatype>*      m_sort_buff;
    int                         m_max;
    sort_buff_helper()
    {
        m_max = 0;
        m_sort_buff = 0;
        m_sort_stack = 0;
    }
    void create(int n)
    {
        if(n<m_max)
            return;
        if(m_sort_buff)
            delete m_sort_buff;
        if(m_sort_stack)
            delete m_sort_stack;
        m_max = n;
        m_sort_stack = new sort_stack< sort_param<T,datatype>>(m_max);
        m_sort_buff  = new sort_item<T,datatype>[m_max];
    }
    void clear()
    {
        if(m_sort_buff)
            delete m_sort_buff;
        if(m_sort_stack)
            delete m_sort_stack;
        m_max = 0;
        m_sort_buff = 0;
        m_sort_stack = 0;
    }
    inline sort_item<T,datatype>& operator [] (int index)
    {
        return m_sort_buff[index];
    }
    sort_stack< sort_param<T,datatype>>* get_stack()
    {
        return m_sort_stack;
    }
private:
    sort_stack< sort_param<T,datatype>>* m_sort_stack;
};
 
template <class T, class datatype>
void stack_sort(sort_buff_helper<T,datatype>& buf, int size, bool dir=true)
{
    buf.get_stack()->reset();
    stack_sort(buf.m_sort_buff, size, dir, buf.get_stack());
}
 
/*
使用方法Demo：
 
//模拟排序数据
struct item_tag{
    int value;
    int grade;
};
 
//定义排序数据存储
map<unsigned int,item_tag> sort_data;
 
//...load sort_data;
 
 
//创建排序缓存
sort_buff_helper<int,map<unsigned int,item_tag>::iterator> sbuff;
sbuff.create(sort_data.size()+1);
 
//保存迭代器,回写排序结果时用到
map<unsigned int,item_tag>::iterator i;
int index = 0;
for(i=sort_data.begin(); i!=sort_data.end(); i++)
{
    sbuff[index].d = i;
sbuff[index].value = i->second.value;
    index ++;
}
 
bool dir = true;
 
//排序
stack_sort(sbuff, sort_data.size(), dir);
 
//回写排序结果
for(int i=0; i<size; i++)
{
sbuff[i].d->second.grade = i;
}
 
*/
 
#endif//__STACK_SORT_H__