数据结构 (3) ——排序 <IT小鸟每日一遍>

最新推荐文章于 2022-04-29 15:06:07 发布

wanqkami

最新推荐文章于 2022-04-29 15:06:07 发布

阅读量583

点赞数

CC 4.0 BY-SA版权

分类专栏：数据结构 java

本文链接：https://blog.youkuaiyun.com/wanqkami/article/details/8707048

java 同时被 2 个专栏收录

9 篇文章

订阅专栏

数据结构

3 篇文章

订阅专栏

本文深入讲解了多种排序算法的实现，包括二分法排序、冒泡排序、桶式排序、堆积排序、插入排序、归并排序、基数排序、快速排序、选择排序和希尔排序等。每种算法都配有详细的代码实现及说明。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

排序，一直是频繁出现的话题，所以排序包含的内容页非常多！

分享不同排序算法的实现，思想可以另行查看

二分法排序

public class BinaryInsertSort {

	public static void binaryInsertSort(int[] data) {
		for (int i = 1; i < data.length; i++) {
			if (data[i] < data[i - 1]) {
				// 缓存i处的元素值
				int tmp = data[i];
				// 记录搜索范围的左边界
				int low = 0;
				// 记录搜索范围的右边界
				int high = i - 1;
				while (low <= high) {
					// 记录中间位置
					int mid = (low + high) / 2;
					// 比较中间位置数据和i处数据大小，以缩小搜索范围
					if (data[mid] < tmp) {
						low = mid + 1;
					} else {
						high = mid - 1;
					}
				}
				// 将low~i处数据整体向后移动1位
				for (int j = i; j > low; j--) {
					data[j] = data[j - 1];
				}
				data[low] = tmp;
				print(data);
			}
		}
	}

	public static void print(int[] data) {
		for (int i = 0; i < data.length; i++) {
			System.out.print(data[i] + "\t");
		}
		System.out.println();
	}
}

冒泡排序

public class BubbleSort {
	public static void swap(int[] data, int i, int j) {
		if (i == j) {
			return;
		}
		data[i] = data[i] + data[j];
		data[j] = data[i] - data[j];
		data[i] = data[i] - data[j];
	}

	public static void bubbleSort(int[] data) {
		for (int i = 0; i < data.length - 1; i++) {
			// 记录某趟是否发生交换，若为false表示数组已处于有序状态
			boolean isSorted = false;
			for (int j = 0; j < data.length - i - 1; j++) {
				if (data[j] > data[j + 1]) {
					swap(data, j, j + 1);
					isSorted = true;
					print(data);
				}
			}
			if (!isSorted) {
				// 若数组已处于有序状态，结束循环
				break;
			}
		}
	}

	public static void print(int[] data) {
		for (int i = 0; i < data.length; i++) {
			System.out.print(data[i] + "\t");
		}
		System.out.println();
	}
}

桶式排序

public class BucketSort {

	public static void bucketSort(int[] data, int min, int max) {
		// 缓存数组
		int[] tmp = new int[data.length];
		// buckets用于记录待排序元素的信息
		// buckets数组定义了max-min个桶
		int[] buckets = new int[max - min];
		// 计算每个元素在序列出现的次数
		for (int i = 0; i < data.length; i++) {
			buckets[data[i] - min]++;
		}
		// 计算“落入”各桶内的元素在有序序列中的位置
		for (int i = 1; i < max - min; i++) {
			buckets[i] = buckets[i] + buckets[i - 1];
		}
		// 将data中的元素完全复制到tmp数组中
		System.arraycopy(data, 0, tmp, 0, data.length);
		// 根据buckets数组中的信息将待排序列的各元素放入相应位置
		for (int k = data.length - 1; k >= 0; k--) {
			data[--buckets[tmp[k] - min]] = tmp[k];
		}
	}

	public static void print(int[] data) {
		for (int i = 0; i < data.length; i++) {
			System.out.print(data[i] + "\t");
		}
		System.out.println();
	}
}

堆积排序

public class HeapSort {

	public static void swap(int[] data, int i, int j) {
		if (i == j) {
			return;
		}
		data[i] = data[i] + data[j];
		data[j] = data[i] - data[j];
		data[j] = data[i] - data[j];
	}

	public static void heapSort(int[] data) {
		for (int i = 0; i < data.length; i++) {
			createMaxdHeap(data, data.length - 1 - i);
			swap(data, 0, data.length - 1 - i);
			print(data);
		}
	}

	public static void createMaxdHeap(int[] data, int lastIndex) {
		for (int i = (lastIndex - 1) / 2; i >= 0; i--) {
			// 保存当前正在判断的节点
			int k = i;
			// 若当前节点的子节点存在
			while (2 * k + 1 <= lastIndex) {
				// biggerIndex总是记录较大节点的值,先赋值为当前判断节点的左子节点
				int biggerIndex = 2 * k + 1;
				if (biggerIndex < lastIndex) {
					// 若右子节点存在，否则此时biggerIndex应该等于 lastIndex
					if (data[biggerIndex] < data[biggerIndex + 1]) {
						// 若右子节点值比左子节点值大，则biggerIndex记录的是右子节点的值
						biggerIndex++;
					}
				}
				if (data[k] < data[biggerIndex]) {
					// 若当前节点值比子节点最大值小，则交换2者得值，交换后将biggerIndex值赋值给k
					swap(data, k, biggerIndex);
					k = biggerIndex;
				} else {
					break;
				}
			}
		}
	}

	public static void print(int[] data) {
		for (int i = 0; i < data.length; i++) {
			System.out.print(data[i] + "\t");
		}
		System.out.println();
	}
}

插入排序

public class InsertSort {
	
	public static void insertSort(int[] data) {
		for (int i = 1; i < data.length; i++) {
			// 缓存i处的元素值
			int tmp = data[i];
			if (data[i] < data[i - 1]) {
				int j = i - 1;
				// 整体后移一格
				while (j >= 0 && data[j] > tmp) {
					data[j + 1] = data[j];
					j--;
				}
				// 最后将tmp插入合适的位置
				data[j + 1] = tmp;
				print(data);
			}
		}
	}

	public static void print(int[] data) {
		for (int i = 0; i < data.length; i++) {
			System.out.print(data[i] + "\t");
		}
		System.out.println();
	}
}

归并排序

public class MergeSort {
	
	public static void mergeSort(int[] data) {
		sort(data, 0, data.length - 1);
	}

	public static void sort(int[] data, int left, int right) {
		if (left >= right)
			return;
		// 找出中间索引
		int center = (left + right) / 2;
		// 对左边数组进行递归
		sort(data, left, center);
		// 对右边数组进行递归
		sort(data, center + 1, right);
		// 合并
		merge(data, left, center, right);
		print(data);
	}

	/**
	 * 将两个数组进行归并，归并前面2个数组已有序，归并后依然有序
	 * 
	 * @param data
	 *            数组对象
	 * @param left
	 *            左数组的第一个元素的索引
	 * @param center
	 *            左数组的最后一个元素的索引，center+1是右数组第一个元素的索引
	 * @param right
	 *            右数组最后一个元素的索引
	 */
	public static void merge(int[] data, int left, int center, int right) {
		// 临时数组
		int[] tmpArr = new int[data.length];
		// 右数组第一个元素索引
		int mid = center + 1;
		// third 记录临时数组的索引
		int third = left;
		// 缓存左数组第一个元素的索引
		int tmp = left;
		while (left <= center && mid <= right) {
			// 从两个数组中取出最小的放入临时数组
			if (data[left] <= data[mid]) {
				tmpArr[third++] = data[left++];
			} else {
				tmpArr[third++] = data[mid++];
			}
		}
		// 剩余部分依次放入临时数组（实际上两个while只会执行其中一个）
		while (mid <= right) {
			tmpArr[third++] = data[mid++];
		}
		while (left <= center) {
			tmpArr[third++] = data[left++];
		}
		// 将临时数组中的内容拷贝回原数组中
		// （原left-right范围的内容被复制回原数组）
		while (tmp <= right) {
			data[tmp] = tmpArr[tmp++];
		}
	}

	public static void print(int[] data) {
		for (int i = 0; i < data.length; i++) {
			System.out.print(data[i] + "\t");
		}
		System.out.println();
	}
}

基数排序

public class MultiKeyRadixSort {

	public static void radixSort(int[] data, int radix, int d) {
		// 缓存数组
		int[] tmp = new int[data.length];
		// buckets用于记录待排序元素的信息
		// buckets数组定义了max-min个桶
		int[] buckets = new int[radix];

		for (int i = 0, rate = 1; i < d; i++) {

			// 重置count数组，开始统计下一个关键字
			Arrays.fill(buckets, 0);
			// 将data中的元素完全复制到tmp数组中
			System.arraycopy(data, 0, tmp, 0, data.length);

			// 计算每个待排序数据的子关键字
			for (int j = 0; j < data.length; j++) {
				int subKey = (tmp[j] / rate) % radix;
				buckets[subKey]++;
			}

			for (int j = 1; j < radix; j++) {
				buckets[j] = buckets[j] + buckets[j - 1];
			}

			// 按子关键字对指定的数据进行排序
			for (int m = data.length - 1; m >= 0; m--) {
				int subKey = (tmp[m] / rate) % radix;
				data[--buckets[subKey]] = tmp[m];
			}
			rate *= radix;
		}

	}

	public static void print(int[] data) {
		for (int i = 0; i < data.length; i++) {
			System.out.print(data[i] + "\t");
		}
		System.out.println();
	}
}

快速排序

public class QuickSort {
	public static void swap(int[] data, int i, int j) {
		if (i == j) {
			return;
		}
		data[i] = data[i] + data[j];
		data[j] = data[i] - data[j];
		data[i] = data[i] - data[j];
	}

	public static void quickSort(int[] data, int start, int end) {
		if (start >= end)
			return;
		// 以起始索引为分界点
		int pivot = data[start];
		int i = start + 1;
		int j = end;
		while (true) {
			while (i <= end && data[i] < pivot) {
				i++;
			}
			while (j > start && data[j] > pivot) {
				j--;
			}
			if (i < j) {
				swap(data, i, j);
			} else {
				break;
			}
		}
		// 交换 j和分界点的值
		swap(data, start, j);
		print(data);
		// 递归左子序列
		quickSort(data, start, j - 1);
		// 递归右子序列
		quickSort(data, j + 1, end);
	}

	public static void print(int[] data) {
		for (int i = 0; i < data.length; i++) {
			System.out.print(data[i] + "\t");
		}
		System.out.println();
	}
}

选择排序

public class SelectSort {

	public static void swap(int[] data, int i, int j) {
		if (i == j) {
			return;
		}
		data[i] = data[i] + data[j];
		data[j] = data[i] - data[j];
		data[i] = data[i] - data[j];
	}

	public static void selectSort(int[] data) {
		for (int i = 0; i < data.length - 1; i++) {
			int minIndex = i;// 记录最小数的索引
			for (int j = i + 1; j < data.length; j++) {
				if (data[j] < data[minIndex]) {
					minIndex = j;// 若后面的元素值小于最小值,将j赋值给minIndex
				}
			}
			if (minIndex != i) {
				swap(data, i, minIndex);
				print(data);
			}
		}
	}

	public static void print(int[] data) {
		for (int i = 0; i < data.length; i++) {
			System.out.print(data[i] + "\t");
		}
		System.out.println();
	}
}

希尔排序

public class ShellSort {

	public static void shellSort(int[] data) {
		// 计算出最大的h值
		int h = 1;
		while (h <= data.length / 3) {
			h = h * 3 + 1;
		}
		while (h > 0) {
			for (int i = h; i < data.length; i += h) {
				if (data[i] < data[i - h]) {
					int tmp = data[i];
					int j = i - h;
					while (j >= 0 && data[j] > tmp) {
						data[j + h] = data[j];
						j -= h;
					}
					data[j + h] = tmp;
					print(data);
				}
			}
			// 计算出下一个h值
			h = (h - 1) / 3;
		}
	}

	public static void print(int[] data) {
		for (int i = 0; i < data.length; i++) {
			System.out.print(data[i] + "\t");
		}
		System.out.println();
	}
}