算法---排序算法

排序算法

冒泡排序

1.将序列中所有元素两两比较，将最大的放在最后面。

2.将剩余序列中所有元素两两比较，将最大的放在最后面。

3.重复第二步，直到只剩下一个数。

/**
 * 冒泡排序
 */
public class MaoPaoSort {
    public static void sort(int[] array){
        for (int i=0;i<array.length;i++){
            for (int j=0;j<array.length-i-1;j++){
                if (array[j] > array[j+1]) {//{21,34,55,20,53,3,71,44}
                    int temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }

        for (int i=0;i<array.length;i++)
            System.out.print(array[i]+"\t");
        System.out.println();
    }
}

---

简单选择排序

稳定

常用于取序列中最大最小的几个数时。

(如果每次比较都交换，那么就是交换排序；如果每次比较完一个循环再交换，就是简单选择排序。

遍历整个序列，将最小的数放在最前面。

遍历剩下的序列，将最小的数放在最前面。

重复第二步，直到只剩下一个数。

代码实现原理：

1.首先确定循环次数，并且记住当前数字和当前位置。

2.将当前位置后面所有的数与当前数字进行对比，小数赋值给key，并记住小数的位置。

3.比对完成后，将最小的值与第一个数的值交换。

重复2、3步。

/**
 * 简单选择排序
 */
public class SelectSort {
    public static void Select(int[] array){
        for (int i=0;i<array.length;i++){
            int temp=array[i];
            int index=i;
            for (int j=i+1;j<array.length;j++){
                if (array[j]<temp){
                    temp=array[j];
                    index=j;
                }
            }
            array[index]=array[i];
            array[i]=temp;
        }

        for (int i=0;i<array.length;i++)
            System.out.print(array[i]+"\t");
        System.out.println();
    }
}

---

直接插入排序

把新的数据插入到已经排好的数据列中。
将第一个数和第二个数排序，然后构成一个有序序列。
将第三个数插入进去，构成一个新的有序序列。对第四个数、第五个数……直到最后一个数。

默认第一个数已经排好序， 然后拿他后边的数据和他进行比较；如果是升序（大的往后走小的往前走；） 如果是降序； 大的往前走，小的往后走， 然后等他排完之后， 后边的数据还是按照这个来进行排序。

/**
 * 直接插入排序
 * 默认第一个已经排好序,拿后面的比较
 */
public class InsertSort {
    public static void insertTo(int[] array){
        int temp=0;
        for (int i=1;i<array.length;i++){
            temp=array[i];
            int j=i-1;
            for (;j>=0&&temp<array[j];j--){
                array[j+1]=array[j];//将大于temp的整体后移
            }
            array[j+1]=temp;//如果temp里存放的是最小的,执行完内层的for循环后,j=-1,array[j+1]=array[0]=最小的元素
        }

        for (int j=0;j<array.length;j++)
            System.out.print(array[j]+"\t");
        System.out.println();
    }
}

public static void main(String[] args) {
        int array[]={34,21,55,20,53,3,71,44};
        InsertSort.insertTo(array);
    }

---

希尔排序

针对直接插入排序的效率问题，有人对它进行了改进与升级，这就是现在的希尔排序。希尔排序（底层实现使用直接插入排序），也称递减增量排序算法，是插入排序的一种更高效的改进版本。希尔排序是非稳定排序算法(因为它是跳跃分组的)。

希尔排序是基于插入排序的以下两点性质而提出改进方法的：

• 插入排序在对几乎已经排好序的数据操作时，效率高， 即可以达到线性排序的效率
• 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位

希尔排序—分组进行比较进行排序，其实就是把数据进行分组；

对于直接插入排序问题，数据量巨大时，

将数的个数设为n，取数k=n/2，将下标差值为k的数分为一组，构成有序序列。

再取k=k/2 ，将下标差值为k的数分为一组，构成有序序列。

重复第二步，直到k=1执行简单插入排序。

当你的分组完了之后这个k=1的时候，开始直接插入排序；

希尔排序其实先进行分组，根据你数据个数去分组，也就是和2进行取模运算之后进行我们的向下取整数的方式； 等最后的时候这个分组为1的使用直接插入排序。

/**
 * 希尔排序
 */
public class XierSort {
    public static void shell(int[] array){
        int size=array.length;
        int temp=0;//中间变量
        while (true){
            size=(int) Math.ceil(size/2);//向下取整    分组(相隔d个为一组)
            for (int i=0;i<size;i++){//多少个组
                for (int j=i+size;j<array.length;j+=size){//每个组里的数据     从这开始就和直接插入排序基本相同了
                    temp=array[j];
                    int k=j-size;
                    for (;k>=0&&temp<array[k];k-=size){
                        array[k+size]=array[k];
                    }
                    array[k+size]=temp;
                }
            }
            if (size==1)
                break;
        }

        for (int i=0;i<array.length;i++)
            System.out.print(array[i]+"\t");
        System.out.println();
    }
}

---

---

快速排序

是java里边提供一种排序算法

要求时间最快时。

选择第一个数为基准数p，小于p的数放在左边，大于p的数放在右边。

然后在大于他的所有数中再次进行这个递归运算； 和在小于他的也进行这个递归运算；

递归的将p左边和右边的数都按照第一步进行，直到不能递归。

对于{5,7,6,1,9,10,4,2,3,8}这个数组，第一次排序我们的Flag是5，我们分别从数组的左右两端开始“探测”。

我们定义i指向数组的最左端，定义j指向数组的最右端。首先将j向左移，直到j指向的数小于5；再将i向右移，直到i指向的数大于5。最终i指向7，j指向3。

3.交换
将3和7交换，数组变为{5,3,2,1,9,10,4,6,7,8}。第一次交换结束。

接下来继续探测、交换，探测、交换…

4.Flag落位
第二次交换结束后数组变为{5,3,2,1,4,10,9,6,7,8}。

j指向9的位置，i指向4的位置，j继续向左移动，直到i的位置才找到小于5的值。

此时i=j，我们只需将Flag落在这个位置：将5和4的值交换。数组变为{4,3,2,1,5,10,9,6,7,8}。

至此，5这个Flag完成了它的历史使命，第一轮交换结束。

数组被划分为两个区，Flag左边是小于Flag的{4,3,2,1}，Flag右边是大于Flag的{10,9,6,7,8}。

5.递归
我们再分别对这两个区进行第二轮交换，交换结果是{1,3,2,4}和{8,9,6,7,10}

对于{1,3,2}和{8,9,6,7}重复进行以上操作，直至得到不能拆解的单个数字，排序完成！

/**
 * 快速排序
 */
public class QuickSort {
    public static void sort(int[] array,int left,int right){
        if (left>right)
            return;
        int base=array[left];//基准数
        int i=left,j=right;
        while (i!=j){
            //先从右边开始往左找，直到找到比base值小的数
            while (array[j]>=base&&i<j)
                j--;
            //再从左往右边找，直到找到比base值大的数
            while (array[i]<=base&&i<j)
                i++;
            //上面的循环结束表示找到了位置或者(i>=j)了，交换两个数在数组中的位置
            if (i<j){
                int temp=array[i];
                array[i]=array[j];
                array[j]=temp;
            }
        }
        array[left]=array[i];
        array[i]=base;

        sort(array,left,i-1);
        sort(array,i+1,right);

        for (int k=0;k<array.length;k++)
            System.out.print(array[k]+"\t");
        System.out.println();
    }
}

---

归并排序

稳定

速度仅次于快速排序，内存少的时候使用，可以进行并行计算的时候使用。

1.选择相邻两个数组成一个有序序列。

2.选择相邻的两个有序序列组成一个有序序列。

3.重复第二步，直到全部组成一个有序序列。

/**
 * 归并排序
 */
public class MergeSort {
    public static void merge(int[] array,int first,int mid,int last){
        int[] temp=new int[last - first + 1];
        int i=first;
        int j=mid+1,k=0;
        //把较小的数先移到新数组中
        while (i<=mid&&j<=last){
            if (array[i]<array[j])
                temp[k++]=array[i++];
            else
                temp[k++]=array[j++];
        }
        //把左边剩余的数移入数组
        while (i<=mid)
            temp[k++]=array[i++];
        //把右边剩余的数移入数组
        while (j<=last)
            temp[k++]=array[j++];
        //新数组覆盖原来的array数组
        for (int m=0;m<temp.length;m++)
            array[m+first]=temp[m];
    }

    /*
     * 归并排序思路：
     * 先分割--将整的序列先分成一个个子序列
     * 再排序--将分割的子序列分别进行排序
     * 后合并--将排好序的子序列合并
     * 再排序--再将最后合并的序列排序
     */
    public static void mergeSort(int[] array,int low,int high){
        int mid=(low+high)/2;
        if (low<high){
            //左边排序  34,21,55,20,53,3,71,44
            mergeSort(array,low,mid);
            //右边排序
            mergeSort(array,mid+1,high);
            //左右归并
            merge(array,low,mid,high);
            System.out.println(Arrays.toString(array));
        }
    }
}

总结

排序

插入排序类：直接插入排序，希尔排序

选择排序类：简单选择排序，堆排序

交换排序类：冒泡排序，快速排序

归并排序类：归并排序

稳定性:

稳定：冒泡排序、插入排序、归并排序、选择排序和基数排序

不稳定：、快速排序、希尔排序、堆排序

平均时间复杂度

O(n^2):直接插入排序，简单选择排序，冒泡排序。

在数据规模较小时（9W内），直接插入排序，简单选择排序差不多。当数据较大时，冒泡排序算法的时间代价最高。性能为O(n^2)的算法基本上是相邻元素进行比较，基本上都是稳定的。

O(nlogn):快速排序，归并排序，希尔排序，堆排序。

其中，快排是最好的， 其次是归并和希尔，堆排序在数据量很大时效果明显。

排序算法的选择

1.数据规模较小

（1）待排序列基本有序的情况下，可以选择直接插入排序；–小的规模的排序；

（2）对稳定性不作要求宜用简单选择排序，对稳定性有要求宜用插入或冒泡

2.数据规模不是很大

（1）完全可以用内存空间，序列杂乱无序，对稳定性没有要求，快速排序，此时要付出log（N）的额外空间。----我们经常使用快速排序；

（2）序列本身可能有序，对稳定性有要求，空间允许下，宜用归并排序

3.数据规模很大

（1）对稳定性有求，则可考虑归并排序。

（2）对稳定性没要求，宜用堆排序

4.序列初始基本有序（正序），宜用直接插入，冒泡

排序方法	平均情况	最坏情况	最好情况	空间复杂度	稳定性
冒泡排序	O(n^2)	O(n^2)	O(n)	O(1)	稳定
简单选择排序	O(n^2)	O(n^2)	O(n^2)	O(1)	稳定
直接插入排序	O(n^2)	O(n^2)	O(n)	O(1)	稳定
希尔排序	O(n*logn)	O(n*logn)	O(n*logn)	O(1)	不稳定
快速排序	O(n*logn)	O(n^2)	O(n*logn)	O(logn)	不稳定
归并排序	O(n*logn)	O(n*logn)	O(n*logn)	O(n)	稳定
堆排序	O(n*logn)	O(n*logn)	O(n*logn)	O(1)	不稳定
基数排序	O(n*k)	O(n*k)	O(n*k)	O(n+k)	稳定