【基本排序实现 笔记记录】

冒泡排序 稳定的排序

冒泡排序是一种稳定排序，因为在两个数交换的时候，如果两个数相同，那么它们并不会因为算法中哪条语句相互交换位置
时间复杂度：是 O(n^2)

	//冒泡排序
	public static void bubbleSort(int[] arr) {
		int n=arr.length;
		for (int i = 0; i < n - 1; i++) {// 控制比较轮次，一共 n-1 趟
			for (int j = 0; j < n - 1 - i; j++) {// 控制两个挨着的元素进行比较
				if (arr[j] > arr[j + 1]) {
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
		}
	}

选择排序 不稳定的排序

时间复杂度：是 O(n^2)
第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法

	//选择排序
	public static void selectionSort(int arr [] ){
		int n=arr.length;
		int minindex,temp;
		for (int i = 0; i < n-1; i++) {
			minindex=i;
			for (int j = i+1; j < n; j++) {
				if (arr[j]<arr[minindex]) {// 寻找最小的数
					minindex=j; // 将最小数的索引保存
				}
			}
			temp=arr[i];
			arr[i]=arr[minindex];
			arr[minindex]=temp;
		}
	}

插入排序 稳定的排序

插入排序的平均时间复杂度也是 O(n^2)，空间复杂度为常数阶 O(1)，具体时间复杂度和数组的有序性也是有关联的。
插入排序中，当待排序数组是有序时，是最优的情况，只需当前数跟前一个数比较一下就可以了，这时一共需要比较 N-1 次，时间复杂度为 O(N)。最坏的情况是待排序数组是逆序的，此时需要比较次数最多，最坏的情况是 O(n^2)。

// 插入排序
	public static void insertionSort(int arr[]) {
		for (int i = 1; i < arr.length; i++) {// i: 代表即将插入的元素角标,作为每一组比较数据的最后一个元素
			for (int j = i; j > 0; j--) { // j:代表数组角标
				if (arr[j - 1] > arr[j]) {// 符合条件，插入元素（交换位置）
					int temp = arr[j];
					arr[j] = arr[j - 1];
					arr[j - 1] = temp;
				}
			}
		}
	}

希尔排序 不稳定

希尔排序(Shell’s Sort)是插入排序的一种又称“缩小增量排序”是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。
时间复杂度：O(n^（1.3—2）)

public static void shellSort(int arr[]) {
		// 不断缩小增量
		for (int interval = arr.length / 2; interval > 0; interval /= 2) {
			// 增量为1的插入排序
			for (int i = interval; i < arr.length; i++) {
				int target = arr[i];
				int j = i - interval;
				while (j < -1 && target < arr[j]) {
					arr[j + interval] = arr[j];
					j -= interval;
				}
				arr[j + interval] = target;
			}