三种排序算法

三种排序算法：

冒泡排序：

1. 一共进行数组的大小 -1 次大的循环
2. 每一趟排序的次数在逐渐的减少
3. 如果我们发现在某一趟排序中，没有发生一次交换，可以提前结束冒泡排序，这就是优化
   //冒泡排序时间复杂度：O（n^2）
   int temp = 0; //临时变量
   boolean flag = false; //标识变量，表示是否进行交换，优化

for(int i = 0; i < arr.length - 1; i++){
    for(int j = 0; j < arr.length - 1 -i; j++){
        //如果前面的数大于后面的数，则交换	
        if(arr[j] > arr[j + 1]){
            flag = true;	//优化
            temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
    System.out.println(Arrays.toString[arr]);
    
    if(!flag){	//	优化
        break;	//在一趟排序中，一次交换都没发生过
    }else{
        flag = false;	//重置flag，进行下一次判断
    }
}

选择排序：

1.选择排序一共有数组大小的 -1 轮排序

2.每 1 轮排序，又是一个循环，循环的规则（代码）

​ 2.1先假定当前这个数是最小数

​ 2.2然后和后面的每个数进行比较，如果发现有比当前数更小的数，就重新确定最小数，并得到下标

​ 2.3当遍历到数组的最后时，就得到本轮最小的下标

​ 2.4交换

//时间复杂度 O(n^2)
for(int i = 0; i < arr.length - 1; i++){
    int minIndex = i;
    int min = arr[i];
    for(int j = i + 1; j < length; j++){
        if(min > arr[j]){	//说明假定的是最小值，并不是最小的
            min = arr[j];	//重置min
            minIndex = j;	//重置minIndex
        }
    }
    //将最小值，放在arr[i] ，即交换
    if(minIndex != i){
        arr[minIndex] = arr[i];
        arr[i] = min;
    }
}

插入排序：

1. 把n个待排序的元素看成为一个有序表和一个无序表。
2. 开始时，有序表中只包含一个元素，无序表中包含 n-1 个元素。
3. 排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较。
4. 将它插入到有序表中的适当位置，使成为新的有序表。

    //给insertVal找到插入的位置
    /**
    	insertIndex >= 0保证在给insertVal 找插入位置，不越界
    	insertVal < arr[insertIndex]待插入的数，还没找到插入位置
    	需要将arr[insertIndex] 后移
    */
    while(insertIndex >= 0 && insertVal < arr[insertIndex]){
        arr[insertIndex + 1] = arr[insertIndex];
        insertIndex--;
    }
    
    //当退出while循环时，说明插入的位置找到，insertIndex + 1
    arr[insertIndex + 1] = insertVal;
}