对数器的使用及三种常见排序算法示例（java）

最新推荐文章于 2024-01-10 00:04:27 发布
最新推荐文章于 2024-01-10 00:04:27 发布
阅读量724 收藏 1
点赞数
分类专栏： java 文章标签： 对数器 常见排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hnu_zzt/article/details/88221753
版权

什么是对数器？
当写好一段代码，如何验证是否正确呢？你可以自己去设计case，但是有些case你可能想不到。你也可以去找合适的oj系统测试自己的代码，但往往遇到一个问题的时候这些方法都不方便，而且别人找的测试用例也不一定对。使用对数器就能自己验证自己的代码。

对数器有一下三个好处：
1.我们在找不到合适的oj系统测试自己的代码时，可以自己写一个对数器对代码进行测试。
2.在面试的过程中，提供的小样本测试都对。但大样本测试报错，此时找到代码错误的地方比较困难。对数器就可以帮到你。
3.贪心策略。你可以用数学的方法证明你的贪心策略的准确性。但往往在笔试、考试时有限的时间内做到是不现实的。而对数器可以验证。

对数器的概念和使用：
1.有一个你要测的方法a；
2.实现一个绝对正确即使复杂度不好的方法b；
3.实现一个随机样本产生器；
4.实现比对的方法；
5.把方法a和方法b比对很多次来验证方法a是否正确
6.如果有一个样本使得比对出错，打印样本分析是哪个方法出错
7.当样本数量很多时比对测试依然正确，可以确定方法a已经正确

下面举三个例子（冒泡排序、选择排序和插入排序算法）来说明对数器的使用方法：
1.冒泡排序：冒泡排序啊的基本思想就是不断比较相邻的两个数，让较大的元素不断地往后移。经过一轮比较，就选出最大的数（升序），然后放在这次排列的最后一位；然后在进行下一次的重复动作，不过不动上次已经放好的数，减少一次比较，再找出这一轮最大的数，放在这一轮的最后面，然后依次循环，这就得到一个升序的排列了。

package basic_class_01;

import java.util.Arrays;

public class Code_00_BubbleSort {

	public static void bubbleSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		for (int e = arr.length - 1; e > 0; e--) {
			for (int i = 0; i < e; i++) {
				if (arr[i] > arr[i + 1]) {
					swap(arr, i, i + 1);
				}
			}
		}
	}

	public static void swap(int[] arr, int i, int j) {
		arr[i] = arr[i] ^ arr[j];
		arr[j] = arr[i] ^ arr[j];
		arr[i] = arr[i] ^ arr[j];
	}

	// for test
	public static void comparator(int[] arr) {
		Arrays.sort(arr);
	}

	// for test
	public static int[] generateRandomArray(int maxSize, int maxValue) {
		int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
		}
		return arr;
	}

	// for test
	public static int[] copyArray(int[] arr) {
		if (arr == null) {
			return null;
		}
		int[] res = new int[arr.length];
		for (int i = 0; i < arr.length; i++) {
			res[i] = arr[i];
		}
		return res;
	}

	// for test
	public static boolean isEqual(int[] arr1, int[] arr2) {
		if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
			return false;
		}
		if (arr1 == null && arr2 == null) {
			return true;
		}
		if (arr1.length != arr2.length) {
			return false;
		}
		for (int i = 0; i < arr1.length; i++) {
			if (arr1[i] != arr2[i]) {
				return false;
			}
		}
		return true;
	}

	// for test
	public static void printArray(int[] arr) {
		if (arr == null) {
			return;
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}

	// for test
	public static void main(String[] args) {
		int testTime = 500000;
		int maxSize = 100;
		int maxValue = 100;
		boolean succeed = true;
		for (int i = 0; i < testTime; i++) {
			int[] arr1 = generateRandomArray(maxSize, maxValue);
			int[] arr2 = copyArray(arr1);
			bubbleSort(arr1);
			comparator(arr2);
			if (!isEqual(arr1, arr2)) {
				succeed = false;
				break;
			}
		}
		System.out.println(succeed ? "Nice!" : "Fucking fucked!");

		int[] arr = generateRandomArray(maxSize, maxValue);
		printArray(arr);
		bubbleSort(arr);
		printArray(arr);
	}

}

2.选择排序：选择排序法也可以看做冒泡的一个改进，经过一轮的两两比较后，并不马上交换数的位置，而是找到本轮最小的数，记下该数的位置（即在数组中的下标），待本轮比较完毕后，通过一次交换即可将本轮最小的数交换到位。然后就找到把数字排好了。

package basic_class_01;

import java.util.Arrays;

public class Code_02_SelectionSort {

	public static void selectionSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		for (int i = 0; i < arr.length - 1; i++) {
			int minIndex = i;
			for (int j = i + 1; j < arr.length; j++) {
				minIndex = arr[j] < arr[minIndex] ? j : minIndex;
			}
			swap(arr, i, minIndex);
		}
	}

	public static void swap(int[] arr, int i, int j) {
		int tmp = arr[i];
		arr[i] = arr[j];
		arr[j] = tmp;
	}

	// for test
	public static void comparator(int[] arr) {
		Arrays.sort(arr);
	}

	// for test
	public static int[] generateRandomArray(int maxSize, int maxValue) {
		int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
		}
		return arr;
	}

	// for test
	public static int[] copyArray(int[] arr) {
		if (arr == null) {
			return null;
		}
		int[] res = new int[arr.length];
		for (int i = 0; i < arr.length; i++) {
			res[i] = arr[i];
		}
		return res;
	}

	// for test
	public static boolean isEqual(int[] arr1, int[] arr2) {
		if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
			return false;
		}
		if (arr1 == null && arr2 == null) {
			return true;
		}
		if (arr1.length != arr2.length) {
			return false;
		}
		for (int i = 0; i < arr1.length; i++) {
			if (arr1[i] != arr2[i]) {
				return false;
			}
		}
		return true;
	}

	// for test
	public static void printArray(int[] arr) {
		if (arr == null) {
			return;
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}

	// for test
	public static void main(String[] args) {
		int testTime = 500000;
		int maxSize = 100;
		int maxValue = 100;
		boolean succeed = true;
		for (int i = 0; i < testTime; i++) {
			int[] arr1 = generateRandomArray(maxSize, maxValue);
			int[] arr2 = copyArray(arr1);
			selectionSort(arr1);
			comparator(arr2);
			if (!isEqual(arr1, arr2)) {
				succeed = false;
				printArray(arr1);
				printArray(arr2);
				break;
			}
		}
		System.out.println(succeed ? "Nice!" : "Fucking fucked!");

		int[] arr = generateRandomArray(maxSize, maxValue);
		printArray(arr);
		selectionSort(arr);
		printArray(arr);
	}

}

3.插入排序：插入排序法是一种非常快速的排序算法，且原理简单，结构紧凑。它的是原理：从序列中第二个数A开始，将A，插入前面已经排好的序列中，形成一个新的排序好的序列，以此类推到最后一个元素。

package basic_class_01;

import java.util.Arrays;

public class Code_01_InsertionSort {

	public static void insertionSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		for (int i = 1; i < arr.length; i++) {
			for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
				swap(arr, j, j + 1);
			}
		}
	}

	public static void swap(int[] arr, int i, int j) {
		arr[i] = arr[i] ^ arr[j];
		arr[j] = arr[i] ^ arr[j];
		arr[i] = arr[i] ^ arr[j];
	}

	// for test
	public static void comparator(int[] arr) {
		Arrays.sort(arr);
	}

	// for test
	public static int[] generateRandomArray(int maxSize, int maxValue) {
		int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
		}
		return arr;
	}

	// for test
	public static int[] copyArray(int[] arr) {
		if (arr == null) {
			return null;
		}
		int[] res = new int[arr.length];
		for (int i = 0; i < arr.length; i++) {
			res[i] = arr[i];
		}
		return res;
	}

	// for test
	public static boolean isEqual(int[] arr1, int[] arr2) {
		if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
			return false;
		}
		if (arr1 == null && arr2 == null) {
			return true;
		}
		if (arr1.length != arr2.length) {
			return false;
		}
		for (int i = 0; i < arr1.length; i++) {
			if (arr1[i] != arr2[i]) {
				return false;
			}
		}
		return true;
	}

	// for test
	public static void printArray(int[] arr) {
		if (arr == null) {
			return;
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}

	// for test
	public static void main(String[] args) {
		int testTime = 500000;
		int maxSize = 100;
		int maxValue = 100;
		boolean succeed = true;
		for (int i = 0; i < testTime; i++) {
			int[] arr1 = generateRandomArray(maxSize, maxValue);
			int[] arr2 = copyArray(arr1);
			insertionSort(arr1);
			comparator(arr2);
			if (!isEqual(arr1, arr2)) {
				succeed = false;
				break;
			}
		}
		System.out.println(succeed ? "Nice!" : "Fucking fucked!");

		int[] arr = generateRandomArray(maxSize, maxValue);
		printArray(arr);
		insertionSort(arr);
		printArray(arr);
	}

}
hnu_zzt
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java实现基数排序算法
06-14
在每个位上，使用计数排序来稳定地排序数组。通过多次迭代，对所有位进行排序后，最终得到有序的数组。 在示例代码中，我们首先找到数组中的最大值，以确定数字的位数。然后，通过循环迭代从最低位到最高位，依次...
[Java算法-排序练习]三色排序判断.java
09-07
文档中涵盖了三色排序判断的基本概念，包括如何对数组进行排序以及如何在Java中实现三色排序判断。此外，文档还包括一个逐步指南，介绍了如何在Java中实现三色排序判断，包括详细的代码示例和实现细节。 文档还涵盖...
数据结构与算法 ---- 冒泡排序算法
qq_41877840的博客
09-04 1288
冒泡排序是一种简单的排序算法，它也是一种稳定排序算法。其实现原理是重复扫描待排序序列，并比较每一对相邻的元素，当该对元素顺序不正确时进行交换。一直重复这个过程，直到没有任何两个相邻元素可以交换，就表明完成了排序。 假设待排序序列为 (5,1,4,2,8)，如果采用冒泡排序对其进行升序（由小到大）排序，则整个排序过程如下所示： 第一轮排序，此时整个序列中的元素都位于待排序序列，依次扫描每对相邻的元素，并对顺序不正确的元素对交换位置，整个过程如图 1 所示。 从图 1 可以看到，经过第一轮冒泡排序，从.
Python常见排序之冒泡排序（详解）
qq_54934861的博客
11-02 9969
一、为啥叫冒泡排序呢？因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中co2的气泡最终会上浮到顶端一样，故名“冒泡排序”。 二、排序思路： 1.相邻元素之间的比较，如果第一个元素比第二个元素大，则他们两个进行交换。（若第一个元素小于第二个元素，则不交换位置，第二个和第三个进行比较） 2.对每一对的元素进行同样的工作，直到最后一对元素。则最后一个元素是最大的元素。（所以在下一轮比较时，除了最后一个元素重复以上的步骤） 3.重复以上的步骤直到没有任何一对数字需要比较则结
python算法：冒泡排序
有学习问题可以加我qq群：785318982，群内有大佬免费答疑
08-22 6775
def Bubbl(r): for i in range(len(r)): '''保证每一个数字都要找到对应位置，遍历列表的长度 从0开始找到最小值放在第一位''' exchange=False for j in range(i,len(r)-1): '''从i开始的位置遍历，遍历到最后一位减去一，否则会导致报错（超出范围）''' if r[j]>r[j+1]:
Python实现冒泡排序
nuoyanli的博客
07-10 4054
最简单冒泡排序： arr = [7, 4, 3, 67, 34, 1, 8] def bubble_sort(arr): n = len(arr) for j in range(0, n - 1): for i in range(0, n - 1 - j): if arr[i] > arr[i + 1]: ...
Python排序算法之冒泡排序
程序员小芽的博客
06-25 7677
冒泡排序是一种简单直观的排序算法；它重复的遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复的进行直到不再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经过交换慢慢“浮”到数列的顶端。比较相邻的元素。如果第一个比第二个大，就交换他们两个。对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。针对所有的元素重复以上的步骤，除了最后一个。
[Java算法-排序]希尔排序.java
09-07
文档中涵盖了希尔排序的基本概念，包括如何对数组进行排序以及如何在Java中实现希尔排序。此外，文档还包括一个逐步指南，介绍如何在Java中实现希尔排序代码，包括详细的代码示例和实现细节。 文档还涵盖了高级主题...
[Java算法-排序]归并排序.java
09-07
文档中涵盖了归并排序的基本概念，包括如何对数组进行排序以及如何在Java中实现归并排序。此外，文档还包括一个逐步指南，介绍如何在Java中实现归并排序，包括详细的代码示例和实现细节。 文档还涵盖了高级主题，如...
[Java算法-排序]快速排序.java
09-07
文档中涵盖了快速排序的基本概念，包括如何对数组进行排序以及如何在Java中实现快速排序。此外，文档还包括一个逐步指南，介绍了如何在Java中实现快速排序，包括详细的代码示例和实现细节。 文档还涵盖了高级主题，...
Python实现冒泡排序法的三种方式
最新发布
长孤秋落的札记
01-10 1367
Python中实现冒泡排序法有很多方式，和其他强类型语言实现起来有点不一样以下为三种冒泡排序的代码例子，给大家参考。
基本算法——冒泡排序（Python版）
Limerence的博客
08-11 9422
基本算法——冒泡排序（Python版）
冒泡排序（Python实现）
不错就是对的博客
04-06 2112
该算法的最差时间复杂度为O(n2)，最优时间复杂度为O(n)，平均时间复杂度为 O(n2)。 原理（以从小到大排列为例）： 1、从列表中第一个和第二个元素开始，比较相邻元素，如果左比右大，则左右交换位置； 2、从列表的开头到结尾，依次比较每对元素，直至不能再比较为止； 举例：list = [1, 3, 4, 2] （1）[1, 3, 2, 4] --- list[2]和list[3]交换位置后的结果； （2）[1, 2, 3, 4] --- list'[1]和list'[2交换位置后的结
Python数据结构与算法篇（十四）-- 冒泡排序算法
CarpeDiem
04-13 2844
冒泡排序（Bubble Sort）是一种简单的排序算法，它也是一种稳定排序算法。其实现原理是重复扫描待排序序列，并比较每一对相邻的元素，当该对元素顺序不正确时进行交换。一直重复这个过程，直到没有任何两个相邻元素可以交换，就表明完成了排序。
2. python 冒泡排序-全网最详细
2301_79002886的博客
10-24 305
冒泡排序(Bubble Sort)法可以理解成升序排序，即排列顺序是由小到大。Bubble [ˈbʌbl]：冒泡。Sort [sɔːt]：分类。【实现原理】从头开始比较每一对相邻的元素，每一轮选出一个最大的数放到序列最后，重复遍历序列，直到完成升序排列。从头开始比较的是相邻的数最大的数放到最后之所以叫做冒泡排序，是因为每一个元素都可以像小气泡一样，根据自身大小一点一点向数组的一侧移动。大的数向后移，小的数向前移。冒泡排序的核心就是2个数相比较，大的数往后移。
python：冒泡排序（Bubble Sort）超详细教程！
KevenDuan的博客
12-10 4042
冒泡排序是一种重要的排序方法，也是算法的基础。读完本教程，你一定会对冒泡排序有一定的想法和收获！
java对数器
m0_51787573的博客
08-01 289
代码】java对数器。
python排序算法 ——冒泡排序（附代码）
阿极的博客
01-11 8086
（附详细代码）冒泡排序的平均时间复杂度是O(n2)，最好情况下的时间复杂度是O(n)，最坏情况下的时间复杂度是O( n2 )。空间复杂度是O(1)。冒泡排序算法是一个稳定的排序算法。
使用比较排序法对数组进行排序，java
06-12
好的，以下是使用Java语言实现三种比较排序算法的示例代码： 1. 冒泡排序 ```java public static void bubbleSort(int[] arr) { int n = arr.length; for (int i = 0; i ; i++) { for (int j = 0; j ; j++) { ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值