常见的5种排序java实现

冒泡排序、选择排序、插入排序、快速排序和归并排序Java实现

import java.util.Scanner;

public class Sort {
	static Scanner sc = new Scanner(System.in);

	public static void main(String[] args) {
		
		while (true) {
			System.out.println("请输入需要排序的数字个数（-1作为结束）");
			int size = sc.nextInt();
			if (size <= 0) {
				System.out.println("end....");
				break;
			}
			int[] a = new int[size];
			System.out.println("请输入数字，以空格隔开");
			for (int i = 0; i < size; ++i) {
				a[i] = sc.nextInt();
			}
			System.out.println("请选择你要执行的排序算法（输入前面的数字）");
			System.out.println("1：冒泡排序（升序）");
			System.out.println("2：选择排序（降序）");
			System.out.println("3：插入排序（升序）");
			System.out.println("4：希尔排序（待写）");
			System.out.println("5：归并排序（升序）");
			System.out.println("6：快速排序（升序）");
			System.out.println("7：基数排序（待写）");
			System.out.println("8：桶排序（待写）");
			int x = sc.nextInt();
			Solve s = new Solve();
			// 调用相应的排序方法
			switch (x) {
			case 1: {
				s.bubble_Sort(a, size);
				break;
			}
			case 2: {
				s.select_Sort(a, size);
				break;
			}
			case 3: {
				s.insert_Sort(a, size);
				break;
			}
			case 5: {
				s.merge_Sort(a, 0, size - 1);
				break;
			}
			case 6: {
				s.quick_Sort(a, 0, size - 1);
				break;
			}
			}
			// for循环遍历排序后的数组
			for (int temp : a) {
				System.out.println(temp);
			}
		}
	}
}

class Solve {

	// 冒泡排序
	void bubble_Sort(int[] a, int size) {
		for (int i = 1; i < size; ++i) {// 代表第几轮冒泡
			for (int j = 0; j < size - i; ++j) {
				if (a[j] > a[j + 1]) {
					int temp = a[j + 1];
					a[j + 1] = a[j];
					a[j] = temp;
				}
			}
		}
	}

	// 选择排序
	void select_Sort(int[] a, int size) {
		for (int i = 0; i < size - 1; ++i) {
			int t = i;
			for (int j = i + 1; j < size; ++j) {
				if (a[t] >= a[j]) {
				} else {
					t = j;
				}
			}
			int temp = a[i];
			a[i] = a[t];
			a[t] = temp;
		}
	}

	// 插入排序
	void insert_Sort(int[] a, int size) {
		for (int i = 1; i < size; ++i) {
			int t = i;
			for (int j = i - 1; j >= 0; --j) {
				if (a[t] < a[j]) {
					int temp = a[t];
					a[t--] = a[j];
					a[j] = temp;
				} else {
					break;
				}
			}
		}
	}

	// 希尔排序
	void shell_Sort(int[] a, int size) {

	}

//	 快速排序
//	挖坑填数
//	 5   9   7   1   4   0  10
//	 i					     j  从j这个位置递减往左找第一个小于5的数,填到i这个位置,同时++i
//	 0   9   7   1   4   0   10 
//	     i               j
//	 0   9   7   1   4   9   10  从i这个位置递增往右找第一个大于5的数，填到j这个位置,同时--j
//	     i           j
//	重复以上步骤
//   0   4   7   1   4   9   10  <<--++i
//	         i       j
//	 0   4   7   1   7   9   10  -->>--j
//	         i   j
//	 0   4   1   1   7   9   10   <<--++i
//	           (i,j)
//	 0   4   1   6   7   9   10   将key值填入最后挖的坑
	void quick_Sort(int[] a, int l, int r) {
		if (l >= r)
			return;
		int i = l, j = r, key = a[l];
		while (i < j) {// 记住：是i和j比，不是l和r
			while (i < j && a[j] >= key) {
				j--;
			}
			if (i < j) {
				a[i] = a[j];
				i++;
			}
			while (i < j && a[i] < key) {
				++i;
			}
			if (i < j) {
				a[j] = a[i];
				--j;
			}
		}
		a[i] = key;
		quick_Sort(a, l, i - 1);
		quick_Sort(a, i + 1, r);

	}
	//归并排序
	void merge_Sort(int[] A, int start, int end) {
		if (start >= end) {
			return;
		}
		//划分成两个数组，先排好两个数组，再进行合并
		int middle = (start + end) / 2;
		merge_Sort(A, start, middle);
		merge_Sort(A, middle + 1, end);
		// 归并排序需要分配的临时数组
		// 这是归并排序的核心
		int[] temp = new int[end - start + 1];
		int i = start;
		int j = middle + 1;
		int index = 0;
		while (i <= middle && j <= end) {
			if (A[i] <= A[j]) {
				temp[index++] = A[i++];
			} else {
				temp[index++] = A[j++];
			}
		}
		while (i <= middle) {
			temp[index++] = A[i++];
		}
		while (j <= end) {
			temp[index++] = A[j++];
		}
		index = 0;
		for (i = start; i <= end; i++) {
			A[i] = temp[index++];
		}
	}
}