Java(Scala)排序总结(选择|冒泡|插入|快速|归并)

Java版本

package sort;

import java.util.Arrays;

/**
 * @ClassName: Sort
 * @Description: 
 * @Author: xuezhouyi
 * @Version: V1.0
 **/
public class Sort {
	public static void main(String[] args) {
		int[] arr = {8, 6, 4, 2, 1, 3, 5, 7, 9};
		System.out.println(Arrays.toString(arr));
//		Choice(arr);
//		Bubble(arr);
//		Insert(arr);
//		Quick(arr, 0, arr.length - 1);
//		Merge(arr, 0, arr.length - 1);
		System.out.println(Arrays.toString(arr));
	}

	/* 归并排序 */
	private static void Merge(int[] arr, int start, int stop) {
		/* 开始和结束遇到则跳出 */
		if (start == stop) return;
		int middle = (start + stop) / 2;
		/* 左递归 */
		Merge(arr, start, middle);
		/* 有递归 */
		Merge(arr, middle + 1, stop);
		/* 合并 */
		_Merge(arr, start, middle, stop);
	}

	private static void _Merge(int[] arr, int start, int middle, int stop) {
		/* 临时数组存放 */
		int[] tmp = new int[stop - start + 1];
		int i = start, j = middle + 1, k = 0;
		/* 两段比较小的先放大的后放 */
		while (i <= middle && j <= stop) {
			if (arr[i] < arr[j]) tmp[k++] = arr[i++];
			else tmp[k++] = arr[j++];
		}
		/* 剩余直接放入 */
		while (j <= stop) tmp[k++] = arr[j++];
		while (i <= middle) tmp[k++] = arr[i++];
		/* 拷贝回去 */
		for (k = 0; k < tmp.length; k++) arr[start + k] = tmp[k];
	}

	/* 快速排序 */
	private static void Quick(int[] arr, int left, int right) {
		/* 左边大于右边则跳出 */
		if (left > right) return;
		/* 假定左边是中轴 */
		int start = left, stop = right, pivot = arr[left];
		while (start < stop) {
			/* 从右边开始找比标中轴的小的 */
			while (start < stop && arr[stop] >= pivot) stop--;
			/* 找到后放入中轴 */
			arr[start] = arr[stop];
			/* 在从左边找大于中轴的 */
			while (start < stop && arr[start] < pivot) start++;
			/* 找到后放入右边 */
			arr[stop] = arr[start];
		}
		/* 最后这个位置就是中轴的位置，放入即可 */
		arr[start] = pivot;
		Quick(arr, left, start - 1);
		Quick(arr, start + 1, right);
	}

	/* 插入排序 */
	private static void Insert(int[] arr) {
		/* 第一个默认有序 */
		for (int i = 1; i < arr.length; i++) {
			int tmp = arr[i];
			/* 只要前一个大后往后移 */
			while ((i - 1) >= 0 && arr[i - 1] > tmp) {
				arr[i] = arr[i - 1];
				i--;
			}
			/* 直到合适位置插入 */
			arr[i] = tmp;
		}
	}

	/* 冒泡排序 */
	public static void Bubble(int[] arr) {
		/* 最后一次不需要比较所以减一 */
		for (int i = 0; i < arr.length - 1; i++) {
			/* 每次取出后一个跟前一个进行比较 */
			for (int j = 0; j < arr.length - 1 - i; j++) {
				/* 小的往前放，大的往后放 */
				if (arr[j + 1] < arr[j]) {
					int tmp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = tmp;
				}
			}
		}
	}

	/* 选择排序 */
	public static void Choice(int[] arr) {
		/* 最后一次不需要比较所以减一 */
		for (int i = 0; i < arr.length - 1; i++) {
			/* 设置最小索引 */
			int k = i;
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[j] < arr[k]) {
					/* 找到最小索引 */
					k = j;
				}
			}
			/* 交换 */
			int tmp = arr[i];
			arr[i] = arr[k];
			arr[k] = tmp;
		}
	}
}

Scala版本

package sort

/**
 * @ClassName: Sort
 * @Description: 
 * @Author: xuezhouyi
 * @Version: V1.0
 **/
object Sort {
	def main(args: Array[String]) {
		val arr = Array(9, 7, 5, 3, 1, 2, 4, 6, 8)
//		choice(arr)
//		bubble(arr)
//		insert(arr)
//		quick(arr, 0, arr.length - 1)
//		merge(arr, 0, arr.length - 1)
		arr.foreach(i => print(i + " "))
	}

	/* 归并排序 */
	def merge(arr: Array[Int], start: Int, stop: Int) {
		if (start == stop) return
		val middle = (start + stop) / 2
		merge(arr, start, middle)
		merge(arr, middle + 1, stop)
		_merge(arr, start, middle, stop)
	}

	def _merge(arr: Array[Int], start: Int, middle: Int, stop: Int) {
		val _arr = new Array[Int](stop - start + 1)
		var i = start
		var j = middle + 1
		var k = 0
		while (i <= middle && j <= stop) {
			if (arr(i) < arr(j)) {
				_arr(k) = arr(i)
				i += 1
			}
			else {
				_arr(k) = arr(j)
				j += 1
			}
			k += 1
		}
		while (i <= middle) {
			_arr(k) = arr(i)
			k += 1
			i += 1
		}
		while (j <= stop) {
			_arr(k) = arr(j)
			k += 1
			j += 1
		}
		for (x <- 0 until (_arr.length)) {
			arr(start + x) = _arr(x)
		}
	}

	/* 快速排序 */
	def quick(arr: Array[Int], left: Int, right: Int) {
		if (left > right) return
		var start = left
		var stop = right
		val pivot = arr(left)
		while (start < stop) {
			while (start < stop && arr(stop) >= pivot) stop -= 1
			arr(start) = arr(stop)
			while (start < stop && arr(start) < pivot) start += 1
			arr(stop) = arr(start)
		}
		arr(start) = pivot
		quick(arr, left, start - 1)
		quick(arr, start + 1, right)
	}

	/* 插入排序 */
	def insert(arr: Array[Int]) = {
		for (i <- 1 until (arr.length)) {
			var j = i
			val tmp = arr(j)
			while ((j - 1) >= 0 && arr(j - 1) > tmp) {
				arr(j) = arr(j - 1)
				j -= 1
			}
			arr(j) = tmp
		}
	}

	/* 冒泡排序 */
	def bubble(arr: Array[Int]) {
		for (i <- 0 until (arr.length - 1)) {
			for (j <- 0 until (arr.length - 1 - i)) {
				if (arr(j + 1) < arr(j)) {
					val tmp = arr(j)
					arr(j) = arr(j + 1)
					arr(j + 1) = tmp
				}
			}
		}
	}

	/* 选择排序 */
	def choice(arr: Array[Int]) {
		for (i <- 0 until (arr.length - 1)) {
			var k = i
			for (j <- i + 1 until (arr.length)) {
				if (arr(j) < arr(k)) k = j
			}
			val tmp = arr(i)
			arr(i) = arr(k)
			arr(k) = tmp
		}
	}
}