1. 冒泡排序
最基础排序，一句话总结冒泡排序，对于给定的数组，如果是升序排序，每一趟排序，都会把最大的元素放置在当前趟次的最后位置；
冒泡排序，只会比较交换两个相邻的元素
时间复杂度：严格O(N^2) ，和数据无关；
public static void bubbleSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
// details O(N^2) Deprecated
// end is arr.length - 1 because exist of swap i++, prevent out of index error situation happen
// outer foreach find one max num, and put it at end of arr array
// inner foreach compare two nums and swap, util to the end of end border
for (int end = arr.length - 1; end > 0; end--) {
for (int i = 0; i < end; i++) {
swap(arr, i, i + 1);
}
}
}
private static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
2. 选择排序
最基础排序，一句话总结选择排序，对于给定的数组，如果是升序排序，每次选择最小的元素放置在当前次序的第一个位置；
时间复杂度：严格O(N^2) ，和数据无关；
public static void selectionSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
// details O(N^2) Deprecated
// first loop: search 0~ N-1, find min num and put it at 0 index
// second loop: search 1~ N-1,find min num and put it at 1 index
// until foreach all array
for (int i = 0; i < arr.length - 1; i++) {
int minIndex = i;
for (int j = i + 1; j < arr.length; j++) {
minIndex = arr[j] < arr[minIndex] ? j : minIndex;
}
swap(arr, i, minIndex);
}
}
private static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
3. 插入排序
基础排序，类似扑克牌，整体思路如下(升序排)
1. 从第二个元素开始遍历，即index = 1，1个元素默认有序；
2. 对于当前元素，如果前一个元素比当前元素小，那么交换，直到前面没有元素；
3. 每次循环保证当前位置 i 之前的素有元素都是有序的；
时间复杂度：O(N^2)
1. 最好情况：如果原始数据是升序，那么插入排序的时间复杂度是O(N)，因为每次都不用发生交换动作；
2. 最坏情况：如果原始数据是逆序，那么插入排序的时间复杂度是O(N^2) ，每次都要进行交换到第一个元素；
public static void insertSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
// details
for (int i = 1; i < arr.length; i++) {
int j = i - 1;
while (j > 0 && arr[j] > arr[j + 1]) {
swap(arr, j, j + 1);
j--;
}
}
}
private static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}