【Java 排序】冒泡排序(升降序,Int类型,Double类型,多数组排序)(111)

这篇具有很好参考价值的文章主要介绍了【Java 排序】冒泡排序(升降序,Int类型,Double类型,多数组排序)(111)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

思路:
用二重循环实现,外循环变量设为i,内循环变量设为j。假如有n个数需要进行排序,则外循环重复n-1次,内循环依次重复n-1,n-2,…,1次。每次进行比较的两个元素都是与内循环j有关的,它们可以分别用a[j]和a[j+1]标识,i的值依次为1,2,…,n-1,对于每一个i,j的值依次为0,1,2,…n-i 。

设数组长度为N:
1.比较相邻的前后二个数据,如果前面数据大于后面的数据,就将二个数据交换。
2.这样对数组的第0个数据到N-1个数据进行一次遍历后,最大的一个数据就“沉”到数组第N-1个位置。
3.N=N-1,如果N不为0就重复前面二步,否则排序完成。

自定义排序数据类型

1.Int类型:冒泡排序(降序)(一维单数组);
2.Int类型:冒泡排序(升序)(一维单数组);
3.Double类型:冒泡排序(降序)(一维单数组);
4.Double类型:冒泡排序(升序)(一维单数组);
5.Int类型:冒泡排序(升序):(一维双数组);
6.Int类型:冒泡排序(升序):(一维三数组);
7.Int类型:冒泡排序(降序):(一维双数组);
8.Doble类型:冒泡排序(降序):(一维双数组);
9.String类型:冒泡排序(降序):(二维双数组):(按照二维排序):
自定义:9.String类型:排序举例如下:
/*
* String类型:冒泡排序(降序):排序双数组(自定义二维数组二维排序):
* 自定义二维数组排序:
* 输入:
* arr1:{{“1”,“1”,“3”,“1”,“2”},{“1”,“2”,“1”},{“1”,“2”},{“1”}}
* arr2:{{“延安市”,“咸阳市”,“西安市”,“汉中市”,“宝鸡市”},{“广元市”,“成都市”,“绵阳市”},{“扬州市”,“南京市”},{“石家庄市”}}
* 输出:
* arr1:{{“3”,“2”,“1”,“1”,“1”},{“2”,“1”,“1”},{“1”,“2”},{“1”}}
* arr2:{{“西安市”,“宝鸡市”,“延安市”,“咸阳市”,“汉中市”},{“成都市市”,“广元”,“绵阳市”},{“南京市市”,“扬州”},{“石家庄市”}}
*
*/

直接上代码:

import java.util.Arrays;
import java.util.Iterator;

/*
 * 工具类:冒泡排序常用数据类型,用法总结
 * 
 */

public class BubblSortUtils {

	/*
     * 1.Int类型:冒泡排序(降序)(一维单数组);
     *
     */
    public static void bubbleSortDesc(int[] arr) {
        int temp;  // 定义一个临时变量
        for (int i=0;i<arr.length;i++) {
            for (int j = 0; j < arr.length; j++) {
                if (arr[i] >= arr[j]) {
                    temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }
    
    /*
     * 2.Int类型:冒泡排序(升序)(一维单数组);
     *
     */
    public static void bubbleSortAsc(int[] arr) {
	    int temp;  // 定义一个临时变量
	    for(int i=0;i<arr.length-1;i++){  // 冒泡趟数
	        for(int j=0;j<arr.length-i-1;j++){
	            if(arr[j+1]<arr[j]){
	                temp = arr[j];
	                arr[j] = arr[j+1];
	                arr[j+1] = temp;
	            }
	        }
	    }
	}   
    
    /*
     * 3.Double类型:冒泡排序(降序)(一维单数组);
     *
     */
    public static void bubbleSortDescDouble(Double[] arr) {
    	Double temp;  // 定义一个临时变量
        for (int i=0;i<arr.length;i++) {
            for (int j = 0; j < arr.length; j++) {
                if (arr[i] >= arr[j]) {
                    temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }
    
    /*
     * 4.Double类型:冒泡排序(升序)(一维单数组);
     *
     */
    public static void bubbleSortAscDouble(Double[] arr) {
	    Double temp;  // 定义一个临时变量
	    for(int i=0;i<arr.length-1;i++){  // 冒泡趟数
	        for(int j=0;j<arr.length-i-1;j++){
	            if(arr[j+1]<arr[j]){
	                temp = arr[j];
	                arr[j] = arr[j+1];
	                arr[j+1] = temp;
	            }
	        }
	    }
	}
    
    /*
     * 5.Int类型:冒泡排序(升序):(一维双数组);
     *
     */
    public static void bubbleSortAscMultiple(int[] arr,String[] arr2) {
	    int temp;  // 定义一个临时变量
	    String temp2;  // 定义一个临时变量
	    for(int i=0;i<arr.length-1;i++){  // 冒泡趟数
	        for(int j=0;j<arr.length-i-1;j++){
	            if(arr[j+1]<arr[j]){
	                temp = arr[j];
	                arr[j] = arr[j+1];
	                arr[j+1] = temp;
	                
	                temp2 = arr2[j];
	                arr2[j] = arr2[j+1];
	                arr2[j+1] = temp2;
	                
	            }
	        }
	    }
	}
    
    /*
     * 6.Int类型:冒泡排序(升序):(一维三数组);
     * 
     * 多个数组排序,可继续优化排序代码
     * 提供思路:比如:第一个入参传int类型数组进行排序,后面多个数组按照二维数组入参;
     *
     */
    public static void bubbleSortAscMultiple2(int[] arr,String[] arr2,String[] arr3) {
	    int temp;  // 定义一个临时变量
	    String temp2;  // 定义一个临时变量
	    String temp3;  // 定义一个临时变量
	    for(int i=0;i<arr.length-1;i++){  // 冒泡趟数
	        for(int j=0;j<arr.length-i-1;j++){
	            if(arr[j+1]<arr[j]){
	                temp = arr[j];
	                arr[j] = arr[j+1];
	                arr[j+1] = temp;
	                
	                temp2 = arr2[j];
	                arr2[j] = arr2[j+1];
	                arr2[j+1] = temp2;
	                
	                temp3 = arr3[j];
	                arr3[j] = arr3[j+1];
	                arr3[j+1] = temp3;
	                
	            }
	        }
	    }
	}
    
    /*
     * 7.Int类型:冒泡排序(降序):(一维双数组);
     *
     */
    public static void bubbleSortDescMultiple(int[] arr,String[]arr2) {
        int temp;
        String temp2;
        for (int i=0;i<arr.length;i++) {
            for (int j = 0; j < arr.length; j++) {
                if (arr[i] >= arr[j]) {
                    temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;

                    temp2 = arr2[i];
                    arr2[i] = arr2[j];
                    arr2[j] = temp2;
                }
            }
        }
    }
   
    /*
     * 8.Doble类型:冒泡排序(降序):(一维双数组);
     *
     */
    public static void bubbleSortDescMultipleDouble(Double[] arr,String[]arr2) {
    	Double temp;
        String temp2;
        for (int i=0;i<arr.length;i++) {
            for (int j = 0; j < arr.length; j++) {
                if (arr[i] >= arr[j]) {
                    temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;

                    temp2 = arr2[i];
                    arr2[i] = arr2[j];
                    arr2[j] = temp2;
                }
            }
        }
    }
    
    /*
     * 9.String类型:冒泡排序(降序):(二维双数组):(按照二维排序):
     *   自定义二维数组排序:
     *   输入:
     *   arr1:{{"1","1","3","1","2"},{"1","2","1"},{"1","2"},{"1"}}
     *   arr2:{{"延安市","咸阳市","西安市","汉中市","宝鸡市"},{"广元市","成都市","绵阳市"},{"扬州市","南京市"},{"石家庄市"}}
     *   输出:
     *   arr1:{{"3","2","1","1","1"},{"2","1","1"},{"1","2"},{"1"}}
     *   arr2:{{"西安市","宝鸡市","延安市","咸阳市","汉中市"},{"成都市市","广元","绵阳市"},{"南京市市","扬州"},{"石家庄市"}}
     *   
     */
	 public static void bubbleSortDescMultiple2(String[][] arr1,String[][]arr2) {
	    	
    	if(arr1.length == arr2.length) {
    		for (int a = 0; a < arr1.length; a++) {
				String [] s1 = arr1[a];
				int[] s2 = Arrays.asList(s1).stream().mapToInt(Integer::parseInt).toArray();
				String [] z1 = arr2[a];
				int temp;
				String temp2;
				for (int i=0;i<s2.length;i++) {
		            for (int j = 0; j < s2.length; j++) {
		                if (s2[i] >= s2[j]) {
		                    temp = s2[i];
		                    s2[i] = s2[j];
		                    s2[j] = temp;

		                    temp2 = z1[i];
		                    z1[i] = z1[j];
		                    z1[j] = temp2;
		                }
		            }
		        }
				// int数组转String数组;
				String[] s3 = new String[s2.length];
				for (int i = 0; i < s2.length; i++) {
					s3[i] = String.valueOf(s2[i]);
				}
				arr1[a] = s3;
				arr2[a] = z1;
    		}
    	}
    }
    
    // 测试用例:
    public static void main(String[] args) {
		
		int arr[] = new int[]{9,3,13,12,12,-2,5,-11,100,423,5622,78900};
		bubbleSortDesc(arr);
		System.out.println("1.Int类型:冒泡排序(降序):"+Arrays.toString(arr));
		
		System.out.println("----------------------------");
		
		int arr2[] = new int[]{9,3,13,12,12,-2,5,-11,100,423,5622,78900};
		bubbleSortAsc(arr2);
		System.out.println("2.Int类型:冒泡排序(升序):"+Arrays.toString(arr2));
			
		System.out.println("----------------------------");
		
		Double arr3[] = new Double[]{9.1,3.1,13.1,9.2,9.0,0.0,-0.2,-0.1,-0.35,100.0,423.0,9.0,5622.0,78900.0};
		bubbleSortDescDouble(arr3);
		System.out.println("3.Double类型:冒泡排序(升序):"+Arrays.toString(arr3));
		
		System.out.println("----------------------------");
		
		Double arr4[] = new Double[]{9.1,3.1,13.1,9.2,9.0,0.0,-0.2,-0.1,-0.35,100.0,423.0,9.0,5622.0,78900.0};
		bubbleSortAscDouble(arr4);
		System.out.println("4.Double类型:冒泡排序(升序):"+Arrays.toString(arr4));
		
		System.out.println("----------------------------");
		
		int arr5[] = new int[]{9,3,13,12,12,5};
		String arrStr5[] = new String[]{"西安","北京","上海","武汉","深圳","成都"};
		bubbleSortAscMultiple(arr5,arrStr5);
		System.out.println("5.Int类型:冒泡排序(升序):排序双数组1:"+Arrays.toString(arr5));
		System.out.println("5.Int类型:冒泡排序(升序):排序双数组2:"+Arrays.toString(arrStr5));
		
		System.out.println("----------------------------");
		
		int arr6[] = new int[]{9,3,13,12,12,5};
		String arrStrArr1[] = new String[]{"西安","北京","上海","武汉","深圳","成都"};
		String arrStrArr2[] = new String[]{"西安2","北京2","上海2","武汉2","深圳2","成都2"};
		bubbleSortAscMultiple2(arr6,arrStrArr1,arrStrArr2);
		System.out.println("6.Int类型:冒泡排序(升序):排序三数组1:"+Arrays.toString(arr6));
		System.out.println("6.Int类型:冒泡排序(升序):排序三数组2:"+Arrays.toString(arrStrArr1));
		System.out.println("6.Int类型:冒泡排序(升序):排序三数组3:"+Arrays.toString(arrStrArr2));
		
		System.out.println("----------------------------");
		
		int arr7[] = new int[]{9,3,13,12,12,5};
		String arrStr7[] = new String[]{"西安","北京","上海","武汉","深圳","成都"};
		bubbleSortDescMultiple(arr7,arrStr7);
		System.out.println("7.Int类型:冒泡排序(降序):排序双数组1:"+Arrays.toString(arr7));
		System.out.println("7.Int类型:冒泡排序(降序):排序双数组2:"+Arrays.toString(arrStr7));
				
		System.out.println("----------------------------");
		
		Double arr8[] = new Double[]{9.1,3.1,13.1,9.2,9.0,0.0};
		String arrStr8[] = new String[]{"西安","北京","上海","武汉","深圳","成都"};
		bubbleSortDescMultipleDouble(arr8,arrStr8);
		System.out.println("8.Doble类型:冒泡排序(降序):排序双数组1:"+Arrays.toString(arr8));
		System.out.println("8.Doble类型:冒泡排序(降序):排序双数组2:"+Arrays.toString(arrStr8));
		
		System.out.println("----------------------------");
		
		String[][] arr9 = {{"1","1","3","1","2"},{"1","2","1"},{"1","2"},{"1"}};
		String[][] arrStr9 = {{"延安市","咸阳市","西安市","汉中市","宝鸡市"},{"广元市","成都市","绵阳市"},{"扬州市","南京市"},{"石家庄市"}};
		bubbleSortDescMultiple2(arr9,arrStr9);
		for (int i = 0; i < arrStr9.length; i++) {
			System.out.println("i:"+i);
			String[] s = arr9[i];
			String[] z = arrStr9[i];
			for (int j = 0; j < s.length; j++) {
				System.out.println("9.String类型:冒泡排序(降序):排序双数组(自定义二维数组排序)1:"+z[j]+":"+s[j]);
			}
		}
		
		System.out.println("----------------------------");
		
	}  
}

测试输出:文章来源地址https://www.toymoban.com/news/detail-654590.html

1.Int类型:冒泡排序(降序)[78900, 5622, 423, 100, 13, 12, 12, 9, 5, 3, -2, -11]
----------------------------
2.Int类型:冒泡排序(升序)[-11, -2, 3, 5, 9, 12, 12, 13, 100, 423, 5622, 78900]
----------------------------
3.Double类型:冒泡排序(升序)[78900.0, 5622.0, 423.0, 100.0, 13.1, 9.2, 9.1, 9.0, 9.0, 3.1, 0.0, -0.1, -0.2, -0.35]
----------------------------
4.Double类型:冒泡排序(升序)[-0.35, -0.2, -0.1, 0.0, 3.1, 9.0, 9.0, 9.1, 9.2, 13.1, 100.0, 423.0, 5622.0, 78900.0]
----------------------------
5.Int类型:冒泡排序(升序):排序双数组1[3, 5, 9, 12, 12, 13]
5.Int类型:冒泡排序(升序):排序双数组2[北京, 成都, 西安, 武汉, 深圳, 上海]
----------------------------
6.Int类型:冒泡排序(升序):排序三数组1[3, 5, 9, 12, 12, 13]
6.Int类型:冒泡排序(升序):排序三数组2[北京, 成都, 西安, 武汉, 深圳, 上海]
6.Int类型:冒泡排序(升序):排序三数组3[北京2, 成都2, 西安2, 武汉2, 深圳2, 上海2]
----------------------------
7.Int类型:冒泡排序(降序):排序双数组1[13, 12, 12, 9, 5, 3]
7.Int类型:冒泡排序(降序):排序双数组2[上海, 深圳, 武汉, 西安, 成都, 北京]
----------------------------
8.Doble类型:冒泡排序(降序):排序双数组1[13.1, 9.2, 9.1, 9.0, 3.1, 0.0]
8.Doble类型:冒泡排序(降序):排序双数组2[上海, 武汉, 西安, 深圳, 北京, 成都]
----------------------------
i:0
9.String类型:冒泡排序(降序):排序双数组(自定义二维数组排序)1:西安市:3
9.String类型:冒泡排序(降序):排序双数组(自定义二维数组排序)1:宝鸡市:2
9.String类型:冒泡排序(降序):排序双数组(自定义二维数组排序)1:咸阳市:1
9.String类型:冒泡排序(降序):排序双数组(自定义二维数组排序)1:延安市:1
9.String类型:冒泡排序(降序):排序双数组(自定义二维数组排序)1:汉中市:1
i:1
9.String类型:冒泡排序(降序):排序双数组(自定义二维数组排序)1:成都市:2
9.String类型:冒泡排序(降序):排序双数组(自定义二维数组排序)1:绵阳市:1
9.String类型:冒泡排序(降序):排序双数组(自定义二维数组排序)1:广元市:1
i:2
9.String类型:冒泡排序(降序):排序双数组(自定义二维数组排序)1:南京市:2
9.String类型:冒泡排序(降序):排序双数组(自定义二维数组排序)1:扬州市:1
i:3
9.String类型:冒泡排序(降序):排序双数组(自定义二维数组排序)1:石家庄市:1
----------------------------


到了这里,关于【Java 排序】冒泡排序(升降序,Int类型,Double类型,多数组排序)(111)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • java冒泡排序(含冒泡排序代码)

    目录 一:冒泡排序思想 二:冒泡排序代码 三:结果  

    2024年02月14日
    浏览(41)
  • C语言基本语句(变量类型int、 float、 double、 char,函数scanf、printf、putchar()、getchar() )

    1. int, float, double, char ①整型int(对应%d)  int a,b;  scanf(\\\"%d,%d\\\",a,b); printf (\\\"%d\\\",a); printf(\\\"我今天吃了%d个苹果,在黑板上写下整数%d,这很有趣。\\\",a,b); //printf(\\\"……\\\",变量名)中,“……”部分内容比较自由,可随便发挥,但必须包括%d,几个变量名就对应几个%d ②单精度型浮点数

    2024年02月08日
    浏览(50)
  • Java BigDecimal、Integer、Long、Double类型数值累加求和

    注意 Double小数点失真问题解决 : 先把Double转为BigDecimal,再求和。代码如下 : 如果此篇文章有帮助到您, 希望打大佬们能 关注 、 点赞 、 收藏 、 评论 支持一波,非常感谢大家! 如果有不对的地方请指正!!! 参考1

    2024年02月02日
    浏览(45)
  • 日常踩坑:Java中double类型出现科学计数法问题

    背景:在与银行的项目对接中,近期客户反馈支付失败,错误信息是:“付款金额格式有问题”,经过日志分析,发现客户系统发送银行系统时,付款金额以科学计数法的形式传递参数。 重现: 经过测试发现,浮点数(double、float)当整数部分超过7位以上(不含7位),就会

    2024年02月16日
    浏览(44)
  • Java实现:选择排序、冒泡排序、插入排序

    本文我们将使用Java编程语言实现经典的选择排序、冒泡排序和插入排序算法,并用对数器进行测试。 选择排序的基本思想是:遍历数组,每次找到数组中最小的元素,将其放到数组的前端。接着,在剩余的元素中继续寻找最小的元素,将其放在已找到的最小元素之后。重复

    2024年02月02日
    浏览(32)
  • Java 与排序算法(1):冒泡排序

    冒泡排序(Bubble Sort)是一种简单的排序算法,它的基本思想是通过不断交换相邻两个元素的位置,使得较大的元素逐渐往后移动,直到最后一个元素为止。冒泡排序的时间复杂度为 O ( n 2 ) O(n^2) O ( n 2 ) ,空间复杂度为 O ( 1 ) O(1) O ( 1 ) ,是一种稳定的排序算法。 其实现过程

    2024年02月11日
    浏览(42)
  • 【Java】使用 Java 语言实现一个冒泡排序

    大家好,我是全栈小5,欢迎阅读小5的系列文章。 这是《Java》系列文章,每篇文章将以博主理解的角度展开讲解, 特别是针对知识点的概念进行叙说,大部分文章将会对这些概念进行实际例子验证,以此达到加深对知识点的理解和掌握。 温馨提示:博主能力有限,理解水平

    2024年03月22日
    浏览(40)
  • (四)Java算法:冒泡排序

       冒泡排序 (Bubble Sort),是一种计算机科学领域的较简单的排序算法。它的工作原理是:它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果不是指定顺序(比如从小达到)就把他们交换过来。走访元素的工作是重复地进行,直到没有相邻元素需要交换,也

    2024年02月04日
    浏览(86)
  • 关于java的冒泡排序

    我们前面的文章中了解到了数组的方法类Arrays,我们本篇文章来了解一下最出名的排序算法之一,冒泡排序!😀 冒泡排序的代码还是非常简单的,两层循环,外层冒泡轮数,里层依次比较,江湖中人人皆知! 1、比较数组中,两个相邻的元素,如果第一个数比第二个数大,我

    2024年01月22日
    浏览(25)
  • 【Java】冒泡排序

    冒泡排序(bubble sort)是最基础的排序算法,它是一种基础的 交换排序 。它的原理就像汽水一样,汽水中常常有许多小气泡飘到上面。而冒泡排序这种排序算法的 每一个元素也可以像小气泡一样根据自身大小一点点地向着数组一端移动 。 那冒泡排序具体是如何移动的呢? 对于

    2024年02月10日
    浏览(23)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包