插入排序

3.插入排序

package com.pj;
import org.junit.jupiter.api.Test;
import java.util.Arrays;
/**
 * @author kht
 * @date 2022/3/18
 * @description:
 */
public class Insertion {

  /*对数组a中的元素进行排序*/
  public static void sort(Comparable[] a) {
    for (int i = 1; i < a.length; i++) {
      // 当前元素为a[i],依次和i前面的元素比较，找到一个小于等于a[i]的元素
      for (int j = i; j > 0; j--) {
        if (greater(a[j - 1], a[j])) {
          // 交换元素
          exch(a, j - 1, j);
        } else {
          // 找到了该元素，结束
          break;
        }
      }
      }
  }

  /*比较v元素是否大于w元素*/
  private static boolean greater(Comparable v, Comparable w) {
    return v.compareTo(w) > 0;
  }

  /*数组元素i和j交换位置*/
  private static void exch(Comparable[] a, int i, int j) {
    Comparable t = a[i];
    a[i] = a[j];
    a[j] = t;
  }

  @Test
  public void test1() {
    Integer[] a = {4,6,8,7,9,2,10,1};
    sort(a);
    System.out.println(Arrays.toString(a));
  }
}

插入排序使用了双层for循环，其中内层循环的循环体是真正完成排序的代码，所以，我们分析插入排序的时间复
杂度，主要分析一下内层循环体的执行次数即可。
最坏情况，也就是待排序的数组元素为{12,10,6,5,4,3,2,1}，那么：
比较的次数为：(N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;
交换的次数为：(N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;
总执行次数为：(N^2/2-N/2)+(N^2/2-N/2)=N^2-N;
按照大O推导法则，保留函数中的最高阶项那么最终插入排序的时间复杂度为O(N^2).