java语言基础数组选择排序从小到大-作者:逝秋

本文详细介绍了选择排序算法的基本原理,并通过实例展示了如何优化排序过程,以实现从小到大的排序。包括代码实现、运行结果分析以及排序效率的讨论。
class  Text1
{
	//选择排序:从小到大
	public static void main(String[] args) 
	{
		int[]arr=new int[]{12,9,56,45,10};
		for (int c=0;c<arr.length;c++ )//控制从角标o到数组.length-1的比较次数
		{
			for (int b=c+1;b<arr.length;b++ )//从上for中得到角标(c)与该角标与之比较的相应角标(c+1循环)的大小比较
			{
				if(arr[c]>arr[b])
				{
					arr[c]=arr[b];//这里思路错误,最终得到每次比较的最小值而不是整体数组的最小值
				}


			}
			System.out.print(arr[c]);//第一次跳出内循环:arr{9,9,56,45,10}第二次跳出:arr{9,9,56,45,10}第三次跳出{9,9,10,45,10}
		}
	}
}
class Text2
{
	public static void main(String[] args) 
	{
		int[]arr=new int[]{12,9,56,45,10};
		for (int c=0;c<arr.length ;c++ )
		{
			for (int b=c+1;b<arr.length;b++ )
			{
				if(arr[c]>arr[b])
				{
					int tep=arr[c];//实现两个变量的值互换,由此可以排列出数组从小到大
					arr[c]=arr[b];
					arr[b]=tep;

				}


			}
			System.out.print(arr[c]+" ");//第一次跳出内循环:arr{9,12,56,45,10}第二次跳出:arr{9,10,56,45,12}
		}
	}
}

输出结果:

通过比较以后得出:如果数组的值在for循环中被重新赋值

int []arr=new int []{12,9,56,45,10};

for(int a=0;a<5;a++)

{

arr[a]=a+2;

}//当for循环结束时arr[]={14,11,58,47,12}

转载请注明出处,谢谢!作者:逝秋http://blog.youkuaiyun.com/vvqiu

<think>好的,我现在要解决的问题是Java数组排序从小到大。作为一个刚开始学习Java的新手,我需要仔细理解这个过程,并确保自己掌握了正确的步骤和方法。 首先,我应该回忆一下Java数组的基本操作。数组是一种存储多个相同类型数据的结构,而排序是常见的操作之一。排序有很多种方法,比如冒泡排序选择排序、插入排序等,但Java也提供了内置的方法来简化排序过程。特别是对于初学者来说,使用内置方法可能更高效,也更不容易出错。 接下来,我需要明确问题:如何将一个数组从小到大的顺序排列。这里可能需要分两种情况:一种是使用Java内置的排序方法,另一种是自己实现排序算法,比如冒泡排序。考虑到用户可能希望了解不同的方法,我需要准备两种方式的解释。 首先,使用内置方法。Java的Arrays类提供了sort方法,可以方便地对数进行排序。需要导入java.util.Arrays包,然后调用Arrays.sort(数组名)。这个方法会对数进行原地排序,即直接修改原数组,而不是返回一个新的排序后的数组。例如: int[] arr = {5, 2, 9, 1, 5}; Arrays.sort(arr); 这样arr就会变成{1, 2, 5, 5, 9}。 不过,用户可能需要知道这个方法的适用范围,比如对于不同类型的数组(如整数、字符串等),以及对于对象数组排序可能需要实现Comparable接口或者使用Comparator。 然后,如果用户想自己实现排序算法,比如冒泡排序,那应该如何操作呢?冒泡排序的基本思想是重复遍历数组,比较相邻元素,如果顺序不对就交换,直到整个数组有序。虽然效率不高,但对于理解算法原理很有帮助。 例如,实现冒泡排序的步骤可能如下: 1. 遍历数组,比较相邻元素。 2. 如果前面的元素大于后面的元素,交换它们。 3. 重复这个过程,每次遍历减少一次比较次数,因为最大的元素会逐渐移动到末尾。 4. 直到没有需要交换的元素,排序完成。 代码可能类似这样: 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; } } } } 然后,在main方法中调用这个方法对数进行排序。 接下来,我需要考虑用户可能的疑问,比如: - Arrays.sort()方法的时间复杂度是什么?对于不同的数据量,性能如何? - 如果数组中有重复元素,排序后它们的顺序会怎样? - 对于对象数组排序,如何处理? 对于第一个问题,Arrays.sort()对于基本类型数组使用的是双轴快速排序算法,时间复杂度平均为O(n log n),最坏情况下是O(n²)。对于对象数组,使用的是归并排序的变体,时间复杂度为O(n log n)。对于大多数情况,内置方法已经足够高效。 第二个问题,重复元素的顺序在排序后会被正确排列,但如果是稳定排序,相同元素的相对顺序会被保留。不过,Java的Arrays.sort()对于基本类型是不保证稳定性的,而对象数组排序是稳定的吗?实际上,对于对象数组,使用的是TimSort算法,它是稳定的。 第三个问题,对象数组需要实现Comparable接口,或者在调用sort时传入自定义的Comparator。例如: String[] strArr = {"banana", "apple", "cherry"}; Arrays.sort(strArr); // 按自然顺序排序,这里是字典序 或者自定义Comparator: Arrays.sort(strArr, (a, b) -> a.length() - b.length()); // 按字符串长度排序 此外,用户可能想知道如何对数进行降序排序。对于基本类型数组,可能需要将数组转换为对应的包装类数组,然后使用Collections.reverseOrder(),或者手动反转数组。例如: Integer[] arr = {5, 2, 9, 1, 5}; Arrays.sort(arr, Collections.reverseOrder()); 但需要注意的是,不能直接对int数组使用reverseOrder,因为Collections.reverseOrder()适用于对象数组。因此,可能需要将int数组转换为Integer数组,或者使用其他方法。 总结一下,回答用户的问题需要涵盖以下几点: 1. 使用Arrays.sort()方法进行排序。 2. 示例代码演示如何对int数组和String数组进行排序。 3. 提到自定义排序方法,比如实现冒泡排序。 4. 可能的高级内容,如对象数组排序和降序排序。 同时,需要确保代码示例正确,语法正确,并且使用中文清晰解释每个步骤。还要注意数组的类型,比如基本类型和对象类型的区别,以及排序后的结果是否符合预期。 最后,验证自己的思考是否正确。例如,编写一个简单的测试程序,使用Arrays.sort()对数进行排序,并打印结果,确认是否从小到大排列。或者手动实现冒泡排序,检查是否能正确排序。如果发现错误,比如循环条件不正确,或者交换逻辑有问题,需要及时修正。 通过这样的思考过程,确保提供给用户的答案既准确又全面,适合不同层次的学习者理解和应用。</think>在Java中,对数进行从小到大排序的常用方法如下: --- ### 一、使用内置方法 `Arrays.sort()` #### 1. **基本类型数组排序** ```java import java.util.Arrays; public class Main { public static void main(String[] args) { int[] arr = {5, 2, 9, 1, 5}; Arrays.sort(arr); // 直接修改原数组 System.out.println(Arrays.toString(arr)); // 输出: [1, 2, 5, 5, 9] } } ``` #### 2. **对象数组排序(如`String`)** ```java import java.util.Arrays; public class Main { public static void main(String[] args) { String[] strArr = {"banana", "apple", "cherry"}; Arrays.sort(strArr); // 按字典序排序 System.out.println(Arrays.toString(strArr)); // 输出: [apple, banana, cherry] } } ``` --- ### 二、手动实现排序算法(以冒泡排序为例) ```java public class Main { public static void main(String[] args) { int[] arr = {5, 2, 9, 1, 5}; bubbleSort(arr); System.out.println(Arrays.toString(arr)); // 输出: [1, 2, 5, 5, 9] } // 冒泡排序实现 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; } } } } } ``` --- ### 三、高级用法(自定义排序规则) #### 1. **降序排序** ```java import java.util.Arrays; import java.util.Collections; public class Main { public static void main(String[] args) { Integer[] arr = {5, 2, 9, 1, 5}; // 必须用包装类 Arrays.sort(arr, Collections.reverseOrder()); System.out.println(Arrays.toString(arr)); // 输出: [9, 5, 5, 2, 1] } } ``` #### 2. **对象自定义排序(如按字符串长度排序)** ```java import java.util.Arrays; import java.util.Comparator; public class Main { public static void main(String[] args) { String[] strArr = {"apple", "banana", "cherry"}; Arrays.sort(strArr, (a, b) -> a.length() - b.length()); System.out.println(Arrays.toString(strArr)); // 输出: [apple, banana, cherry](长度均为5、6、6) } } ``` --- ### 四、关键点总结 1. **内置方法 `Arrays.sort()`** - 简单高效,适合大多数场景。 - 对基本类型数组使用快速排序,对象数组使用归并排序(稳定)。 2. **手动实现排序算法** - 理解原理(如冒泡排序的双层循环和交换逻辑)。 - 时间复杂度为$O(n^2)$,适用于小规模数据。 3. **自定义规则排序** - 使用`Comparator`接口定义比较逻辑。 - 通过Lambda表达式简化代码(Java 8+)。 --- 通过上述方法,可以灵活应对不同场景的排序需求。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值