排序

1. 在多个数据元素（Ri）的序列，其中每个元素有相应的关键字(Ki)（也叫元素的属性），通过关键字的固有关系来对对应数据元素进行排序

2. 排序稳定性：元素R1 R2 的关键字K1 K2相同，排序前R1在R2前面，排序后 R1在R2前面，则该排序方法是稳定的。

3. 多关键字排序：排序先用最高优先级的关键字N1进行排序，，当N1关键字相同时使用N2优先级关键字进行排序，如果关键字还是相同依次使用N2，，Nn-1

4. 排序和交换两个重要手段

5. 排序选择要素：时间性能，空间性能，程序复杂度

 

1.选择排序

　　思想：在排序到当前序列第 i 和元素时，从后面 n-i 个元素中选出最小元素，作为当前排序序列第 i 个元素。 

       

 

 

　　code:

        static void select(T array[], int len)
        {
            for(int x = 0; x < len; x++)
            {
                int min = x; 
                for(int y = x + 1; y < len; y++)
                {
                    if(array[min] > array[y]) //升序< 降序>
                        min = y;
                }
                if(min != x)
                    swap(array[x],array[min]); //不稳定排序
            }

 

　　

2.插入排序

　　思想：序列分为有序序列和无需序列。未排序序列选择第 i (1) 位的元素时，插入到前面的有序序列，使用 i 元素的关键字与前 i-1 个元素关键字进行比较，找到位置后插入即可   

        

 

 

        template <typename T>
        static void insert_sort(T array[], int len, bool ascend = false)
        {
            for(int x = 1; x < len; x++)
            {
                int z = x;
                T temp = array[z];
                for(int y = x - 1; (y >= 0) && (ascend ? array[y] > temp: array[y] < temp); y--)
                {
                    array[y + 1] = array[y]; //稳定排序
                    z = y;
                }
                if(z != x)
                {
                    array[z] = temp;
                }
            }
        }

 

 

3.冒泡排序

　　思想：序列分为有序序列和无序序列，从整个序列的最后一个元素开始向前依次比较大小，小则比较数前移，大则用被比较的元素前移。

        

 

 

template <typename T>
        static void bubble_sort(T array[], int len, bool ascend = false)
        {
            bool state = ture;
            for(int x = 0; x < len && state; x++) //某个元素无法前的元素都是有序的，表明有序
            {
                state = false;
                for(int y = len - 1; y > x; y--)
                {
                    if(ascend ? array[y] > array[y - 1] : array[y] < array[y - 1])
                    {
                        swap(array[y],array[y - 1]);
                        state = ture; 
                    }
                }
            }
        }

 

 

4.希尔排序

　　思想：将n个元素的序列分为d组，每一组使用插入排序。然后再分为d-1组，再分别排序。直到d=1。

　　如何分组： 将n个元素分为d个子序列：第一组：{R[1],R[1+d],R[1+2d]...R[1+kd]} 第二组：{R[2],R[2+d],R[2+2d]....R[2+kd]} .........第d组：{R[d],R[2d],R[3d]...R[(1+k)d]} 。

        

 

 

        template <typename T>
        static void shell_sort(T array[], int len, bool ascend = false)
        {
            int d = len;
            do
            {
                d = d / 3 + 1; //???
                for(int x = d ; x < len; x += d)
                {
                    int z = x;
                    T temp = array[z];
                    for(int y = x - d; (y >= 0) && (ascend ? array[y] > temp: array[y] < temp); y -= d)
                    {
                        array[y + d] = array[y]; //稳定排序
                        z = y;
                    }
                    if(z != x)
                    {
                        array[z] = temp;
                    }
                }
            }
            while(d > 1);
        }

 

 

 

5.归并排序

　　思想：先将一个无序序列划分为两个无序序列，再将两个无序序列接着向下划分，直到每个子序列只包含一个元素此时每个子序列都是有序序列，

                 再两个两个子序列比较后合并，直到所有子序列合并为原来的序列，此时序列变为有序。

　　　　　几个有序序列归并就叫几路归并。

　　          稳定但是花费空间

                 

 

 

    template <typename T>
        static void merge_sort(T array[], int len, bool ascned = ture)
        {
            T* temp_array = new T[len];
            merge_sort_core(array, temp_array, 0, len - 1, ture);
            delete[] temp_array;
        }

        template <typename T>
        static void merge_sort_core(T array[], T temp_array[], int begin, int end, bool ascned = ture)
        {
            if(begin == end)
            {
                return;
            }
            else
            {
　　　　　　　　　　// 分割
                int mid = (begin + end) / 2;
                merge_sort_core(array, temp_array, begin, mid, ascned);
                merge_sort_core(array, temp_array, mid + 1, end, ascned);
                // 合并
                int x = begin, y = mid + 1, z = begin;
                while(x <= mid && y <= end)
                {
                    if(array[x] < array[y])
                    {
                        temp_array[z++] = array[x++];
                    }
                    else
                    {
                        temp_array[z++] = array[y++];
                    }
                }
                while(x <= mid)
                {
                    temp_array[z++] = array[x++];
                }
                while(y <= end)
                {
                    temp_array[z++] = array[y++];
                }
                for(z = begin; z <= end; z++)
                {
                    array[z] = temp_array[z];
                }
            }
        }

 

　

6.快速排序

　思想： 通过在序列中选择一个基准值对一个无序序列划分，将无序序列大于基准值的放在左边，小于基准值的放在右边。再把左右两个子序列继续寻找基准值继续划分下去。

　　　　最后每个序列都只有一个元素，而此时整个序列变成有序的。

               不稳定但是花费空间

               

 

 

        template <typename T>
        static void quick_sort(T array[], int len, bool ascned = ture)
        {
            quick_sort_core(array, 0, len - 1, ascned);
        }

        template <typename T>
        static void quick_sort_core(T array[], int begin, int end, bool ascned = ture)
        {
            //确定基准值的位置
            int base_pos = 0, base_value = array[begin], begin_slide = begin, end_slide = end;
            while(begin_slide < end_slide)
            {
                while(begin_slide < end_slide && ascned ? base_value  < array[end_slide] : base_value  > array[end_slide])
                {
                    --end_slide;
                }
                swap(array[begin_slide], array[end_slide]);
                while(begin_slide < end_slide && ascned ? base_value >= array[begin_slide] : base_value <= array[begin_slide])
                {
                    ++begin_slide;
                }
                swap(array[begin_slide], array[end_slide]);
            }
            array[begin_slide] = base_value;
            base_pos = begin_slide;
            //继续划分
            quick_sort_core(array, begin, (base_pos - 1), ascned);
            quick_sort_core(array, base_pos + 1, end, ascned);
        }