排序算法代码—Java实现

public class Main {

	public static void main(String[] args) {
		int[] arr = { 34, 21, 54, 18, 23, 76, 38, 98, 45 };
		System.out.print("排序前：");
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		bubbleSort(arr);// 冒泡排序
		System.out.print("排序后：");
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
	}

	/**
	 * 1.直接插入排序
	 * 
	 * @param arr
	 *            待排序数组
	 */
	public static void insertSort(int[] arr) {
		for (int i = 1; i < arr.length; i++) {
			int currentelement = arr[i];
			int j;// 必须定义在外面，不能定义在for循环语句内，否则下面的arr[j+1]=currentelement;会报错
			for (j = i - 1; j >= 0 && currentelement < arr[j]; j--) {
				arr[j + 1] = arr[j];
			}
			arr[j + 1] = currentelement;
		}
	}

	/**
	 * 2.希尔排序
	 * 
	 * @param arr
	 *            待排序数组
	 * @param dlta
	 *            增量序列存储在dk数组
	 */
	public static void shellSort(int[] arr, int[] dlta) {
		for (int i = 0; i < dlta.length; i++) {
			shellInsert(arr, dlta[i]);
		}
	}

	/**
	 * 对数据做一趟希尔排序
	 * 
	 * @param arr
	 *            待排序数组
	 * @param dk
	 *            增量，当dk=1为直接插入排序
	 */
	public static void shellInsert(int[] arr, int dk) {
		for (int i = dk; i < arr.length; i++) {
			int currentelement = arr[i];
			int j;
			for (j = i - dk; j >= 0 && currentelement < arr[j]; j -= dk) {
				arr[j + dk] = arr[j];
			}
			arr[j + dk] = currentelement;
		}
	}

	/**
	 * 3.快速排序
	 * 
	 * @param arr
	 *            待排序数组
	 * @param low
	 * @param high
	 */
	public static void quickSort(int[] arr, int start, int end) {
		if (start < end) {
			int index = partition(arr, start, end);
			quickSort(arr, start, index - 1);
			quickSort(arr, index + 1, end);
		}
	}

	/**
	 * 返回关键字所在位置
	 * 
	 * @param arr
	 *            待排序数组
	 * @param low
	 * @param high
	 * @return
	 */
	public static int partition(int[] arr, int low, int high) {
		int key = arr[low];
		while (low < high) {
			while (low < high && arr[high] >= key)
				high--;
			arr[low] = arr[high];
			while (low < high && arr[low] <= key)
				low++;
			arr[high] = arr[low];
		}
		arr[low] = key;
		return low;
	}

	/**
	 * 4.选择排序
	 * 
	 * @param arr
	 *            待排序数组
	 */
	public static void selectSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {
			int j = minKey(arr, i);
			if (i != j) {
				int temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
		}
	}

	/**
	 * 返回数据中最小值的下标
	 * 
	 * @param arr
	 *            待排序数组
	 * @param i
	 *            数据起始位置
	 * @return
	 */
	public static int minKey(int[] arr, int i) {
		int min = i;
		for (int j = i + 1; j < arr.length; j++) {
			if (arr[j] < arr[min])
				min = j;
		}
		return min;
	}

	/**
	 * 5.堆排序
	 * 
	 * @param arr
	 *            待排序数组
	 */
	public static void heapSort(int[] arr) {
		for (int i = arr.length / 2 - 1; i >= 0; i--) {
			heapAdjust(arr, i, arr.length);
		}
		for (int i = arr.length - 1; i > 0; i--) {
			int temp = arr[0];
			arr[0] = arr[i];
			arr[i] = temp;
			heapAdjust(arr, 0, i);
		}
	}

	/**
	 * 调整为大顶堆
	 * 
	 * @param arr
	 *            待调整数组
	 * @param f
	 *            父节点下标
	 * @param len
	 *            数组长度
	 */
	public static void heapAdjust(int[] arr, int f, int len) {
		int father = arr[f];
		for (int j = 2 * f + 1; j < len; j = 2 * j + 1) {
			if (arr[j] < arr[j + 1] && j < len - 1)
				j++;
			if (arr[j] <= father)
				break;
			arr[f] = arr[j];
			f = j;
		}
		arr[f] = father;
	}

	/**
	 * 6.归并排序
	 * 
	 * @param arr
	 *            待排序数组
	 * @param start
	 *            起始位置
	 * @param end
	 *            结束位置
	 */
	public static void mergeSort(int[] arr, int start, int end) {
		int mid = (start + end) / 2;
		if (start < end) {
			mergeSort(arr, start, mid);
			mergeSort(arr, mid + 1, end);
			merge(arr, start, mid, end);
		}
	}

	/**
	 * 将数组中前后相邻的2个有序序列调整为1个有序序列
	 * 
	 * @param arr
	 *            待调整数组
	 * @param start
	 *            第1个序列的起始位置
	 * @param mid
	 *            第1个序列的结束位置
	 * @param end
	 *            第2个序列的结束位置
	 */
	public static void merge(int[] arr, int start, int mid, int end) {
		int[] fin = new int[end - start + 1]; // 存储合并后序列
		int i = start;
		int j = mid + 1;
		int k = 0;
		while (i <= mid && j <= end) {
			if (arr[i] < arr[j])
				fin[k++] = arr[i++];
			else
				fin[k++] = arr[j++];
		}
		while (i <= mid)
			fin[k++] = arr[i++];
		while (j <= end)
			fin[k++] = arr[j++];

		for (int m = 0; m < fin.length; m++) {
			arr[m + start] = fin[m];
		}
	}

	/**
	 * 7.冒泡排序
	 * 
	 * @param arr
	 *            待排序数组
	 */
	public static void bubbleSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++)
			// 表示(arr.length-1)次排序过程
			for (int j = 0; j < arr.length - i - 1; j++) {
				if (arr[j] > arr[j + 1]) {
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
	}
}