【Java基础】数组的排序算法调用

本文介绍了Java中数组的排序方法,强调了sort函数在Array类中的使用。博主指出,通过实现Comparable接口或Comparator接口,可以对数组进行升序或降序排序。对于对象数组,可以通过两种方式排序:一是使用比较器对象,二是让对象类实现Comparable接口。

排序语句的使用

博主初学java,之前使用的更多是C++来写竞赛类代码。初来乍到,很多操作都要重新学习java的版本。比如今天的主角:排序语句。

在程序设计过程中,排序算法是最常用到的算法之一,正是因为其经常用到,所以掌握利用已经设计好的算法语句,会大大提升程序设计过程中的效率。主要优点如下:

  1. 进行排序仅需要一句话,方便书写
  2. 设计好的算法,确保正确率
  3. 算法出自高手,保证运行效率

那么与C语言qsort和sort不同的是,Java语言中并不存在孤立的方法,所有的方法都在类中。所以,今天的主角sort函数,就出现在数组类Array中。

它的调用方式为:

Arrays.sort(Object[] o,int );

括号中,传递需要排序的数组,默认为升序排序。

那么这里就会产生几个问题

  1. 默认顺序为升序,想要降序该怎么办?
  2. 对象数组可以进行排序吗?

回答

在回答问题之前,我有必要引入两个十分相似的接口,comparable,comparator接口。
对象实现这两个接口,分别成为可比较对和比较器对象。

可比较对象

当一个类继承了Comparable接口并实现了CompareTo方法,那么该类实例化出的对象即为可比较对象。这个对象可与其它对象进行大小的比较。

比较器对象

当一个类继承了Comparator接口并实现了Compare方法,那么该类实例化出的对象即为比较器对象。这个对象可比较两个对象的大小。

贴一段代码举例:

class Person implements Comparable<Person>
{
	int age;
	Person(int age)
	{
		this.age = age;
	}
	public int compareTo(Person o) {
		return this.age - o.age;
	}
}

class Judge implements Comparator<Person>
{
	String name;
	Judge(String name)
	{
		this.name = name;
	}
	public int compare(Person o1, Person o2) {
		return o2.age - o1.age;
	}
	
}

在这一段代码中,Person类是可比较类,Judge类是比较器类

有了这样的铺垫,我就可以开始回答问题了。

问:默认顺序为升序,想要降序该怎么办?

答:想要获得降序排列,就必须为方法提供比较器,在比较器中重新定义比较规则。

默认排序算法中比较大小的方式是前者与后者运算使两者相减

为负则小
为零则等
为正则大

故可以重写比较器方法,让结果值取相反数,即可使数组降序。

相对应的,调用方法需改为:

Arrays.sort(数组,比较器对象);

比较方法写成:

public int compare(int a,int b)
{
	return b - a;
}
问:对象数组可以进行排序吗?

答:当然可以,有两种方法

  • 方法1:上一个问题中,我们提到了比较器对象在排序方法中的使用。对于对象数组,比较器的调用方式依旧适用。此时,我们的比较器的便需要可以比较对象大小。
    利用上文的两个类举例。比较器类Judge实现了比较方法,可以用来比较两个Person类对象。
    这时,我们实例化一个Person类对象数组person,再实例化一个Judge类对象judge便可使用语句进行排序了。写法:
Array.sort(person,judge);
  • 方法2:对象数组也可以像一般数组一样不通过比较器进行排序。不过这要求对象之间可进行大小比较。所以只需要我们让类实现Comparable接口,这样我们的对象就成了可比较对象,就可以参与排序了。

笔者水平有限,如有错误之处,欢迎指出

<think>我们要求对Javaint数组进行排序Java中可以使用多种排序算法,这里我将演示几种常见的排序算法:1.冒泡排序(BubbleSort)2.选择排序(SelectionSort)3.插入排序(InsertionSort)4.快速排序(QuickSort)5.归并排序(MergeSort)6.使用Java内置的Arrays.sort()方法(这是最常用且高效的,底层使用了双轴快速排序和归并排序)考虑到题目要求是“排序算法案例”,我将展示这些算法的实现,并解释它们的工作原理。由于数组是基本类型int,所以这些排序算法会直接对数组进行修改(原地排序,除了归并排序可能需要额外空间)。注意:在实际开发中,我们通常直接使用Arrays.sort(),因为它已经高度优化。但为了学习目的,我们手动实现其他算法。我们将按照以下步骤:1.分别实现各个排序算法。2.为每个算法写一个示例,对同一个数组进行排序,并输出排序前后的数组。由于代码较长,我将分部分展示。首先,我们定义一组测试数据,然后分别调用各个排序方法。然后,打印排序结果以验证。这里我选择一个小数组进行演示,以便观察。注意:快速排序和归并排序是递归实现的,需要小心边界条件。</think> 以下是用Java实现几种常见的`int`数组排序算法及详细说明: ### 1. 冒泡排序 (Bubble Sort) ```java public static void bubbleSort(int[] arr) { int n = arr.length; for (int i = 0; i < n-1; i++) { for (int j = 0; j < n-i-1; j++) { if (arr[j] > arr[j+1]) { // 交换相邻元素 int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } } } } ``` **原理**: 重复遍历数组,比较相邻元素,若顺序错误则交换。每轮遍历将最大元素"冒泡"到末尾。 **时间复杂度**:O(n²) **适用场景**:小型数组或教学演示 ### 2. 选择排序 (Selection Sort) ```java public static void selectionSort(int[] arr) { int n = arr.length; for (int i = 0; i < n-1; i++) { int minIndex = i; for (int j = i+1; j < n; j++) { if (arr[j] < arr[minIndex]) { minIndex = j; } } // 交换当前元素与最小值 int temp = arr[minIndex]; arr[minIndex] = arr[i]; arr[i] = temp; } } ``` **原理**: 每次从未排序部分选出最小值,放到已排序序列末尾。 **时间复杂度**:O(n²) **优势**:交换次数少(最多n次) ### 3. 插入排序 (Insertion Sort) ```java public static void insertionSort(int[] arr) { int n = arr.length; for (int i = 1; i < n; i++) { int key = arr[i]; int j = i-1; // 后移大于key的元素 while (j >= 0 && arr[j] > key) { arr[j+1] = arr[j]; j--; } arr[j+1] = key; // 插入正确位置 } } ``` **原理**: 将每个元素插入到已排序序列中的正确位置,类似扑克牌排序。 **时间复杂度**:O(n²) **适用场景**:小型或基本有序数组 ### 4. 快速排序 (Quick Sort) ```java public static void quickSort(int[] arr, int low, int high) { if (low < high) { int pi = partition(arr, low, high); // 获取基准点 quickSort(arr, low, pi-1); // 左子数组 quickSort(arr, pi+1, high); // 右子数组 } } private static int partition(int[] arr, int low, int high) { int pivot = arr[high]; // 选取最后元素为基准 int i = low - 1; // 小于基准的边界 for (int j = low; j < high; j++) { if (arr[j] <= pivot) { i++; // 交换元素 int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } // 将基准放到正确位置 int temp = arr[i+1]; arr[i+1] = arr[high]; arr[high] = temp; return i+1; } ``` **原理**: 1. 选取基准元素分区 2. 递归排序左(≤基准)右(≥基准)子数组 **时间复杂度**:平均O(n log n),最坏O(n²) **优化点**:三数取中法选基准 ### 5. 归并排序 (Merge Sort) ```java public static void mergeSort(int[] arr, int left, int right) { if (left < right) { int mid = left + (right - left)/2; mergeSort(arr, left, mid); // 左半部 mergeSort(arr, mid+1, right); // 右半部 merge(arr, left, mid, right); // 合并 } } private static void merge(int[] arr, int left, int mid, int right) { // 创建临时数组 int[] temp = new int[right - left + 1]; int i = left, j = mid+1, k = 0; // 合并两个有序数组 while (i <= mid && j <= right) { temp[k++] = arr[i] <= arr[j] ? arr[i++] : arr[j++]; } while (i <= mid) temp[k++] = arr[i++]; while (j <= right) temp[k++] = arr[j++]; // 拷贝回原数组 System.arraycopy(temp, 0, arr, left, temp.length); } ``` **原理**: 分治法策略,先递归分解数组,再合并有序子序列 **时间复杂度**:O(n log n) **空间复杂度**:O(n) ### 6. Java内置排序 (Arrays.sort) ```java import java.util.Arrays; // 使用 int[] arr = {5, 2, 9, 1, 5}; Arrays.sort(arr); // 双轴快速排序 Arrays.parallelSort(arr); // 并行排序(大数据量) ``` **实现原理**: - 小数组:插入排序 - 大数组:双轴快速排序(Dual-Pivot Quicksort) **时间复杂度**:O(n log n) **特点**:官方优化,处理5千万元素仅需2秒 --- **完整测试示例**: ```java public class SortDemo { public static void main(String[] args) { int[] arr = {64, 34, 25, 12, 22, 11, 90}; // 根据需要调用排序方法 bubbleSort(arr.clone()); quickSort(arr.clone(), 0, arr.length-1); Arrays.sort(arr.clone()); } } ``` **算法选择建议**: | 场景 | 推荐算法 | |------|----------| | 小型数组(≤50) | 插入排序 | | 通用场景 | `Arrays.sort()` | | 需要稳定性 | 归并排序 | | 内存敏感 | 堆排序(未展示) | | 大数据并行 | `Arrays.parallelSort()` |
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值