Java中数组排序算法(冒泡排序)

最新推荐文章于 2024-07-24 16:24:19 发布
最新推荐文章于 2024-07-24 16:24:19 发布
阅读量553 收藏 1
点赞数
分类专栏： 开发经验总结 文章标签： java基础 java学习 java数组 冒泡算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31814611/article/details/89005477
版权

在其他地方你可能经常会看到一些关于java的数组排序，大多数写的都是同一种数据类型的数组排序，例如统一为整数的数组排序、统一为小数的数组排序，但是在实际开发中，这类排序是不能满足于我们的日常需求的。

今天就分享一下我个人采用的数组排序做法：

  1. 满足整数(int)、小数(double、float)的排序
  2. 可以满足于一维、二维、多维数组排序
  3. 封装类，随调随用

先新建一个包含主方法的类：Main.java

package com.ldw.arrayAlgorithm;

public class Main
{
	public static void main(String[] args)
	{
		Object[] arr_one = {10.2,32,21.73,15,66.0,30};
		System.out.println("排序前的数组："+outsortArray(arr_one));
		Array_sort arr_sort = new Array_sort();
		Object[] reArr = arr_sort.arrSortOne(arr_one);
		System.out.println("排序后的数组："+outsortArray(reArr));
		Object[][] rearr2= {{"小明",2},{"tom",0.5},{"Bucky",11},{"小李",8.8},{"老帅",10.12,999},{"Berry",5.0}};
		System.out.println("排序前的数组："+outsortArray_2(rearr2));
		System.out.println("排序后的数组："+outsortArray_2(arr_sort.arrSortTwo(rearr2,1)));
		
		//测试数组(一维)
		/*int[] ary = {21,10,23,42,11,35,66};
		Array_sort arr_test = new Array_sort(arr_one);
		System.out.println(arr_test.arrSortTest(ary));*/
	}
	
	/**
	 * 输出自定义数组文本
	 * @param arrObj
	 * @return
	 */
	public static String outsortArray(Object[] arrObj) {
		String arrStr = "[";
		for (int i = 0; i < arrObj.length; i++) {
			if(i != arrObj.length-1) {
				arrStr+=arrObj[i]+", ";
			}else {
				arrStr+=arrObj[i];
			}
			
		}
		arrStr+="]";
		return arrStr;
	}
	
	/**
	 * 输出自定义数组文本(二维)
	 * @param arrObj
	 * @return
	 */
	public static String outsortArray_2(Object[][] arrObj) {
		String arrStr = "[ [";
		for(int i = 0;i < arrObj.length; i++) {
			for (int j = 0; j < arrObj[i].length; j++) {
				if(j != arrObj[i].length-1) {
					arrStr+=arrObj[i][j]+", ";
				}else {
					arrStr+=arrObj[i][j];
				}
			}
			if(i != arrObj.length-1) {
				arrStr+="], [";
			}else {
				arrStr+="] ";
			}
			
		}
		arrStr+="]";
		return arrStr;
	}
}

然后新建数组排序(冒泡算法)封装类：Array_sort.java

package com.ldw.arrayAlgorithm;
public class Array_sort
{
	//定义一维数组变量
	private Object[] one;
	//定义临时存放数据类型的一维数组
	private String[] one_temp;
	//定义二维数组变量
	private Object[][] two;
	//定义当前类
	Array_sort that = this;
	/**
	 * 构造函数
	 */
	public Array_sort() {
		
	}
	public Array_sort(Object[] one){
		this.one = one;
		//System.out.println(this.one);
	}
	public Array_sort(Object[] one,Object[][] two){
		that.one = one;
		that.two = two;
	}
	
	/**
	 * 一维数组排序函数
	 * @return
	 */
	public Object[] arrSortOne(){
		//动态为临时数组实例长度
		that.one_temp = new String[that.one.length];
		for(int a=0;a<that.one.length;a++) {
			if(that.one[a] instanceof Integer) {
				that.one_temp[a] = "int";
			}else if(that.one[a] instanceof Byte) {
				that.one_temp[a] = "byte";
			}else if(that.one[a] instanceof Short) {
				that.one_temp[a] = "short";
			}else if(that.one[a] instanceof Long) {
				that.one_temp[a] = "long";
			}else if(that.one[a] instanceof Float) {
				that.one_temp[a] = "float";
			}else if(that.one[a] instanceof Double) {
				that.one_temp[a] = "double";
			}
			//将所有元素强转为double类型
			that.one[a] = Double.parseDouble(that.one[a].toString());
		}
		//冒泡算法排序
		for(int i=0;i<that.one.length;i++){
			for(int j=i+1;j<that.one.length;j++){
				//System.out.println(that.one[i].getClass());
				//System.out.println(Double.parseDouble(that.one[i].toString()));
				double front = Double.parseDouble(that.one[i].toString());
				double behind = Double.parseDouble(that.one[j].toString());
				if (front<behind) {
					//交换一维数组位置
					double temp = behind;
					that.one[j]=front;
					that.one[i]=temp;
					//交换临时一维数组位置
					String temps = that.one_temp[i];
					that.one_temp[i] = that.one_temp[j];
					that.one_temp[j] = temps;
				}
			}
			
		}
		for(int x=0;x<that.one.length;x++){
			switch (that.one_temp[x]) {
				case "int":
					/*int xx = Integer.parseInt(new java.text.DecimalFormat("0").format(that.one[x]));
					that.one[x] = xx;*/
					//System.out.println(that.one[x].getClass());
					/*double xx = (double) that.one[x];
					that.one[x] = (new Double(xx)).intValue();*/
					if(that.one[x] instanceof Double) {
						double xx = (double) that.one[x];
						that.one[x] = (new Double(xx)).intValue();
					}else if(that.one[x] instanceof Integer){
						that.one[x] = that.one[x];
					}
					break;
				case "byte":
					that.one[x] = (byte) that.one[x];
					break;
				case "short":
					that.one[x] = (short) that.one[x];
					break;
				case "long":
					that.one[x] = (long) that.one[x];
					break;
				case "float":
					that.one[x] = (float) that.one[x];
					break;
				case "double":
					if(that.one[x] instanceof Integer) {
						that.one[x] = Double.valueOf(that.one[x].toString());
					}else if(that.one[x] instanceof Double){
						that.one[x] = that.one[x];
					}
					break;
			}
		}
		return that.one;
	}
	/**
	 * 一维数组排序(重载)
	 * @param array
	 * @return
	 */
	public Object[] arrSortOne(Object[] array){
		that.one = array;
		Object[] resultSort = this.arrSortOne();
		return resultSort;
	}
	/**
	 * 二维数组排序
	 * @param index 指定排序索引依据
	 * @return
	 */
	public Object[][] arrSortTwo(int index) {
		//动态为临时数组实例长度
		that.one_temp = new String[that.two.length];
		for(int a=0;a<that.two.length;a++) {
			if(that.two[a][index] instanceof Integer) {
				that.one_temp[a] = "int";
			}else if(that.two[a][index] instanceof Byte) {
				that.one_temp[a] = "byte";
			}else if(that.two[a][index] instanceof Short) {
				that.one_temp[a] = "short";
			}else if(that.two[a][index] instanceof Long) {
				that.one_temp[a] = "long";
			}else if(that.two[a][index] instanceof Float) {
				that.one_temp[a] = "float";
			}else if(that.two[a][index] instanceof Double) {
				that.one_temp[a] = "double";
			}
			//将所有元素强转为double类型
			that.two[a][index] = Double.parseDouble(that.two[a][index].toString());
		}
		//冒泡算法排序
		for(int i=0;i<that.two.length;i++){
			for(int j=i+1;j<that.two.length;j++){
				//System.out.println(that.one[i].getClass());
				//System.out.println(Double.parseDouble(that.one[i].toString()));
				double front = Double.parseDouble(that.two[i][index].toString());
				double behind = Double.parseDouble(that.two[j][index].toString());
				if (front<behind) {
					//交换二维数组位置
					Object[] temp = that.two[j];
					that.two[j]=that.two[i];
					that.two[i]= temp;
					//交换临时一维数组位置
					String temps = that.one_temp[i];
					that.one_temp[i] = that.one_temp[j];
					that.one_temp[j] = temps;
				}
			}
					
		}
		for(int x=0;x<that.two.length;x++){
			switch (that.one_temp[x]) {
				case "int":
					/*int xx = Integer.parseInt(new java.text.DecimalFormat("0").format(that.one[x]));
					that.one[x] = xx;*/
					/*double xx = (double) that.two[x][index];
					that.that.two[x][index] = (new Double(xx)).intValue();*/
					if(that.two[x][index] instanceof Double) {
						double xx = (double) that.two[x][index];
						that.two[x][index] = (new Double(xx)).intValue();
					}else if(two[x][index] instanceof Integer){
						that.two[x][index] = that.two[x][index];
					}
					//that.two[x][index] = (int) that.two[x][index];
					break;
				case "byte":
					that.two[x][index] = (byte) that.two[x][index];
					break;
				case "short":
					that.two[x][index] = (short) that.two[x][index];
					break;
				case "long":
					that.two[x][index] = (long) that.two[x][index];
					break;
				case "float":
					that.two[x][index] = (float) that.two[x][index];
					break;
				case "double":
					/*double xx = (double) that.two[x][index];
					System.out.println(Double.valueOf(xx));*/
					if(that.two[x][index] instanceof Integer) {
						that.two[x][index] = Double.valueOf(that.two[x][index].toString());
					}else if(that.two[x][index] instanceof Double) {
						that.two[x][index] = that.two[x][index];
					}
					//that.two[x][index] = (double) that.two[x][index];
					break;
			}
		}
		return that.two;
		
	}
	/**
	 * 二维数组排序(重载)
	 * @param array 排序二维数组
	 * @param index 指定排序索引依据
	 * @return
	 */
	public Object[][] arrSortTwo(Object[][] array ,int index) {
		this.two = array;
		Object[][] resultSort = this.arrSortTwo(index);
		return resultSort;
		
	}
	
	//数组排序测试(int类型)
	public int[] arrSortTest(int[] array){
		for(int i=0;i<array.length-1;i++){
			for(int j=i+1;j<array.length-1;j++){
				if(array[i] < array[j]){
				 	int temp;
				 	temp = array[j];
				 	array[j]=array[i];
				 	array[j]=temp;
				 }
			}
			
		 }
		 System.out.println(array);
		 return array;
	}
}

通过运行主函数可以在控制台看到类似以下输出：

当前Array_sort.java仅对一维数组和二维数组排序进行封装，有兴趣的朋友可以继续完成多维数组的封装，原理同二维数组排序类似

小黑猪的家
关注
专栏目录
java数组-冒泡排序
m0_62705509的博客
09-18 334
java-冒泡排序
java语言编写的数组冒泡排序法,Java实现数组排序含冒泡排序、选择排序
weixin_31880471的博客
03-11 1505
数组排序其实很简单，但是小疯因为许久不用有些生疏，所以在这里重温一下，这里有两种简单的冒泡和选择。一、冒泡排序根据数组的长度循环遍历，并判断如果前一个值小于后一个值，那么就把“后一个值”排列到“当前前一个值”的前面。代码实现如下：// 定义一个无序的整形数组int arr[] = {25,29,13,10,12,14,41};// 进行排序for(int i = 0; i < arr.len...
Java数组，冒泡排序
fengbingbing1的博客
12-18 182
冒泡排序： 需求：数组中存储多个学生分数，按照分数从低到高的顺序排序 步骤：1:两两做大于比较，大的往后移，小的往前移,把最大的值找出来，放在倒数第1位 这个时候，我们数组划分为2部分，排好序是一部分，未排序的是一部分 2:两两做大于比较，大的往后移，小的往前移,把第二大的值找出来，放在倒数第2位 这个时候，我们数组划分为2部分，排好序是一部分，未排序的是一部分 3：依次类推，直到把所有的数字都按...
Java学习笔记（五）数组、冒泡排序
最新发布
Jin_Xiang123的博客
07-24 867
数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。即:数组就是一组数据数据类型数组名[]=new数据类型【大小】//创建了一个数组，名字a,存放5个int说明:这是定义数组的一种方法。为了让大家明白，我画数组内存图说明将拷贝到arr2数组要求数据空间是独立的代码示例拷贝过程public class 数组拷贝 {//将int[]arr1={10,20,30};拷贝到arr2数组,//要求数据空间是独立的.
java数组——冒泡排序
Fat_peach的博客
05-22 238
了解冒泡排序，应用冒泡排
java实现数组的冒泡排序、选择排序代码
热门推荐
gt.liu的博客
11-22 4万+
数组排序之冒泡排序： 相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处package cn.lgt.sortarray;public class MaoPaoSort { public static void maoPaoSort(int[] arr){ //冒泡排序 for(int i = 0; i < arr.length; i++){
Java数组：冒泡排序
W256936的博客
07-14 3967
在编程中，排序是一项常见的任务，其中冒泡排序是最简单且易于理解的排序算法之一。本文将介绍Java中的数组冒泡排序算法，包括实现原理、代码示例和算法的时间复杂度分析，帮助读者理解和运用这个简单而强大的排序算法。
Java简单数组排序(冒泡法)
09-03
本文将深入探讨一个简单的数组排序技术——冒泡排序法，通过实例来阐述其工作原理和Java中的实现方式。 冒泡排序是一种基础的排序算法，其基本思想是通过重复遍历待排序的数列，依次比较相邻元素并根据需要交换它们...
java数组排序示例(冒泡排序、快速排序、希尔排序、选择排序)
09-04
在Java编程中，数组排序是常见的操作，有多种算法可供选择。本文主要介绍四种常见的排序算法：冒泡排序、快速排序、希尔排序和选择排序。这些算法各有特点，适用于不同的场景。 1. **冒泡排序**： 冒泡排序是一种...
二维数组如何进行冒泡排序
07-18
### 二维数组冒泡排序详解 #### 一、引言 冒泡排序是一种简单的排序算法，...这种思路不仅可以应用于冒泡排序，还可以推广到其他类型的排序算法中。希望本文能够帮助初学者更好地理解二维数组排序的原理和实现细节。
Java数组排序算法.docx
01-29
Java数组排序算法主要涵盖三种经典的排序方法：冒泡排序、直接选择排序以及反转排序。这三种算法都是在处理数组数据时，对数组元素按照特定规则进行重新排列的常见方法。 1. **冒泡排序**： 冒泡排序是一种简单的...
java数组排序冒泡排序源代码
10-29
java冒泡排序 代码为排序源代码 简洁明了 无其他
Java数组08：冒泡排序
weiyoo55的博客
05-27 192
冒泡排序 冒泡排序无疑是最为出名的排序算法之一，总共有八大排序！ 冒泡排序的代码是相当简单的，两层循环，外层冒泡轮数，里层依次比较，江湖无人不晓，无人不知。 我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为O(n^2). package com.wang.array; import java.util.Arrays; //冒泡排序 //1、比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置 //2、每一次比较，都会产生出一个最大，或者最小的数字 //3、下一轮则可以
【Java数组】冒泡排序
Smilence的博客
11-07 204
冒泡排序 public static int[] paixu(int[] a) { for (int i = 0; i < a.length; i++) { for (int j = 0; j < a.length - i - 1; j++) { if (a[i] > a[i + 1]) { ...
Java数组--冒泡排序
qq_45028878的博客
02-22 159
冒泡排序 冒泡排序无疑是最为出名的排序之一，总共有八大排序 冒泡的代码，两层循环，外层冒泡轮数，里层依次比较 看到嵌套循环，应该就可以得出这个算法的时间复杂度O(n2) package com.tao.array; import java.util.Arrays; public class ArrayDemo07 { public static void main(String[] args) { int[] a={11,2,2,2,72,33,64,51};
java之数组冒泡排序
阅后即焚
09-09 234
程序代码 import java.util.Scanner; public class MyFun2 { public static void main(String[] args) { int[] arr = { 9, 8, 3, 5, 2 }; System.out.print("冒泡排序前 ："); printArra...
JAVA数组的冒泡排序
qq_38146131的博客
08-30 196
package test; public class Test { private static void arraySort(int[]array) { for (int i = 0; i &lt; array.length-1; i++) { for (int j = 0; j &lt; array.length-i-1; j++) { if(array[...
Java数组排序算法详解：冒泡、递增、快速、选择排序
"Java数组常用排序算法的实例代码与解析" 在Java编程中，排序是常见的操作，本资源总结了四种常用的排序算法，分别是冒泡排序、数组递增排序（也称为简单选择排序）、快速排序以及选择排序。这些算法都是基于数组...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值