面试排序算法个人总结

总结了很久的排序算法，自己测试了很多次，一直写在笔记本上，还是怕弄丢了，还是贴到博客上面来吧

//冒泡排序：

/**
	 * 交换排序--冒泡排序
	 * 
	 * @param arr
	 */
	public static void bubbleSort(long arr[]) {
		int exchange = 1;// 1为有交换,0为无交换
		// 最多需要arr.length-1次交换(i不是下标)
		for (int i = 0; i < arr.length - 1; i++) {//需要做arr.length - 1交换
			exchange = 0;
			for (int j = arr.length - 1; j > i; j--) {//j>i的原因:每一趟都会将一个最小的数排到前面(正确的位置)
				if (arr[j - 1] > arr[j]) {
					long temp = arr[j];
					arr[j] = arr[j - 1];
					arr[j - 1] = temp;
					exchange = 1;
				}
			}
			if (exchange == 0) {
				return;
			}
		}
	}

 插入排序：

/**
	 * 直接插入排序
	 * 
	 * @param arr
	 */
	public static void insertSort(long[] arr) {
		long temp = 0;
		for (int i = 1; i < arr.length; i++) {
			temp = arr[i];
			int j = i;
			while (j > 0 && arr[j - 1] > temp) {
				arr[j] = arr[j - 1];
				j--;
			}
			arr[j] = temp;
		}
	}

   希尔排序:

/**
	 * 希尔排序
	 * @param arr
	 */
	public static void shellSort(long arr[]) {
		for (int dk = arr.length / 2; dk >= 1; dk = dk / 2) {// dk为增量
			for (int i = dk; i < arr.length; ++i) {
				if (arr[i] < arr[i - dk]) {
					long temp = arr[i];
					int j = i;
					while (j > dk - 1 && arr[j - dk] > temp) {
						arr[j] = arr[j - dk];
						j -= dk;
					}
					arr[j] = temp;
				}
			}
		}
	}

 快速排序:

	// 划分数组
	public static int partition(long arr[], int left, int right) {
		int leftPtr = left - 1;
		int rightPtr = right;
		long pivot = arr[right];
		while (true) {
			while (leftPtr < rightPtr && arr[++leftPtr] < pivot)
				;
			while (rightPtr > leftPtr && arr[--rightPtr] > pivot)
				;
			if (leftPtr >= rightPtr) {
				break;
			} else {
				// long temp = arr[leftPtr];
				// arr[leftPtr]=arr[rightPtr];
				// arr[rightPtr] = temp;
				swap(arr, leftPtr, rightPtr);
			}
		}
		// long temp = arr[leftPtr];
		// arr[leftPtr]=arr[right];
		// arr[right] = temp;
		swap(arr, leftPtr, right);
		return leftPtr;
	}

	private static void swap(long arr[], int i, int j) {
		long temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}

	// 快速排序
	public static void quickSort(long arr[], int left, int right) {
		if (left < right) {
			int pivotPos = partition(arr, left, right);
			quickSort(arr, left, pivotPos - 1);
			quickSort(arr, pivotPos + 1, right);
		}
	} 

  堆排序:

public static void heapSort(int[] array) {
		initHeap(array);
		// 这个过程就是不断的从堆顶移除，调整
		for (int i = 1; i < array.length; i++) {
			int temp = array[0];
			int end = array.length - i;
			array[0] = array[end];
			array[end] = temp;
			adjustHeap(array, 0, end);
		}
	}

	private static void initHeap(int[] array) {
		for (int i = array.length / 2 - 1; i >= 0; i--) {
			adjustHeap(array, i, array.length);
		}
	}

	private static void adjustHeap(int[] array, int n, int size) {
		int temp = array[n]; // 先拿出数据
		int child = n * 2 + 1; // 这个是左孩子
		while (child < size) { // 这个保证还有左孩子
			// 如果右孩子也存在的话，并且右孩子的值比左孩子的大
			if (child + 1 < size && array[child + 1] > array[child]) {
				child++;
			}
			if (array[child] > temp) {
				array[n] = array[child];
				n = child; // n需要重新计算
				child = n * 2 + 1; // 重新计算左孩子
			} else {
				// 这种情况说明左右孩子的值都比父结点的值小break;
			}
		}
		array[n] = temp;
	}

 //归并排序

public static int[] mergeSort(int[] array, int left, int right) {
		if (left == right) {
			return new int[] { array[left] };
		}
		int mid = (right + left) / 2;
		int[] l = mergeSort(array, left, mid);
		int[] r = mergeSort(array, mid + 1, right);
		return merge(l, r);
	}

	// 将两个数组合并成一个
	public static int[] merge(int[] l, int[] r) {
		int[] result = new int[l.length + r.length];
		int p = 0;
		int lp = 0;
		int rp = 0;
		while (lp < l.length && rp < r.length) {
			result[p++] = l[lp] < r[rp] ? l[lp++] : r[rp++];
		}
		while (lp < l.length) {
			result[p++] = l[lp++];
		}
		while (rp < r.length) {
			result[p++] = r[rp++];
		}
		return result;
	}

 //选择排序

// 每次从中选出最小的元素，只进行一次交换
	// 相比冒泡，大大减少了元素的交换次数
	public static void selectSort(int[] array) {
		for (int i = 0; i < array.length; i++) { // 确定了多少个元素
			int min = i; // 每次都默认第一个是最小的
			for (int j = i + 1; j < array.length; j++) {
				if (array[min] > array[j]) {
					min = j;
				}
			}
			int temp = array[min];
			array[min] = array[i];
			array[i] = temp;
		}
	}