JAVA 十大排序算法（自用笔记）

排序算法

一、排序算法一缆

二、算法的时间复杂度O(n^M)（算法（程序）的执行时间）

①、度量算法（程序）的执行时间的两种方法，已经时间频度

1）、事后统计的方法
这种方法可行，但是有两个问题，一是要想对设计的算法的运行性能进行评测，需要实际运行该程序，二是所得时间的统计量依赖于计算机的硬件、软件等环境因素，这种方式，要在同一计算机的相同状态下运行，才能比较那个算法速度更快。

2）、事前估算的方法
通过分析某个算法的时间复杂度来判断那个算法更优

3）、时间频度
一个算法花费的时间与算法中语句的执行次数成正比，哪个算法中语句执行次数多，它花费的时间就多，一个算法中语句执行次数称之为语句频度或者时间频度，记为T(n)

4）、计算时间复杂度时，可以忽略常数项、低次项，系数项，因为当数据量足够大时，它们已经起不到关键性的作用了。它们不会随n值的增大而增大

5）、如何计算时间复杂度以及时间复杂度需要注意的细节（来源于Car大佬的学习网址，里面的东西是真不错）

三、算法的空间复杂度
1）、.类似于时间复杂度的讨论，一个算法的空间复杂度(Space Complexity)定义为该算法所耗费的存储空间，它也是问题规模n的函数。

2）、空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度。有的算法需要占用的临时工作单元数与解决问题的规模n有关，它随着n的增大而增大，当n较大时，将占用较多的存储单元，例如快速排序和归并排序算法就属于这种情况

3）、在做算法分析时，主要讨论的是时间复杂度。从用户使用体验上看，更看重的程序执行的速度。一些缓存产品(redis, memcache)和算法(基数排序)本质就是用空间换时间.

四、排序算法

① 冒泡排序（稳定，最坏时间复杂度O(n^2)）
我都不想重写写遍，太常见，太基础，看这篇博客，有图解，有代码，有思路，很🆗的。
冒泡排序

② 简单选择排序（不稳定，最坏时间复杂度O(n^2)，比冒泡排序要快，测试方法使用了事后统计法）

1)、基本思想，取出数组中最小的放到最前面，取出的数据不与下次做对比，最后就得出排序后的数组了。

2)、基于此思想的算法主要有简单选择排序、树型选择排序和堆排序。

3)、简单选择排序的的基本思路：从arr[1]_{arr[n]中选出最小，与arr[1]交换位置，在从arr[2]}arr[n]中选出最小值，与arr[2]交换位置，以此类推。

4）、代码

/**
	 * 简单选择排序,时间复杂度：O(n2)
	 *虽然时间复杂度一样，但是比冒泡要快
	 * @param arr
	 * @return
	 */
	public static int[] selectSort(int arr[]) {
		for (int i = 0; i < arr.length - 1; i++) {
			int k = i;//拿到第一次遍历的值
			for (int j = k + 1; j < arr.length; j++) {//temp+1,temp的后一个值
				if (arr[j] < arr[k]) {//小于记录下最小值的位置
					k = j;
				}
			}
			//找到最小值，交换位置
			if (i != k) {
				int temp = arr[i];
				arr[i] = arr[k];
				arr[k] = temp;
			}
		}
		return arr;
	}

③ 简单插入排序
1)、基本思想:把待排序的列表看成一个有序列表和一个无序列表，开始时有序列表中只包含一个元素，无序列表中包含有n-1个元素，排序过程中，每次从无序表中取出第一个元素与有序表中的元素进行比较，将他插到合适的位置，使之变为有序列表

2)、代码：

	/**
	 * 插入排序
	 * 时间复杂度 O(n2)
	 */
	public static int[] insertSort(int[] arr){
		//从1开始与前面的值比较
		for (int i = 1; i < arr.length; i++) {
			int k=arr[i];//待插入的数
			int v=i-1;//待插入的前一个
			/**
			 * v>=0 保证在给 k找插入位置，不越界
			 * k<arr[v] 待插入的数，还没有找到位置
			 * 需要后移，满足条件表示k不能插在原来的位置，v需要后移给我们的k预留我i之，v--让k与v前面位置的值比较，v>=0防止越界
			 */
			while (v>=0 && k<arr[v]){
				arr[v+1]=arr[v];
				v--;
			}
			//退出while循环，说明位置找到看，放到当前v的后面一位，一位不满足条件是当前值大于v下标的值，所以在放在v的后一位。
			if (v+1!=i){
				arr[v+1]=k;
			}
		}
		return arr;
	}

④ 简单希尔排序插入排序的一种（交换法，不推荐使用）

	/**
	 * 希尔排序时，对有序序列在插入时采用交换法，并测试排序速度，速度比简单插入排序还慢
	 * @param arr
	 * @return
	 */
	public static  int[] ShellSort(int[] arr){
		//增量gap，并逐步缩小增量
		for (int gap = arr.length/2; gap >0 ; gap /=2) {
			int temp = 0;
			//将gap.length个数据分成gap.length/2组
			for (int i = gap; i < arr.length; i++) {
				//遍历各组中，所有的元素（共gap组），步长gap
				for (int j = i - gap; j >= gap; j -= gap) {
					//如果当前元素大于加上步长后的那个元素，说明交换
					if (arr[j] > arr[j + gap]) {
						temp = arr[j];
						arr[j] = arr[j + gap];
						arr[j + gap] = temp;
					}
				}
			}
		}
		return arr;
	}

⑤ 希尔排序（移动法

	/**
	 * 希尔排序时，对有序序列在插入时采用移动法，并测试排序速度，速度比简单插入排序快很多
	 * @param arr
	 * @return
	 */
	public static  int[] ShellSort2(int[] arr){
		//增量gap，并逐步缩小增量
		for (int gap = arr.length/2; gap >0 ; gap /=2) {
			//从gap个元素，逐个对其所在的组进行直接插入排序
			for (int i = gap; i < arr.length ; i++) {
				int j =i;
				int temp=arr[j];
				if (arr[j]<arr[j-gap]){
					while (j-gap>=0 && temp<arr[j-gap]){
						//移动
						arr[j]=arr[j-gap];
						j-=gap;
					}
					//退出while，找到位置
					arr[j]=temp;
				}
			}
		}
		return arr;
	}

⑦ 快速排序
1）、核心思想:快速排序

2）、代码

/**
	 * 快速排序
	 * @param array
	 */
	public static int[]  quickSort(int[] array) {
		int len;
		if(array == null
				|| (len = array.length) == 0
				|| len == 1) {
			return array;
		}
		sort(array, 0, len - 1);
		return array;
	}
	/**
	 * 快排核心算法，递归实现
	 * @param array
	 * @param left
	 * @param right
	 */
	public static void sort(int[] array, int left, int right) {
		if(left > right) {
			return;
		}
		// base中存放基准数
		int base = array[left];
		int i = left, j = right;
		while(i != j) {
			// 顺序很重要，先从右边开始往左找，直到找到比base值小的数
			while(array[j] >= base && i < j) {
				j--;
			}

			// 再从左往右边找，直到找到比base值大的数
			while(array[i] <= base && i < j) {
				i++;
			}

			// 上面的循环结束表示找到了位置或者(i>=j)了，交换两个数在数组中的位置
			if(i < j) {
				int tmp = array[i];
				array[i] = array[j];
				array[j] = tmp;
			}
		}

		// 将基准数放到中间的位置（基准数归位）
		array[left] = array[i];
		array[i] = base;

		// 递归，继续向基准的左右两边执行和上面同样的操作
		// i的索引处为上面已确定好的基准值的位置，无需再处理
		sort(array, left, i - 1);
		sort(array, i + 1, right);
	}

	public static int[] mergeSort(int[] a,int low,int high){
		int mid = (low+high)/2;
		if(low<high){
			mergeSort(a,low,mid);
			mergeSort(a,mid+1,high);
			//左右归并
			merge(a,low,mid,high);
		}
		return a;
	}

	public static void merge(int[] a, int low, int mid, int high) {
		int[] temp = new int[high-low+1];
		int i= low;
		int j = mid+1;
		int k=0;
		// 把较小的数先移到新数组中
		while(i<=mid && j<=high){
			if(a[i]<a[j]){
				temp[k++] = a[i++];
			}else{
				temp[k++] = a[j++];
			}
		}
		// 把左边剩余的数移入数组
		while(i<=mid){
			temp[k++] = a[i++];
		}
		// 把右边边剩余的数移入数组
		while(j<=high){
			temp[k++] = a[j++];
		}
		// 把新数组中的数覆盖nums数组
		for(int x=0;x<temp.length;x++){
			a[x+low] = temp[x];
		}
	}