常见的Java排序算法总结

常见的Java排序算法总结如下：

（1）快速排序算法 — 平均时间复杂度O(nlogn)

	private static void QuickSort(int[] arr, int start, int end){
			if(start < end){
			//先找一个基数
				int stad = arr[start];
			   //记录需要排序的下标
			   int low = arr[start];
			   int high = arr[end];
			   //循环找出比基数大的数，比基数小的数
			   while(low < high){
			   		//右边的数比基数大
			   		while(low < high && stad <= arr[high]){
			   				high--;
			   		}
			   		//使用右边的数替换左边的数
			   		arr[low] = arr[high];
			   		//左边的数比基数小
			   		while(low < high && arr[low] <= stad){
			   				low++;
			   		}
			   		//使用左边的数替换右边的数
			   		arr[high] = arr[low];
			   }
			   //把基数赋给低位置所在元素
			   arr[low] = stad;
			   //使用递归进行排序剩下的数
			   QuickSort(arr, stad, low);
			   QuickSort(arr, low+1, high);
			}
	}

(2) 冒泡排序算法 — 平均时间复杂度O(n^2)

private static void BubbleSort(int[] arr){
	//控制一共要进行比较多少轮
	for(int i = 0; i < arr.length-1; i++){
		//比较次数
		for(int j = 0; j < arr.length-i-1; j++){
			if(arr[j] > arr[j+1]){
				int temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}
		}
	}
}

(3) 选择排序算法 — 平均时间复杂度O(n^2)

private static void SelectSort(int[] arr){
	 int len = arr.length;
	 for(int i = 0; i < len-1; i++){
	 	for(int j = i+1; j < len; j++){
	 		if(arr[i] > arr[j]){
	 			int remp = arr[i];
	 			arr[i] = arr[j];
	 			arr[j] = remp;
	 		}
	 	}
	 }
}

(4) 插入排序算法 — 平均时间复杂度O(n^2)

private static void InSertSort(int[] arr){
	//遍历所有数字
	for(int i = 1; i < arr.length; i++){
		//如果当前数字比前一个数字小
		if(arr[i] < arr[i-1]){
			//把当前遍历数存储起来
			int temp = arr[i];
			//遍历当前数字前的所有数字
			for(int j = i-1; j >= 0 && temp < arr[j]; j--){
				//如果当前数小于前一个数，把当前数赋给后一个数
				arr[j+1] = arr[j];
			}
			//把临时变量（外层for循环的当前元素）赋给不满足条件的后一个元素
			arr[j+1] = temp;
		}
	}
}

(5) 归并排序算法 — 平均时间复杂度O(nlogn)

private static void MergeSort(int[] arr, int low, int high){
	if(low < high){
		int mid = (low + high)/2;
		//递归遍历
		MergeSort(arr, low mid);
		MergeSort(arr, mid+1, high);
		merge(arr, low, mid, high);
	}
}
private static void merge(int[] arr, int low, int mid, int high){
	//用于存储归并后的数组
	int[] temp = new int[high - low + 1];
	//记录第一个数组中需要遍历的下标
	int i = low;
	//记录第二个数组中需要遍历的下标
	int j = mid+1;
	//记录在临时数组中存放的下标
	int index = 0;
	//遍历两个数组取出小的数字放入临时数组中
	while(i <= mid && j <= high){
		//第一个数组中的元素更小
		if(arr[i] <= arr[j]){
				//将小的数据放入临时数组中
			temp[index++] = arr[i++];
		}else{
			temp[index++] = arr[j++];
		}
	}
	//出来多余的数组
	while(i <= mid){
		temp[index++] = arr[i++];
	}
	while(j <= high){
		temp[index++] = arr[j++];
	}
	//把临时数组中的元素放回原数组
	for(int k = 0; k < temp.length; k++){
		arr[k+low] = temp[k];
	}
}

(6) 希尔排序算法 — 平均时间复杂度O(nlogn)

private static void ShellSort(int[] arr){
	int step = arr.length/2;
	while(step > 1){
		for(int i = step; i < arr.length; i += step){
			int temp = arr[i];
			for(int j = i; j > 0 && arr[j-step] > temp; j -= step){
				arr[j] = arr[j-step];
			}
			arr[j] = temp;
		}
		step /= 2;
	}
}

（7）一个简单的列表递归排序算法

private static void RecursionSort(List items){
	if(items.size() > 1){
	//新建三个临时链表
		List smaller = new ArrayList<>();   //较小的数
		List same= new ArrayList<>();       //相同的数字
		List larger= new ArrayList<>();     //较大的数
		//取到链表中间位置的数
		Integer choseItem = items.get(items.size()/2);
		//遍历和该数进行比较
		for(Integer i : items){
			if(i > choseItem)
				larger.add(i);
			else if(i < choseItem)
				smaller.add(i);
			else 
			    same.add(i);
		}
		//遍历对每一个临时链表中数进行排序
		RecursionSort(smaller);
		RecursionSort(larger);
		//把临时链表的数放回到原链表中
		items.clear();
		items.addAll(smaller);
		items.addAll(same);
		items.addAll(larger);
	}
}

常见Java排序算法时间复杂度总结如下：