数据结构中的10中排序算法代码（面试常考题）

package chapter9排序;
/**
 * 实现排序的几种算法
*/
public class SortData {
	/**
	 * 1.最简单的排序实现
	 */
	public void bubble0(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[i] > arr[j]) {
					SortTest.swap(arr, i, j);
				}
			}
		}
	}

	/**
	 * 2.基本的冒泡排序算法
	 */
	public void bubble1(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			for (int j = arr.length - 2; j >= i; j--) {
				if (arr[j] > arr[j + 1]) {
					SortTest.swap(arr, j, j + 1);
				}
			}
		}
	}

	/**
	 * 3.冒泡排序优化
	 */
	public void bubble2(int[] arr) {
		// 定义一个状态变量，用于检测接下来的比较还有没有必要
		boolean flag = true;
		for (int i = 0; i < arr.length && flag; i++) {
			flag = false;
			for (int j = arr.length - 2; j >= i; j--) {
				// 只要不进入if块 flag就不会改变 接下的循环就没必要了
				if (arr[j] > arr[j + 1]) {
					SortTest.swap(arr, j, j + 1);
					flag = true;
				}
			}
		}
	}

	/**
	 * 4.简单选择排序
	 */
	public void selectSort(int[] arr) { // 交换的次数少
		// 利用一个min下表保存一个一次排序的最小值
		for (int i = 0; i < arr.length; i++) {
			int min = i;
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[j] < arr[min]) {
					min = j;
				}
			}
			if (i != min) {// 如果i在这次排序中本身最小 就不用交换了
				SortTest.swap(arr, i, min);
			}
		}
	}

	/**
	 * 5.直接插入排序
	 */
	public void insertSort(int[] arr) {
		for (int i = 1; i < arr.length; i++) {
			for (int j = i; (j > 0) && (arr[j] < arr[j - 1]); j--) {
				SortTest.swap(arr, j - 1, j);
			}
		}
	}

	/**
	 * 6.希尔排序 直接插入排序升级版（跳着插）
	 */
	public void shellSort(int[] arr) {
		int increment = arr.length;
		do {
			increment = increment / 3 + 1;// 2
			for (int i = increment; i < arr.length; i++) {
				if (arr[i] < arr[i - increment]) {
					SortTest.swap(arr, i, i - increment);
				}
			}
		} while (increment > 1);
	}

	/**
	 * 7.堆排序
	 */
	public void heapSort(int[] arr) {
		for (int i = arr.length / 2 - 1; i >= 0; i--) {
			heapAdjust(arr, i, arr.length - 1);
		}
		// 调整完大顶堆
		for (int j = arr.length - 1; j >= 1; j--) {
			SortTest.swap(arr, 0, j);
			heapAdjust(arr, 0, j - 1);
		}
	}

	public void heapAdjust(int[] arr, int s, int m) {
		int temp = arr[s];
		int j;
		for (j = 2 * s; j <= m; j *= 2) {
			if (j < m && arr[j] < arr[j + 1]) {
				j = j + 1;
			}
			if (temp >= arr[j]) {
				break;
			}
			arr[s] = arr[j];
			s = j;
		}
		arr[s] = temp;
	}

	/**
	 * 8.归并排序
	 */
	public void mergeSort(int[] arr) {

		int[] temp = new int[arr.length];
		merge(arr, temp, 0, arr.length - 1);
	}

	public void merge(int[] data, int[] temp, int l, int r) {
		int mid = (l + r) / 2;
		if (l == r)
			return;
		merge(data, temp, l, mid);
		merge(data, temp, mid + 1, r);

		for (int i = l; i <= r; i++) {
			temp[i] = data[i];
		}
		int i1 = l; // 两个起点
		int i2 = mid + 1;
		for (int cur = l; cur <= r; cur++) {
			if (i1 == mid + 1) // 处理小号越界
				data[cur] = temp[i2++];
			else if (i2 > r)// 处理大号越界
				data[cur] = temp[i1++];
			else if (temp[i1] < temp[i2])
				data[cur] = temp[i1++];
			else
				data[cur] = temp[i2++];
		}
	}

	/**
	 * 9.快速排序
	 */

	public void quickSort(int[] arr) {
		quickSort1(arr, 0, arr.length - 1);
	}

	public void quickSort1(int[] arr, int low, int high) {
		int pivot = 0;//
		if (low < high) {
			pivot = partition(arr, low, high);
			quickSort1(arr, low, pivot - 1);
			quickSort1(arr, pivot + 1, high);
		}
	}

	public int partition(int[] arr, int low, int high) {
		// int prikey = arr[randomIndex];
		int pivotkey = arr[low];
		// int pivotkey = array[];
		while (low < high) {
			while (low < high && arr[high] >= pivotkey) {
				high--;
			}
			SortTest.swap(arr, high, low);
			while (low < high && arr[low] <= pivotkey) {
				low++;
			}
			SortTest.swap(arr, high, low);
		}
		return high;
	}

	/*
	 * 10.二分查找代码
	 */
	public static int binarySearch(int[] srcArray, int des) {
		int low = 0;
		int high = srcArray.length - 1;
		while (low <= high) {
			int middle = (low + high) / 2;
			if (des == srcArray[middle]) {
				return middle;
			} else if (des < srcArray[middle]) {
				high = middle - 1;
			} else {
				low = middle + 1;
			}
		}
		return -1;
	}
}