【java】八大基础排序算法

1.冒泡排序

比较简单的排序算法，前后元素两两交换，平均时间复杂度O(n^2),空间复杂度O(1)，稳定

public static void main(String[] args) {
		int arr[] = {-1,-3,7,3,10,2};
		int temp = 0;
		boolean flag = false;//设置flag，若未发生交换则排序完成
		for(int i = 0;i<arr.length-1;i++) {//排序次数
			for(int j = 0;j<arr.length-1-i;j++) {//比较次数
				if(arr[j]>arr[j+1]) {
					flag = true;
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
			if(flag == false) {
				break;
			}else {
				flag = false;
			}
		}
		System.out.println("排序后:" + Arrays.toString(arr));
	}

2.选择排序

默认第一个元素最小，每次从待排序列中选择一个最小的元素与其交换，平均时间复杂度O(n^2),空间复杂度O(1)，不稳定

public static void main(String[] args) {
		int arr[] = {-1,2,-4,1,6};
		for(int i = 0;i<arr.length-1;i++) {
			int minIndex = i;//记录最小元素下标
			int min = arr[i];//最小值
			for(int j = i+1;j<arr.length;j++) {		
				if(arr[j]<min) {
					min = arr[j];
					minIndex = j;
				}
			}
			if(minIndex!=i) {
				arr[minIndex] = arr[i];
				arr[i] = min;
			}
		}
		System.out.println("排序后:" + Arrays.toString(arr));
	}

3.插入排序

从第二个元素开始将每个元素插入到待排队列的合适位置，同时其他元素后移，平均时间复杂度O(n^2),空间复杂度O(1)，稳定

public static void main(String[] args) {
		int[] arr = {-1,3,2,6,-4};
		int insertVal = 0;
		int insertIndex = 0;
		for(int i = 1;i < arr.length; i++) { 
			insertVal = arr[i];
			insertIndex = i-1;
			while(insertIndex>=0 && insertVal < arr[insertIndex]) {
				arr[insertIndex + 1] = arr[insertIndex];//后移
				insertIndex--;
			}
			if(insertIndex != i-1) {
				arr[insertIndex + 1] = insertVal;
			}
		}
		System.out.println("排序后:" + Arrays.toString(arr));
	}

4.希尔排序

先取一个整数d1作为第一个增量，把待排队列分组。所有距离为d1的元素放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量 =1( < …<d2<d1)，即所有记录放在同一组中进行直接插入排序为止

public static void main(String[] args) {
		int[] arr = {8,9,1,7,2,3,5,4,6,0};
		shellSort(arr);
	}
	public static void shellSort(int[] arr) {
		for(int gap = arr.length/2; gap >0; gap /= 2) {
		//第一次增量取了数组长度的一半
			for(int i = gap; i<arr.length; i++) {
				int j = i;
				int temp = arr[j];
				while(j - gap >=0 && arr[j - gap] > temp) {
				//组内插入排序，注意以间隔插入
					arr[j] = arr[j-gap];
					j -= gap;
				}
				arr[j] = temp;
			}
		}
		System.out.println("排序后:" + Arrays.toString(arr));
	}//平均时间复杂度O(nlogn),空间复杂度O(1)，不稳定

还有一种组内交换式排序方法，但时间复杂度高，不推荐

public static void shellSort(int[] arr) {		
		int temp = 0;
		for(int gap = arr.length/2; gap > 0; gap /=2) {
			for(int i = gap;i < arr.length; i++) {
				for(int j = i - gap;j >= 0;j -= gap) {
					if(arr[j] > arr[j+gap]) {
						temp = arr[j];
						arr[j] = arr[j+gap];
						arr[j+gap] = temp;
					}
				}
			}
		}
		System.out.println("排序后:" + Arrays.toString(arr));
	}

5.快速排序

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程递归进行，最后使整个数据变成有序序列。平均时间复杂度O(nlogn),空间复杂度O(logn)，不稳定

public static void main(String[] args) {
		int[] arr = {8,9,1,7,2,3,5,4,6,0};
		quickSort(arr, 0, arr.length-1);
	}
	
	public static void quickSort(int[] arr,int left,int right) {
		int l = left;
		int r = right;
		int pivot = arr[(left + right) / 2];
		int temp = 0;
		while(l < r) {
			while(arr[l] < pivot) {
				l++;
			}
			while(arr[r] > pivot) {
				r--;
			}
			if(l >= r) {
				break;
			}
			temp = arr[l];
			arr[l] = arr[r];
			arr[r] = temp;
		}
		if(l == r) {
			l++;
			r--;
		}
		if(left < r) {
			quickSort(arr, left, r);
		}
		if(right > l) {
			quickSort(arr, l, right);
		}
		System.out.println("排序后:" + Arrays.toString(arr));
	}

6.归并排序（二路归并）

采用分治算法，将一个待排数组分为两个子数组，再继续分这两个子数组。即先使每个子序列有序，再使子序列段间有序。平均时间复杂度O(nlogn),空间复杂度O(n)，稳定

public static void main(String[] args) {
		int[] arr = {8,9,1,7,2,3,5,4,6,0};
		int[] temp = new int[arr.length];
		mergeSort(arr, 0, arr.length-1, temp);
		System.out.println("排序后:" + Arrays.toString(arr));
	}
	
	public static void mergeSort(int[] arr,int left,int right,int[] temp) {
		if(left < right) {
			int mid = (left + right)/2;
			mergeSort(arr, left, mid, temp);
			mergeSort(arr, mid+1, right, temp);
			merge(arr, left, mid, right, temp);
		}
	}
	
	public static void merge(int[] arr,int left,int mid,int right,int[] temp) {
		int i = left;
		int j = mid + 1;
		int t = 0;
		while(i <= mid && j <= right) {
			if(arr[i] < arr[j]) {
				temp[t++] = arr[i++];
			}else {
				temp[t++] = arr[j++];
			}
		}
		while(i <= mid) {
			temp[t++] = arr[i++];
		}
		while(j <= right) {
			temp[t++] = arr[j++];
		}
		
		t = 0;
		int tempLeft = left;
		while(tempLeft <= right) {
			arr[tempLeft++] = temp[t++];
		}
	}

7.堆排序

利用堆这种数据结构所设计的一种排序算法，先将堆调整为大顶堆或小顶堆，然后移除位在第一个数据的根节点，并做最大堆调整的递归运算。平均时间复杂度O(nlogn),空间复杂度O(1)，不稳定

public static void main(String[] args) {
		int[] arr = {4,6,8,5,9};
		heapSort(arr);		
	}
	
	public static void heapSort(int arr[]) {
		for(int i = arr.length / 2 - 1; i>=0; i--) {
			adjustHeap(arr, i, arr.length);
		}
		
		int temp = 0;
		for(int j = arr.length - 1; j>0; j--) {
			temp = arr[j];
			arr[j] = arr[0];
			arr[0] = temp;
			adjustHeap(arr, 0, j);
		}
		System.out.println("排序后:" + Arrays.toString(arr));
	}
	
	public static void adjustHeap(int[] arr, int i, int len) {
		int temp = arr[i];
		for(int k = i * 2 + 1; k < len; k = k * 2 + 1) {
			if(k+1 < len && arr[k] < arr[k+1]) {
				k++;
			}
			if(arr[k] > temp) {
				arr[i] = arr[k];
				i = k;
			}else {
				break;
			}
		}
		arr[i] = temp;
	}

8.基数排序

又称“桶子排序”，分别根据个位，十位，百位进行排序。

public static void main(String[] args) {
		int arr[] = {53,3,542,748,14,23,457};
		radixSort(arr);
	}
		
	public static void radixSort(int[] arr) {
		int bucket[][] = new int[10][arr.length];
		int max = arr[0];
		for(int i = 1; i<arr.length; i++) {
			if(max < arr[i]) {
				max = arr[i];
			}
		}
		int maxLenght = (max + "").length();
		
		int[] buckElementsCounts = new int[10];
		
		for(int i = 0 , n = 1; i < maxLenght; i++, n *= 10) {
			for(int j = 0; j < arr.length; j++) {
				int digitOfElments = arr[j] / n % 10;
				bucket[digitOfElments][buckElementsCounts[digitOfElments]] = arr[j];
				buckElementsCounts[digitOfElments]++;
			}
			int index = 0;
			for(int k = 0; k < buckElementsCounts.length; k++) {
				if(buckElementsCounts[k] != 0) {
					for(int l = 0; l < buckElementsCounts[k]; l++) {
						arr[index++] = bucket[k][l];
					}
				}
				buckElementsCounts[k] = 0;
			}
			System.out.println("排序后:" + Arrays.toString(arr));
		}
	}