基于java语言的插入排序的实现（图解+代码）

##插入排序

插入排序原理：

1.准备两个数组，一组数组为未排序数组，一组数组为已排序数组

2.默认将未排序数组的第一个元素插入已排序数组内

3.每次从未排序数组拿取一个元素，与已排序数组的元素从后往前依次倒序比较元素大小。

4.若待插入的元素小于已插入的元素，则向已插入元素的前一个位置插入该待排序元素，反之则向后一位插入。

例如：给定一个数组{ 2,3,4,1,5}

最后完成排序后的数组为
1，2，3，4，5

java实现代码：
插入排序类：

//插入排序
public class Insert {

    public void insertSorce(Comparable[] arr){
        //创建一个新数组，用来存储已排序的元素,已排序的数组于未排序的数组的容量一样
        Comparable[] alerdArr = new Comparable[arr.length];
        //默认将未排序的第一个元素插入到已排序的数组内
        alerdArr[0] = arr[0];

        //遍历原数组，从数组第二位开始遍历
        for (int i = 1; i < arr.length; i++) {
                 //倒叙遍历已排序数组，跟未排序元素依次比较
                for (int j = i; j >0 ; j--) {
                    if (lessThen(arr[i],alerdArr[j-1])){
                        //未排序数组元素小于已排序数组元素时,已比较排序数组向后移动一位
                        alerdArr[j] = alerdArr[j-1];
                        //未排序元素插入到已比较排序数组元素之前
                        alerdArr[j-1]=arr[i];
                    }
                    else {
                        alerdArr[j] = arr[i];
                        break;
                    }

                }
        }

       //将已排序的数组赋值给原数组
        for (int i = 0; i < alerdArr.length; i++) {
            arr[i] = alerdArr[i];
        }

    }


    //判断元素i是否小于元素j，是返回true，否返回false
    public static boolean lessThen(Comparable i,Comparable j){
        return i.compareTo(j)<0; //调用Comparable接口的compareTo方法
    }
}

测试类：

public class InsertTest {
    public static void main(String[] args) {
        //创建一个数组
        Integer[] arr ={ 2,1,5,4,3} ;
        //创建一个插入排序的对象
        Insert is = new Insert();
        //调用insertSort方法对数组进行排序
        is.insertSorce(arr);

        //遍历排序后的数组
        for (Integer integer : arr) {
            System.out.print(integer +" ");
        }

    }
}

测试数据截图：

如：想让数据按照降序进行排序则只需修改lessThen 方法

//判断i的值是否大于j的值，是则返回true，否则返回false
    private static boolean lessThen(Comparable i,Comparable j){
        return i.compareTo(j)>0; //调用Comparable 接口的compareTo方法
    }

排序代码优化：

public class Insert_2 {

    //插入排序
    public void insertSorce_2(Comparable[] a) {
        //遍历数组元素
        for (int i = 1; i < a.length; i++) {
            for (int j = i; j > 0; j--) {
                //判断已排序元素是否大于已排序元素
                if (greateThen(a[j-1],a[j])){
                    //交换两个元素的位置
                    exch(a,j-1,j);
                }else {
                    break;
                }
            }
        }
    }

    //判断v位置处的索引是否大于z位置处的索引,是则返回true
    public static boolean greateThen(Comparable v, Comparable z) {
        return v.compareTo(z) > 0;
    }

    //交换数组a中，交换i位置处与j位置处的值
    public static void exch(Comparable[] a, int i, int j) {
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}