Java SE七大排序—插入排序，希尔排序，选择排序，冒泡排序（上）

函数头：

import java.util.Arrays;
import java.util.*;
public class Sort {

需要用到的交换函数：

public static void swap(int[] array,int i,int j){
        int t=array[i];
        array[i]=array[j];
        array[j]=t;
    }

插入排序：

思路：从后面选一个数与前面的有序数列进行比较，找合适的位置（int[] b=a.clone;）数组的复制//能保证稳定性

public static void insertSort(int[] array){   //插入排序
        for(int i=0;i<array.length;i++){
        //有序区间：[0,i)
        //无序区间：[i,array.length)
            int key=array[i];      //无序区间的第一个数
            int j=i-1;
            //不写array[j]==key是保证排序的稳定性
            for(j=i-1;j>=0&&array[j]>key;j--){
                array[j+1]=array[j];
            }
            array[j+1]=key;
        }
    }

希尔排序：（分组做插排，稳定性不强）

思路：

public static void shellSort(int[] array){    //希尔排序
        int key=array.length;
        while(key>1){
            insertSortGap(array,key);
            key=(key/3)+1;
        }
        insertSortGap(array,1);
    }
    public static void insertSortGap(int[] array,int gap){
        for(int i=1;i<array.length;i++){
            int key=array[i];
            int j=i-gap;
            for(;j>=0&&array[j]>key;j-=gap){
                array[j+gap]=array[j];
            }
            array[j+gap]=key;
        }
    }

选择排序：

思路：每一次选择最大（或最小）的元素放在无序区间的最后（或最前），直到所有待排序的元素排完//不能保证稳定性

public static void selectSort(int[] array){  //选择排序
        for(int i=0;i<array.length-1;i++){
        // 无序区间: [0, array.length - i) 
        // 有序区间: [array.length - i, array.length)
            int max=0;
            for(int j=1;j<array.length-i;j++){
                if(array[j]>array[max]){
                    max=j;
                }
            }
            int t=array[max];
            array[max]=array[array.length-i-1];
            array[array.length-i-1]=t;
        }
    }

冒泡排序：

思路：在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序//能保证稳定性

public static void bubbleSort(int[] array){     //冒泡排序
        for(int i=0;i<array.length-1;i++){
            boolean isSorted=true;
            for(int j=0;j<array.length-i-1;j++){
            //相等不交换，保证稳定性
                if(array[j]>array[j+1]){
                    swap(array,j,j+1);
                    isSorted=false;
                }
            }
            if(isSorted){
                break;
            }
        }
    }

测试用时：

public static void testSpeed(){
        Random random=new Random(20190924);
        int[] array=new int[10*10000];
        for(int i=0;i<10*10000;i++){
            array[i]=random.nextInt(10*10000);
        }
        long begin=System.nanoTime();
        insertSort(array);           //插入排序
        long end=System.nanoTime();
        double ms=(end-begin)*1.0/1000/1000;
        System.out.printf("一共耗时:%5f毫秒%n",ms);
    }

输出函数：

public static void print(){
        int[] array={9,1,2,5,7,4,8,6,3,5};
        insertSort(array);
        System.out.println(Arrays.toString(array));
        shellSort(array);
        System.out.println(Arrays.toString(array));
        selectSort(array);
        System.out.println(Arrays.toString(array));
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
        testSpeed();

函数尾：

public static void main(String[] args){
        print();
    }
}

源代码及运行结果：

import java.util.Arrays;
import java.util.*;
public class Sort {
    public static void swap(int[] array,int i,int j){
        int t=array[i];
        array[i]=array[j];
        array[j]=t;
    }
    public static void insertSort(int[] array){   //插入排序
        for(int i=0;i<array.length;i++){
            int key=array[i];
            int j=i-1;
            for(j=i-1;j>=0&&array[j]>key;j--){
                array[j+1]=array[j];
            }
            array[j+1]=key;
        }
    }


    public static void shellSort(int[] array){    //希尔排序
        int key=array.length;
        while(key>1){
            insertSortGap(array,key);
            key=(key/3)+1;
        }
        insertSortGap(array,1);
    }
    public static void insertSortGap(int[] array,int gap){
        for(int i=1;i<array.length;i++){
            int key=array[i];
            int j=i-gap;
            for(;j>=0&&array[j]>key;j-=gap){
                array[j+gap]=array[j];
            }
            array[j+gap]=key;
        }
    }


    public static void selectSort(int[] array){  //选择排序
        for(int i=0;i<array.length-1;i++){
            int max=0;
            for(int j=1;j<array.length-i;j++){
                if(array[j]>array[max]){
                    max=j;
                }
            }
            int t=array[max];
            array[max]=array[array.length-i-1];
            array[array.length-i-1]=t;
        }
    }



    public static void bubbleSort(int[] array){     //冒泡排序
        for(int i=0;i<array.length-1;i++){
            boolean isSorted=true;
            for(int j=0;j<array.length-i-1;j++){
                if(array[j]>array[j+1]){
                    swap(array,j,j+1);
                    isSorted=false;
                }
            }
            if(isSorted){
                break;
            }
        }
    }




    public static void testSpeed(){               //测试耗时
        Random random=new Random(20190924);
        int[] array=new int[10*10000];
        for(int i=0;i<10*10000;i++){
            array[i]=random.nextInt(10*10000);
        }
        long begin=System.nanoTime();
        insertSort(array);           //插入排序
        long end=System.nanoTime();
        double ms=(end-begin)*1.0/1000/1000;
        System.out.printf("一共耗时:%5f毫秒%n",ms);
    }

    public static void print(){          //输出
        int[] array={9,1,2,5,7,4,8,6,3,5};
        insertSort(array);
        System.out.println(Arrays.toString(array));
        shellSort(array);
        System.out.println(Arrays.toString(array));
        selectSort(array);
        System.out.println(Arrays.toString(array));
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
        testSpeed();

    }
    public static void main(String[] args){
        print();
    }
}

这里的耗时是插入排序所需时间！

转载：https://blog.csdn.net/qq_44847147/article/details/101458172