经典排序 java版-CSDN博客

本文链接：https://blog.csdn.net/iteye_4061/article/details/82553348

一些简单的排序 java代码实现，记录下来方便参考
1、冒泡排序



	public void sort(int[] arr){
		for(int i =0 ;i<arr.length -1 ;i++){
			for(int j = 0 ; j < arr.length -1 - i ; j++){
				int temp =0;
				if(arr[j] > arr[j+1]){
					temp = arr[j] ;
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
	}

2、插入排序


public void sort(int[] arrs) {
		for (int i = 1; i < arrs.length; i++) {
			for (int j = i; j > 0 && arrs[j] < arrs[j - 1]; j--) {
				int temp =0;
				temp = arrs[ j] ;
				arrs[j] = arrs[j-1];
				arrs[j-1] = temp; 
			}
		}
	}

3、选择排序



	public void sort(int[] arr){
		for(int i = 0 ; i < arr.length-1 ; i++){
			int temp = 0;
			for(int j =0;j<=arr.length -1 - i ;j++){
				if(arr[j] >= arr[temp]){
					temp = j;
				}
			}
			int t = arr[arr.length-1 -i] ;
			arr[arr.length -1- i] = arr[temp];
			arr[temp] = t;
		}
	}

4、快速排序


public int AdjustArray(int s[], int l, int r){
	    int i = l, j = r;
	    int x = s[l]; //s[l]即s[i]就是第一个坑
		while (i < j) {
			// 从右向左找小于x的数来填s[i]
			while (i < j && s[j] >= x)
				j--;
			if (i < j) {
				s[i] = s[j]; // 将s[j]填到s[i]中，s[j]就形成了一个新的坑
				i++;
			}

			// 从左向右找大于或等于x的数来填s[j]
			while (i < j && s[i] < x)
				i++;
			if (i < j) {
				s[j] = s[i]; // 将s[i]填到s[j]中，s[i]就形成了一个新的坑
				j--;
			}
		}
		// 退出时，i等于j。将x填到这个坑中。
		s[i] = x;
		return i;
	}
	//递归调用自身
	void quick_sort1(int s[], int l, int r) {
		if (l < r) {
			int i = AdjustArray(s, l, r);// 先成挖坑填数法调整s[]
			quick_sort1(s, l, i - 1); // 递归调用
			quick_sort1(s, i + 1, r);
		}
	}

5、堆排序


private static void buildMaxHeapify(int[] data) {
		// 没有子节点的才需要创建最大堆，从最后一个的父节点开始
		int startIndex = getParentIndex(data.length - 1);
		// 从尾端开始创建最大堆，每次都是正确的堆
		for (int i = startIndex; i >= 0; i--) {
			maxHeapify(data, data.length, i);
		}
	}

	/**
	 * 创建最大堆
	 * 
	 * @param data
	 * @param heapSize
	 *            需要创建最大堆的大小，一般在sort的时候用到，因为最多值放在末尾，末尾就不再归入最大堆了
	 * @param index
	 *            当前需要创建最大堆的位置
	 */
	private static void maxHeapify(int[] data, int heapSize, int index) {
		// 当前点与左右子节点比较
		int left = getChildLeftIndex(index);
		int right = getChildRightIndex(index);

		int largest = index;
		if (left < heapSize && data[index] < data[left]) {
			largest = left;
		}
		if (right < heapSize && data[largest] < data[right]) {
			largest = right;
		}
		// 得到最大值后可能需要交换，如果交换了，其子节点可能就不是最大堆了，需要重新调整
		if (largest != index) {
			int temp = data[index];
			data[index] = data[largest];
			data[largest] = temp;
			maxHeapify(data, heapSize, largest);
		}
	}

	/**
	 * 排序，最大值放在末尾，data虽然是最大堆，在排序后就成了递增的
	 * 
	 * @param data
	 */
	private static void heapSort(int[] data) {
		// 末尾与头交换，交换后调整最大堆
		for (int i = data.length - 1; i > 0; i--) {
			int temp = data[0];
			data[0] = data[i];
			data[i] = temp;
			maxHeapify(data, i, 0);
		}
	}

	/**
	 * 父节点位置
	 * 
	 * @param current
	 * @return
	 */
	private static int getParentIndex(int current) {
		return (current - 1) >> 1;
	}

	/**
	 * 左子节点position 注意括号，加法优先级更高
	 * 
	 * @param current
	 * @return
	 */
	private static int getChildLeftIndex(int current) {
		return (current << 1) + 1;
	}

	/**
	 * 右子节点position
	 * 
	 * @param current
	 * @return
	 */
	private static int getChildRightIndex(int current) {
		return (current << 1) + 2;
	}

	private static void print(int[] data) {
		int pre = -2;
		for (int i = 0; i < data.length; i++) {
			if (pre < (int) getLog(i + 1)) {
				pre = (int) getLog(i + 1);
				System.out.println();
			}
			System.out.print(data[i] + " |");
		}
	}

	/**
	 * 以2为底的对数
	 * 
	 * @param param
	 * @return
	 */
	private static double getLog(double param) {
		return Math.log(param) / Math.log(2);
	}