java冒泡排序的三种实现方法

第一种

通过简单的比较相邻的元素,如果他们的顺序是错误的,则交换它们的位置。
重复这个步骤,直到没有更多要交换的元素为止。
j变量代表未排序数组范围的右边界,j以后的已经排序

public static void bubble(int[] nums,int j){
        if(j == 0){
            return;
        }
        for (int i = 0; i < j; i++) {
            if(nums[i] > nums[i+1]){
                int a = nums[i];
                nums[i] = nums[i+1];
                nums[i+1]= a;
            }
        }
        bubble(nums,j-1);
    }

第二种

这里的x变量其实是一个分界的变量
x的左边未排序 右边则不需要排序
从而提高排序效率

    public static void bubble_plus(int[] nums,int j){
        if(j == 0){
            return;
        }
        int x = 0;
        for (int i = 0; i < j; i++) {
            if(nums[i] > nums[i+1]){
                int a = nums[i];
                nums[i] = nums[i+1];
                nums[i+1]= a;
                x = i;
            }
        }
        bubble_plus(nums,x);
    }

第三种

这种其实是对第一种的补充
x变量代表未排序变量的左边界
x之前以及j之后都已经排序
因此不需要再排序,提高效率

public static void bubble_pro(int[] nums,int j,int x){
        if(j <= x){
            return;
        }
        for (int i = 0; i < j; i++) {
            if(nums[i] > nums[i+1]){
                int a = nums[i];
                nums[i] = nums[i+1];
                nums[i+1]= a;
            }
        }
        bubble_pro(nums,j-1,x+1);
    }
  • 10
    点赞
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
### 回答1: 冒泡排序是一种简单的排序算法,原理是通过对待排序的数列进行多次遍历,对相邻两项进行比较并交换位置,使得序列中较小的项慢慢浮到序列的顶端。 下面是冒泡排序Java 实现方法: ``` public static void bubbleSort(int[] arr) { // 记录是否发生过交换的标志 boolean swapped; // 要遍历的次数 for (int i = 0; i < arr.length - 1; i++) { swapped = false; // 从第一个元素开始,比较相邻的两个元素 for (int j = 0; j < arr.length - 1 - i; j++) { if (arr[j] > arr[j + 1]) { // 交换元素 int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; swapped = true; } } // 如果没有发生交换,说明已经有序,可以结束排序 if (!swapped) { break; } } } ``` 调用方法: ``` int[] arr = {5, 2, 8, 1, 9}; bubbleSort(arr); ``` 冒泡排序的时间复杂度为 O(n^2),不是很适合对大型数据集进行排序。 ### 回答2: 冒泡排序是一种基本的排序算法,它通过比较相邻的元素并进行交换来实现排序。下面是冒泡排序Java实现方法: 1. 首先,创建一个整型数组,用于存储待排序的元素。 2. 使用嵌套的for循环进行排序。外层循环控制排序的趟数,内层循环用于比较相邻元素并进行交换。 3. 在每一趟中,比较相邻的两个元素,如果前面的元素大于后面的元素,则进行交换。 4. 内层循环的循环条件是当前元素不是数组的最后一个元素。每一趟循环都会使数组中最大的元素排到最后。 5. 外层循环的循环次数是数组的长度减一,因为每一趟都会使一个最大的元素排到最后,所以最后一个元素已经是最大的了。 6. 重复执行步骤3、4和5直到所有的元素都排序完成。 7. 最后,输出排序后的数组。 以下是用Java代码实现冒泡排序的示例: ```java public class BubbleSort { public static void main(String[] args) { int[] arr = {5, 2, 8, 1, 4}; int n = arr.length; for (int i = 0; i < n - 1; i++) { for (int j = 0; j < n - 1 - i; j++) { if (arr[j] > arr[j + 1]) { // 交换相邻元素 int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } // 输出排序后的数组 for (int num : arr) { System.out.print(num + " "); } } } ``` 以上就是使用Java实现冒泡排序方法冒泡排序算法简单易懂,但效率较低,适用于数据量较小的排序需求。 ### 回答3: 冒泡排序是一种简单直观的排序算法,它会多次遍历整个待排序的数组,在每次遍历中,相邻的两个元素进行比较,并根据大小交换位置,最大(或最小)的元素会像气泡一样逐渐冒泡到数组的最后位置。以下是冒泡排序Java实现方法: 1. 首先,定义一个整型数组array,表示待排序的数组。 2. 创建一个外层循环,从0到array.length-1进行遍历,表示需要进行array.length-1次的遍历。 3. 在每次外层循环的遍历过程中,创建一个内层循环,从0到array.length-1-i进行遍历,其中i为当前外层循环的遍历次数。 4. 在内层循环的遍历过程中,比较相邻的两个元素array[j]和array[j+1]的大小,如果array[j]大于array[j+1],则交换它们的位置。 5. 内层循环遍历完毕后,最大的元素已经冒泡到数组的最后位置,因此,下一次的外层循环可以从1开始,遍历到array.length-2-i。 6. 外层循环遍历完毕后,数组已经按照从小到大的顺序排列。 以下是具体的Java代码实现: ```java public class BubbleSort { public static void main(String[] args) { int[] array = {5, 2, 9, 1, 3}; for (int i = 0; i < array.length - 1; i++) { for (int j = 0; j < array.length - 1 - i; j++) { if (array[j] > array[j + 1]) { int temp = array[j]; array[j] = array[j + 1]; array[j + 1] = temp; } } } for (int num : array) { System.out.print(num + " "); } } } ``` 运行以上代码,输出结果为:1 2 3 5 9,即数组按照从小到大的顺序排列。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小风XFS

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值