一、介绍
1.1 选择排序分析
选择排序:每次循环找出最小值的索引,直接进行交换。
n表示数组长度 , end 表示最后一次循环。
第1次循环: 在 0 ~ n-1 中找出最小值 ,放在索引为0的位置。
第2次循环: 在 1 ~ n-1 中找出最小值 ,放在索引为1的位置。
第3次循环: 在 2 ~ n-1 中找出最小值 ,放在索引为2的位置。
第4次循环: 在 3 ~ n-1 中找出最小值 ,放在索引为3的位置。
....
第n-1次循环: 在 n-2 ~ n-1 中找出最小值 ,放在索引为n-1的位置。
即 每次循环找出最小值直接交换两个元素的位置。
1.2 冒泡排序分析
冒泡排序:每次循环,两两比较,找出最大值,放在最后。
第1次循环:从 0 ~ n-1 范围中 找到最大值,放在n-1位置。
第2次循环:从 0 ~ n-2 范围中 找到最大值,放在n-2位置。
第3次循环:从 0 ~ n-3 范围中 找到最大值,放在n-3位置。
......
第n-1次循环:从 0 ~ 1 范围中 找到最大值,放在1位置。
即:两两比较,每次循环找出最大值,放在最后。
1.3 插入排序分析
第1次循环:从 0 ~ 1 范围中排序
第2次循环:从 0 ~ 2 范围中排序
第3次循环:从 0 ~ 3 范围中排序
......
第n-1次循环:从 0 ~ n-1 范围中排序
即:每次循环,将待排序的值和之前有序的元素进行比较,放在合适的位置。
二、代码实现
/**
* @author :LiuShihao
* @date :Created in 2022/1/28 5:15 下午
* @desc : 选择排序、冒泡排序、插入排序
*/
public class SortCode {
public static void main(String[] args) {
int[] arr = {9, 4, 1, 6, 2, 5, 4,1};
pringArray(arr);
// selectSort(arr);
// bubbleSort1(arr);
// bubbleSort2(arr);
// insertionSort1(arr);
insertionSort2(arr);
pringArray(arr);
}
/**
* 打印数组
* @param arr
*/
public static void pringArray(int[] arr){
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
System.out.println();
}
/**
* 交换位置
* @param arr
* @param i
* @param j
*/
public static void swap(int[] arr,int i,int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
/**
* 选择排序:每次找出最小值
* 0~n-1 中找出最小的 0-1 1-2 2-3
* 1~n-1 中找出最小的
* 2~n-1 中找出最小的
* 3~n-1 中找出最小的
* @param arr
*/
public static void selectSort(int[] arr){
if (arr == null || arr.length < 2 ){
return;
}
int N = arr.length;
//i可以从1开始,也可以从0开始(第一位不需要比较)
for (int i = 1; i < N; i++) {
int minValueIndex = i;
//注意:内层循环的初始值是当前值的下一位,即i+1,因为内层循环为当前值和后面的值比较,并记录最小值的位置
for (int j = i+1; j < N; j++) {
// 2,1,6,8,1,5
// 0 1 2 3 4 5
minValueIndex = arr[minValueIndex] > arr[j] ? j:minValueIndex;
}
swap(arr,minValueIndex,i);
}
}
/**
* 冒泡排序:两两相比 交换位置 每次找出最大值。
* @param arr
*/
public static void bubbleSort1(int[] arr){
if (arr == null || arr.length < 2){
return;
}
int N = arr.length;
// 0 ~ n-1
// 0 ~ n-2
// 0 ~ n-3
//外层循环控制次数
for (int i = 1; i < N; i++) {
//内层循环进行两两比较,从索引0位置开始两两比较 即:j和j+1进行比较,j++,此处 限制条件:j < N-1 和j < N-1-i 效果是一样的。
for (int j = i; j < N-1; j++) {
if (arr[j] > arr[j+1]){
swap(arr,j+1,j);
}
}
}
}
/**
* 冒泡排序第二种写法:
* @param arr
*/
public static void bubbleSort2(int[] arr){
if (arr == null || arr.length < 2){
return;
}
int N = arr.length;
// 0 ~ n-1
// 0 ~ n-2
// 0 ~ n-3
// 0 ~ n-4
// end 为最后位置
for (int end = N-1; end > 0; end--) {
//second 为比较的第二位元素,second-1为比较的第一位值,所以second 从1 开始比较,选出最大的值放在end的位置。
for (int second = 1; second <= end ; second++) {
if (arr[second-1] > arr[second]){
swap(arr,second-1,second);
}
}
}
}
/**
* 插入排序第一种写法:
* 0 ~ n-1
* 1 ~ n-1
* 2 ~ n-1
* 3 ~ n-1
* @param arr
*/
public static void insertionSort1(int[] arr){
if (arr == null || arr.length < 2){
return;
}
int N = arr.length;
for (int i = 1; i < N; i++) {
// nextValueIndex为待排序新值的位置。如果符合条件的话则交换位置,并--,再与前面的元素比较,直到找到合适的位置停止,之前已经是有序的了。
int nextValueIndex = i ;
while ((nextValueIndex -1)>=0 && (arr[nextValueIndex] < arr[nextValueIndex-1])){
swap(arr,nextValueIndex,nextValueIndex-1);
nextValueIndex--;
}
}
}
/**
* 插入排序第二种写法:
* @param arr
*/
public static void insertionSort2(int[] arr){
if (arr == null || arr.length < 2){
return;
}
int N = arr.length;
// end 为待排序的新值的位置
for (int end = 1; end < N; end++) {
// pre 为前一位元素的位置
for (int pre = end -1 ; pre >= 0 &&(arr[pre] > arr[pre+1]); pre--) {
swap(arr,pre,pre+1);
}
}
}
}