选择排序，冒泡排序，插入排序的小小记录

package me.jea.array;

import java.util.Arrays;

public class MyTest {
public static void main(String[] args) {
int[] a = new int[] { 6, 5, 4, 32 };
int[] b = (int[])a.clone();
int[] c = (int[])a.clone();
a = selectSort(a);
a = bubbleSort(b);
a = insertSort(c);
System.out.println(Arrays.toString(a));//[4, 5, 6, 32]
System.out.println(Arrays.toString(b));//[4, 5, 6, 32]
System.out.println(Arrays.toString(b));//[4, 5, 6, 32]
}

/**
* 插入排序 首先明确n个数 需要 n-1轮，
* 默认将角标为1的数的左边是排序好了的 因此外循环从[1,arr.length)
* 内循环扫描指定位置的左边的元素，直到找到了合适的位置，
* 把需要插入的元素插入到其下一个位置 key的位置在i,那么内循环角标就在[i-1,0]递减
* 整个过程就像打扑克牌一样
*
* @param a
* @return
*/
private static int[] insertSort(int[] a) {
for (int i = 1; i < a.length; i++) {
int j;// 合适位置的前一位
int key = a[i];// 需要被插入的元素,方法体里面不能出现任何a[i]，否则就是错的，原因不详
for (j = i - 1; j >= 0; j--) {
if (a[j] > key) {
a[j + 1] = a[j];// 把大的扑克牌往右挪一位，空出来的位置让给较小的key
} else {
break;// 这个时候，左边都比key小，那么直接把key放到下一位
}
}
a[j + 1] = key;
}

return a;
}

/**
* 冒泡排序法： 外循环，n个数需要n-1轮
* 内循环：从左往右，一次比较两个数字，如果顺序错误（前大>后小）就交换它们
* 这样就能保持最大的数始终往后面移动 (效果是每轮后，最后一个数是最大的)
* 经验总结：纵向需要arr.length-1轮， 第一次的横向两两比较需要arr.length-1次
* 并且轮数增一，次数减一,因此横向的角标就是[0,arr.length-1-i)
*
* @param a
* @return
*/
private static int[] bubbleSort(int[] a) {
for (int i = 0; i < a.length - 1; i++) {
for (int j = 0; j < a.length - 1 - i; j++) {
if (a[j] > a[j + 1]) {
swap(a, j, j + 1);
}
}
}
return a;
}

/**
* 选择排序法: 外循环：n个数需要n-1轮排序
* 内循环: 用第i个数与后面所有的数比较,并且始终保持第i个位置是最小的
*
* @param a
* @return
*/
public static int[] selectSort(int[] a) {
for (int i = 0; i < a.length - 1; i++) {
for (int j = i + 1; j <= a.length - 1; j++) {
if (a[i] > a[j]) {
swap(a, i, j);
}
}
}
return a;
}

/**
*
* 功能：交换指定数组中不同索引的值
*
* @param a
*            数组
* @param i
*            索引i
* @param j
*            索引j
*/
private static void swap(int[] a, int i, int j) {

int temp = a[i];
a[i] = a[j];
a[j] = temp;

}
}