一、选择排序
过程:
arr[0~N-1]范围上,找到最小值所在的位置,然后把最小值交换到0位置。
arr[1~N-1]范围上,找到最小值所在的位置,然后把最小值交换到1位置。
arr[2~N-1]范围上,找到最小值所在的位置,然后把最小值交换到2位置。
…
arr[N-1~N-1]范围上,找到最小值位置,然后把最小值交换到N-1位置。
估算:
很明显,如果arr长度为N,每一步常数操作的数量,如等差数列一般
所以,总的常数操作数量 = a*(N^2) + b*N + c (a、b、c都是常数)
所以选择排序的时间复杂度为O(N^2)。
import java.util.Arrays;
/**
* 选择排序
* 0~N-1 找min 放到0位置
* 1~N-1 找min 放到1位置
* 以此类推
*/
public class SelectSort {
public static void sort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
for (int i = 0; i < arr.length - 1; i++) {
int minIndex = i;
for (int j = i + 1; j < arr.length; j++) {
minIndex = arr[minIndex] > arr[j] ? j : minIndex;
}
swap(arr, i, minIndex);
}
}
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
/**
* 生成随机数组 for test
*
* @param maxLength 数组最大长度
* @param maxValue 数组中最大值
* @return 生成的数组
*/
private static int[] generateRandomArr(int maxLength, int maxValue) {
//1 ~ maxLength
maxLength = (int) (Math.random() * maxLength) + 1;
int[] arr = new int[maxLength];
for (int i = 0; i < maxLength; i++) {
arr[i] = (int) (Math.random() * maxValue);
}
return arr;
}
/**
* 复制数组 for test
*
* @param arr 原数组
* @return 复制出来的数组
*/
private static int[] copyArr(int[] arr) {
int[] result = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
result[i] = arr[i];
}
return result;
}
/**
* 比较两个数组是否相等 for test
*
* @return
*/
private static boolean isEqualArr(int[] arr1, int[] arr2) {
if (arr1 == null && arr2 != null ||
arr1 != null && arr2 == null ||
arr1.length != arr2.length) {
return false;
}
for (int i = 0; i < arr1.length; i++) {
if (arr1[i] != arr2[i]) {
return false;
}
}
return true;
}
//for test
public static void main(String[] args) {
int maxLength = 10;
int maxValue = 10;
int testNum = 10000;
System.out.println("测试开始");
for (int i = 0; i < testNum; i++) {
int[] arr1 = generateRandomArr(maxLength, maxValue);
int[] arr2 = copyArr(arr1);
sort(arr1);
Arrays.sort(arr2);
if (!isEqualArr(arr1, arr2)) {
System.out.println("出错啦");
}
}
System.out.println("测试结束,没有出错");
}
}
二、冒泡排序
过程:
在arr[0~N-1]范围上:
arr[0]和arr[1],谁大谁来到1位置;arr[1]和arr[2],谁大谁来到2位置…arr[N-2]和arr[N-1],谁大谁来到N-1位置
在arr[0~N-2]范围上,重复上面的过程,但最后一步是arr[N-3]和arr[N-2],谁大谁来到N-2位置
在arr[0~N-3]范围上,重复上面的过程,但最后一步是arr[N-4]和arr[N-3],谁大谁来到N-3位置
…
最后在arr[0~1]范围上,重复上面的过程,但最后一步是arr[0]和arr[1],谁大谁来到1位置
估算:
很明显,如果arr长度为N,每一步常数操作的数量,依然如等差数列一般
所以,总的常数操作数量 = a*(N^2) + b*N + c (a、b、c都是常数)
所以冒泡排序的时间复杂度为O(N^2)。
/**
* 冒泡排序
*/
public class BubbleSort {
public static void sort(int[] arr){
if(arr == null || arr.length < 2){
return;
}
for (int i = arr.length - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
if(arr[j] > arr[j+1]){
//交换
swap(arr,j,j+1);
}
}
}
}
private static void swap(int[] arr,int i,int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
三、插入排序
过程:
想让arr[0~0]上有序,这个范围只有一个数,当然是有序的。
想让arr[0~1]上有序,所以从arr[1]开始往前看,如果arr[1]<arr[0],就交换。否则什么也不做。
…
想让arr[0~i]上有序,所以从arr[i]开始往前看,arr[i]这个数不停向左移动,一直移动到左边的数字不再比自己大,停止移动。
最后一步,想让arr[0~N-1]上有序, arr[N-1]这个数不停向左移动,一直移动到左边的数字不再比自己大,停止移动。
估算时发现这个算法流程的复杂程度,会因为数据状况的不同而不同。
如果某个算法流程的复杂程度会根据数据状况的不同而不同,那么你必须要按照最差情况来估计。
很明显,在最差情况下,如果arr长度为N,插入排序的每一步常数操作的数量,还是如等差数列一般
所以,总的常数操作数量 = a*(N^2) + b*N + c (a、b、c都是常数)
所以插入排序排序的时间复杂度为O(N^2)。
/**
* 插入排序
*/
public class InsertSort {
public static void sort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
for (int i = 1; i < arr.length; i++) {
for (int j = i - 1; j >= 0 && j >= 0 && arr[j] > arr[j + 1]; j--) {
//交换
swap(arr, j, j + 1);
}
}
}
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}