关于JAVA中常见的几种基础排序算法

冒泡排序

public static int[] maopaoSort(int[] arr) {
	//需进行length-1次冒泡
	for (int i = 0; i < arr.length - 1; i++) {
		for (int j = 0; j < arr.length - 1 - i; j++) {
			if (arr[j] > arr[j + 1]) {
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
	return arr;
}

选择排序

/**
 * 选择排序
 *
 * @param arr
 */
public static int[] xuanzeSort(int[] arr) {
	int minIndex = 0;
	//只需要比较n-1次
	for (int i = 0; i < arr.length - 1; i++) {
		minIndex = i;
		//从i+1开始比较，因为minIndex默认为i了，i就没必要比了
		for (int j = i + 1; j < arr.length; j++) {
			if (arr[j] < arr[minIndex]) {
				minIndex = j;
			}
		}
		//如果minIndex不为i，说明找到了更小的值，交换之
		if (minIndex != i) {
			int temp = arr[i];
			arr[i] = arr[minIndex];
			arr[minIndex] = temp;
		}
	}
	return arr;
}

插入排序

/**
 * 插入排序
 *
 * @param arr
 * @return
 */
public static int[] charuSort(int[] arr) {
	//假设第一个数位置时正确的；要往后移，必须要假设第一个
	for (int i = 1; i < arr.length; i++) {
		int j = i;
		int target = arr[i]; //待插入的
		//后移
		while (j > 0 && target < arr[j - 1]) {
			arr[j] = arr[j - 1];
			j--;
		}
		//插入
		arr[j] = target;
	}
	return arr;
}

快速排序

/**
 * 快速排序
 *
 * @param arr
 * @return
 */
public static int[] kuaisuSort(int[] arr) {
	int len = arr.length;
	int left = 0;
	int right = len - 1;
	kuaisuSortCore(arr, left, right);
	return arr;
}
 
/**
 * 快排核心算法，递归实现
 *
 * @param arr
 * @param left
 * @param right
 */
public static void kuaisuSortCore(int[] arr, int left, int right) {
	if (left > right) {
		return;
	}
	// base中存放基准数
	int base = arr[left];
	int i = left, j = right;
	while (i != j) {
		// 顺序很重要，先从右边开始往左找，直到找到比base值小的数
		while (arr[j] >= base && i < j) {
			j--;
		}
		// 再从左往右边找，直到找到比base值大的数
		while (arr[i] <= base && i < j) {
			i++;
		}
		// 上面的循环结束表示找到了位置或者(i>=j)了，交换两个数在数组中的位置
		if (i < j) {
			int tmp = arr[i];
			arr[i] = arr[j];
			arr[j] = tmp;
		}
	}
	// 将基准数放到中间的位置（基准数归位）
	arr[left] = arr[i];
	arr[i] = base;
	// 递归，继续向基准的左右两边执行和上面同样的操作
	// i的索引处为上面已确定好的基准值的位置，无需再处理
	sort(arr, left, i - 1);
	sort(arr, i + 1, right);
}

堆排序

/**
 * 堆排序
 * (创建堆)
 * @param arr
 * @return
 */
private static int[] duiSort(int[] arr) {
	//创建堆
	for (int i = (arr.length - 1) / 2; i >= 0; i--) {
		//从第一个非叶子结点从下至上，从右至左调整结构
		duiSortCore(arr, i, arr.length);
	}
	//调整堆结构+交换堆顶元素与末尾元素
	for (int i = arr.length - 1; i > 0; i--) {
		//将堆顶元素与末尾元素进行交换
		int temp = arr[i];
		arr[i] = arr[0];
		arr[0] = temp;
		//重新对堆进行调整
		duiSortCore(arr, 0, i);
	}
	return arr;
}
/**
 * 调整堆
 *
 * @param arr    待排序列
 * @param parent 父节点
 * @param length 待排序列尾元素索引
 */
private static void duiSortCore(int[] arr, int parent, int length) {
	//将temp作为父节点
	int temp = arr[parent];
	//左子
	int left = 2 * parent + 1;
	while (left < length) {
		//右子
		int right = left + 1;
		// 如果有右子结点，并且右子结点的值大于左子结点，则选取右子结点
		if (right < length && arr[left] < arr[right]) {
			left++;
		}
		// 如果父结点的值已经大于子结点的值，则直接结束
		if (temp >= arr[left]) {
			break;
		}
		// 把子结点的值赋给父结点
		arr[parent] = arr[left];
		//选取孩子结点的左子结点,继续向下筛选
		parent = left;
		left = 2 * left + 1;
	}
	arr[parent] = temp;
}

希尔排序

/**
 * 希尔排序
 * @param arr
 * @return
 */
public static int[] xierSort(int[] arr) {
	int d = arr.length / 2;
	while (d >= 1) {
		xierSortCore(arr, d);
		d /= 2;
	}
	return arr;
}
/**
 * 希尔排序核心
 *
 * @param arr 待排数组
 * @param d   增量
 */
public static void xierSortCore(int[] arr, int d) {
	for (int i = d; i < arr.length; i++) {
		int j = i - d;
		//记录要插入的数据
		int temp = arr[i];
		//从后向前，找到比其小的数的位置
		while (j >= 0 && arr[j] > temp) {
			//向后挪动
			arr[j + d] = arr[j];
			j -= d;
		}
		//存在比其小的数
		if (j != i - d) {
			arr[j + d] = temp;
		}
	}
}

并归排序

/**
 * 并归排序
 *
 * @param arr
 * @return
 */
public static int[] bingguiSort(int[] arr) {
	bingguiSortCore(arr, 0, arr.length - 1);
	return arr;
}
/**
 * 递归分治
 *
 * @param arr   待排数组
 * @param left  左指针
 * @param right 右指针
 */
public static void bingguiSortCore(int[] arr, int left, int right) {
	if (left >= right){
		return;
	}
	int mid = (left + right) / 2;
	//递归排序左边
	bingguiSortCore(arr, left, mid);
	//递归排序右边
	bingguiSortCore(arr, mid + 1, right);
	//最终合并
	int[] temp = new int[right - left + 1];
	int i = left;
	int j = mid + 1;
	int k = 0;
	while (i <= mid && j <= right) {
		if (arr[i] <= arr[j]) {
			temp[k++] = arr[i++];
		} else {
			temp[k++] = arr[j++];
		}
	}
	while (i <= mid) {
		temp[k++] = arr[i++];
	}
	while (j <= right) {
		temp[k++] = arr[j++];
	}
	for (int p = 0; p < temp.length; p++) {
		arr[left + p] = temp[p];
	}
}
# 计数排序
```Java
/**
 * 计数排序
 *
 * @param arr
 * @return
 */
public static int[] jishuSort(int[] arr) {
	int max = Integer.MIN_VALUE;
	for (int i : arr) {
		if (i > max){
			max = i;
		}
	}
	int[] count = new int[max + 1];
	Arrays.fill(count, 0);
	for (int i = 0; i < arr.length; i++) {
		count[arr[i]]++;
	}
	int k = 0;
	for (int i = 0; i <= max; i++) {
		for (int j = 0; j < count[i]; j++) {
			arr[k++] = i;
		}
	}
	return arr;
}

桶排序

/**
 * 桶排序
 *
 * @param arr
 * @return
 */
public static int[] tongSort(int[] arr) {
	//这里默认为10，规定待排数[0,100)
	int bucketNums = 10;
	//桶的索引
	List<List<Integer>> buckets = new ArrayList<List<Integer>>();
	for (int i = 0; i < 10; i++) {
		//用链表比较合适
		buckets.add(new LinkedList<Integer>());
	}
	//划分桶
	for (int i = 0; i < arr.length; i++) {
		buckets.get(arr[i] / 10).add(arr[i]);
	}
	//对每个桶进行排序
	for (int i = 0; i < buckets.size(); i++) {
		if (!buckets.get(i).isEmpty()) {
			//对每个桶进行快排
			Collections.sort(buckets.get(i));
		}
	}
	//还原排好序的数组
	int k = 0;
	for (List<Integer> bucket : buckets) {
		for (int ele : bucket) {
			arr[k++] = ele;
		}
	}
	return arr;
}

基数排序

/**
 * 基数排序
 *
 * @param arr
 * @return
 */
public static int[] baseSort(int[] arr) {
	// 获取最大位数
	int maxBit = Integer.MIN_VALUE;
	for (int ele : arr) {
		int len = (ele + "").length();
		if (len > maxBit){
			maxBit = len;
		}
	}
	for (int i = 1; i <= maxBit; i++) {
		//分配
		List<List<Integer>> buf = new ArrayList<List<Integer>>();
		for (int n = 0; n < 10; n++) {
			buf.add(new LinkedList<Integer>());
		}
		for (int m = 0; m < arr.length; m++) {
			//获取x的第n位，如果没有则为0
			int result = 0;
			String sx = arr[m] + "";
			if (sx.length() < i){
				result = 0;
			} else{
				result = sx.charAt(sx.length() - i) - '0';
			}
			buf.get(result).add(arr[m]);
		}
		//收集
		int k = 0;
		for (List<Integer> bucket : buf) {
			for (int ele : bucket) {
				arr[k++] = ele;
			}
		}
	}
	return arr;
}

所有排序测试

public static void main(String[] args) {

int[] arr1 = new int[]{1, 5, 6, 2, 3, 7, 4};
int[] result1 = maopaoSort(arr1);
System.out.println("冒泡排序:" + Arrays.toString(result1));

int[] arr2 = new int[]{1, 5, 6, 2, 3, 7, 4};
int[] result2 = xuanzeSort(arr2);
System.out.println("选择排序:" + Arrays.toString(result2));

int[] arr3 = new int[]{1, 5, 6, 2, 3, 7, 4};
int[] result3 = charuSort(arr3);
System.out.println("插入排序:" + Arrays.toString(result3));

int[] arr4 = new int[]{1, 5, 6, 2, 3, 7, 4};
int[] result4 = kuaisuSort(arr4);
System.out.println("快速排序:" + Arrays.toString(result4));

int[] arr5 = new int[]{1, 5, 6, 2, 3, 7, 4};
int[] result5 = xierSort(arr5);
System.out.println("希尔排序:" + Arrays.toString(result5));

int[] arr6 = new int[]{1, 5, 6, 2, 3, 7, 4};
int[] result6 = bingguiSort(arr6);
System.out.println("并归排序:" + Arrays.toString(result6));

int[] arr7 = new int[]{1, 5, 6, 2, 3, 7, 4};
int[] result7 = jishuSort(arr7);
System.out.println("计数排序:" + Arrays.toString(result7));

int[] arr8 = new int[]{1, 5, 6, 2, 3, 7, 4};
int[] result8 = baseSort(arr8);
System.out.println("基数排序:" + Arrays.toString(result8));

int[] arr9 = new int[]{1, 5, 6, 2, 3, 7, 4};
int[] result9 = duiSort(arr9);
System.out.println("堆排序:" + Arrays.toString(result9));

int[] arr10 = new int[]{1, 5, 6, 2, 3, 7, 4};
int[] result10 = tongSort(arr10);
System.out.println("桶排序:" + Arrays.toString(result10));

}
```