排序算法基础总结

经典算法java代码实现

1.冒泡排序

	/***
	 * @冒泡排序
	 * @BubbleSort
	 * @param arr
	 */
	public static void BubbleSort(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,i,j);
			}
		}
	}

2.选择排序

	/***
	 * @选择排序
	 * @SelectionSort 两个指针，一个遍历指针，一个指向当前的最值
	 * @param arr
	 */
	public static void SelectionSort(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[j] < arr[minIndex] ? j : minIndex;
			}
			swap(arr, i, minIndex);
		}
	}

3.插入排序

	/***
	 * @插入排序
	 * @InsertionSort
	 * @param arr
	 */
	public static void InsertionSort(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--){
				if(arr[j]<arr[j+1])
					swap(arr,j,j+1);
				else
					break;
			}
		}
	}

4.归并排序

	/***
	 * @归并排序
	 * @mergeSort
	 * @param arr
	 */
	public static void mergeSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		mergeSort(arr, 0, arr.length - 1);
	}
	
	public static void mergeSort(int[] arr, int l, int r) {
		if (l == r) {
			return;
		}
		int mid = l + ((r - l) >> 1);
		mergeSort(arr, l, mid);
		mergeSort(arr, mid + 1, r);
		merge(arr, l, mid, r);
	}
	//两个有序数组 (l-m) (m+1 - r)的合并
	public static void merge(int[] arr, int l, int m, int r) {
		int[] help = new int[r - l + 1];//R-L+1
		int i = 0;
		int p1 = l;
		int p2 = m + 1;
		while (p1 <= m && p2 <= r) {
			help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
		}
		while (p1 <= m) {
			help[i++] = arr[p1++];
		}
		while (p2 <= r) {
			help[i++] = arr[p2++];
		}
		for (i = 0; i < help.length; i++) {
			arr[l + i] = help[i];
		}
	}

5.快速排序

	/***
	 * @快速排序  应用：荷兰国旗问题
	 * @quickSort
	 * @param arr
	 */
	public static void quickSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		quickSort(arr, 0, arr.length - 1);
	}

	public static void quickSort(int[] arr, int l, int r) {
		if (l < r) {
			swap(arr, l + (int) (Math.random() * (r - l + 1)), r);//随机快排，L-R上随机选个位置和R上的交换
			int[] p = partition(arr, l, r);
			quickSort(arr, l, p[0] - 1);
			quickSort(arr, p[1] + 1, r);
		}
	}

	public static int[] partition(int[] arr, int l, int r) {//以R位置上的数为参考值，小的左边，大的右边，等于的放中间
		int less = l - 1;
		int more = r;
		while (l < more) {
			if (arr[l] < arr[r]) {
				swap(arr, ++less, l++);
			} else if (arr[l] > arr[r]) {
				swap(arr, --more, l);
			} else {
				l++;
			}
		}
		swap(arr, more, r);
		return new int[] { less + 1, more };
	}

6.堆排序

	/***
	 * @堆排序
	 * 1.求大根堆
	 * 2.交换首尾
	 * 3.通过heapify下沉首节点
	 * @heapSort
	 * @param arr
	 */
	public static void heapSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		for (int i = 0; i < arr.length; i++) {//构建初始大根堆
			heapInsert(arr, i);
		}
		int size = arr.length;
		swap(arr, 0, --size);
		while (size > 0) {
			heapify(arr, 0, size);//构建出大根堆
			swap(arr, 0, --size);
		}
	}
	public static void heapInsert(int[] arr, int index) {//构造大根堆，index与其父节点比较
		while (arr[index] > arr[(index - 1) / 2]) {//arr[(0-1)/2] = arr[0]
			swap(arr, index, (index - 1) / 2);
			index = (index - 1) / 2;
		}
	}
	public static void heapify(int[] arr, int index, int size) {//由于将最大值和arr[0]互换，不规范的节点往下沉的过程
		int left = index * 2 + 1;//index的左孩子
		while (left < size) {
			int largest = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left;//记录当前孩子节点的最大值下标
			largest = arr[largest] > arr[index] ? largest : index;//记录当前子树（三个结点）的最大值下表
			if (largest == index) {
				break;
			}
			swap(arr, largest, index);//交换最大值
			index = largest;
			left = index * 2 + 1;
		}
	}

7.交换两个数的值

	/***
	 * @公共调用方法
	 * @采用两次异或交换两个数 
	 * @swap a,b
	 * @param arr
	 * @param i
	 * @param j
	 */
	public static void swap(int[] arr,int i,int j){
		arr[i] = arr[i]^arr[j];
		arr[j] = arr[i]^arr[j];
		arr[i] = arr[i]^arr[j];
	}