几种排序算法

真实开发中，用Arrays.sort(arr)

1、选择排序

选择最小的元素放在第一个位置，接着对不包括第一个记录以外的其他元素进行比较，选择最小的记录，直到进行比较的记录只有一个为止。

public static void selectSort(int[] arr){
        int len=arr.length;
        int temp=0;
        for(int i=0;i<len-1;i++){
            int k=i;//待确定的位置(最小元素）
            for(int j=len-1;j>i;j--) {//从后向前，注意j>i条件
                if (arr[j] < arr[k]) {
                    k = j;
                }
            }
            //交换两个数,可用swap(arr,i,j)
            temp=arr[i];
            arr[i]=arr[k];
            arr[k]=temp;
        }
    }

或以下（性能较低，堆内存消耗资源，把频繁换位置的转移到栈内存中）

public static void selectSort2(int[] arr){
        int len=arr.length;
        int temp=0;
        for(int i=0;i<len-1;i++){
            for(int j=i+1;j<len;j++){
                if(arr[i]>arr[j]){
                   temp=arr[i];
                   arr[i]=arr[j];
                   arr[j]=temp;
                }
            }
        }
    }

2、插入排序

假设第一个元素有序，从第二个元素开始插入当前有序序列（所以i的初始值为1），使有序

public static void insertSort(int[] arr){
        int len=arr.length;
        int temp=0;
        int j=0;
        for(int i=1;i<len;i++){
            temp=arr[i];//记录要插的元素
            for(j=i;j>0&&temp<arr[j-1];j--){
                arr[j]=arr[j-1];//若要插入元素较小，则前面值后移
            }
            arr[j]=temp;//找到插入位置
        }
    }

 

3、冒泡排序

从第一个元素开始，相邻元素进行比较，若前面的记录大于后面的则交换，一轮之后，最大值放在第n位，然后对前n-1个记录比较，重复直到比较的记录只剩下一个为止

public static void bubleSort(int[] arr){
        int len=arr.length;
        int temp=0;
        for(int i=0;i<len-1;i++){//只需遍历n-1次
            for(int j=0;j<len-1-i;j++){//注意j的条件
                if(arr[j]>arr[j+1]) {//交换
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

4、快速排序

采用“分而治之”的思想，步骤：分解，递归求解，合并

public class Test{
    public static void main(String[] args){
       int[] a={3,8,5,10,9,7,2,6}
       quickSort(a);
       for(int i=0;i<a.length;i++){
          System.out.print(a[i]+" ");
       }
    }

    public static void quickSort(int[] arr){
        Sort(arr,0,arr.length-1);
    }
    public static void Sort(int[] arr,int low,int high){
        int i,j,index;
        if(low>high)
            return;
        i=low;
        j=high;
        index=arr[i];
        while(i<j){
            while(i<j&&arr[j]>=index) {
                j--;
            }
            if(i<j) {
                arr[i++] = arr[j];
            }
            while(i<j&&arr[i]<index) {
                i++;
            }
            if(i<j) {
                arr[j--] = arr[i];
            }
        }
        arr[i]=index; //中轴的位置
        Sort(arr,low,i-1);
        Sort(arr,i+1,high);

    }
}

5、归并排序

归并排序是将两个（或以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的，然后把有序子序列合并为整体有序序列。

public class MergeSort {
    public static void main(String[] args){
        int[] a={38,65,97,76,13,27,49};
        int[] res=Sort(a,0,6);
        print(res);


    }
    public static void print(int[] arr){
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
    public static int[] Sort(int[] arr,int low,int high){
        int mid=(low+high)/2;
        if(low<high){
            Sort(arr,low,mid);
            Sort(arr,mid+1,high);
            merge(arr,low,mid,high);
        }
        return arr;
    }
    public static void merge(int[] arr,int low,int mid,int high){
        int[] temp=new int[high-low+1];
        int i=low;//左指针
        int j=mid+1;//右指针
        int k=0;
        while(i<=mid&&j<=high){
            if(arr[i]<arr[j]){
                temp[k++]=arr[i++];
            }else{
                temp[k++]=arr[j++];
            }
        }
        while(i<=mid){//把左边剩余的数移入数组中
            temp[k++]=arr[i++];
        }
        while(j<=high){
            temp[k++]=arr[j++];
        }
        for(int k2=0;k2<temp.length;k2++){//把新数组中的数覆盖原数组
            arr[k2+low]=temp[k2];
        }

    }
}

6、堆排序

对选择排序的有效改进。

堆顶元素（第一个元素）必为最大项（大顶堆），完全二叉树可以很直观地表示堆的结构。堆顶为根，其它为左子树、右子树。

堆排序需要2个过程：一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序由2个函数组成。

 

 

7、希尔排序

先将待排序列分割成若个子序列分别进行直接插入排序，待整个序列中的记录基本有序时，再对全体记录进行依次直接插入排序。

操作：

1）选择一个增量序列t1,t2,,,tk,其中ti>tj,tk=1

2) 按增量序列个数k,堆序列进行k趟排序

public static void shellSort(int[] arr){
        int j=0;
        int temp=0;
        
        for(int incre=arr.length/2;incre>0;incre/=2){ //每次将步长缩短为原来的一半
            for(int i=incre;i<arr.length;i++){ //i=incre
                temp=arr[i];//记录
                for(j=i;j>=incre;j-=incre){ //j-=incre
                    if(temp<arr[j-incre]){  //arr[i]与arr[i-incre]相比较，如果从大到小只需修改这里
                        arr[j]=arr[j-incre];
                    }else{
                        break;
                    }
                }
                arr[j]=temp; 
            }
        }
    }