Question

我是Java的新手，所以一直试图将一些旧的JS练习翻译成Java。

这是一个泡泡排序（我知道，我知道......），但这不起作用：

class BubbleSort{
public static void main(String args[]){

int nums [] = {5, 4, 6, 3, 12, 1};


Boolean swap = true;
while(swap){
    swap = false;
    for(int i = 1; i<nums.length ; i++){
        if (nums[i - 1] > nums[i]){
            int t = nums[i-1];
            nums[i-1] = nums[i];
            nums[i] = t;
            swap = true;
        }else{
            swap = false;
        }
    }
}

System.out.print("Sorted: ");
for(int j=0 ; j<nums.length ; j++)
System.out.print(nums[j] + " ");
}
}

它返回4,3,5,1,6,12 ...... 因此，正在进行一些互换，但有些事情正在提前结束。

有人能发现我的问题吗？

Answer 1

只需删除代码中的else块（如下面的代码示例所示）。一旦没有订购，你必须立即进行另一次交换。

在您的代码中，如果最后的项目顺序错误，则只进行另一次交换。如果您的阵列结束太快订购，那么您的排序也会很快结束。

class BubbleSort{
    public static void main(String args[]){

        int nums [] = {5, 4, 6, 3, 12, 1};

        Boolean swap = true;
        while(swap){
            swap = false;
            for(int i = 1; i<nums.length ; i++){
                if (nums[i - 1] > nums[i]){
                    int t = nums[i-1];
                    nums[i-1] = nums[i];
                    nums[i] = t;
                    swap = true;
                }/* else{
                    swap = false;
                }*/
            }
        }

        System.out.print("Sorted: ");
        for(int j=0 ; j<nums.length ; j++)
            System.out.print(nums[j] + " ");
    }
}

Answer 2

当你的第一个内部循环没有交换结束时，交换标记布尔值为false，外部循环停止。

这就是全部。

Answer 3

删除else块，它将起作用

    Boolean swap = true;
    while(swap){
        swap = false;
        for(int i = 1; i<nums.length ; i++){
            if (nums[i - 1] > nums[i]){
                int t = nums[i-1];
                nums[i-1] = nums[i];
                nums[i] = t;
                swap = true;
            }
        }
    }

这个else块使它错了，因为如果你最后一次检查不需要交换，它将结束外部while循环

Answer 4

是。不要使用swap将false重置为else;并且更喜欢boolean到Boolean。像，

boolean swap = true;
while (swap) {
    swap = false;
    for (int i = 1; i < nums.length; i++) {
        if (nums[i - 1] > nums[i]) {
            int t = nums[i - 1];
            nums[i - 1] = nums[i];
            nums[i] = t;
            swap = true;
        }
    }
}

输出

Sorted: 1 3 4 5 6 12

没有其他变化。这个可以使用一些lambda进行优化，并且提取swap方法也会有所帮助。像，

private static void swap(int[] arr, int i, int j) {
    if (arr[i] > arr[j]) {
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
}

public static void main(String args[]) {
    int nums[] = { 5, 4, 6, 3, 12, 1 };
    IntPredicate ip = i -> nums[i - 1] > nums[i];
    while (IntStream.range(1, nums.length).anyMatch(ip)) {
        IntStream.range(1, nums.length).forEach(i -> swap(nums, i - 1, i));
    }
    System.out.print("Sorted: " + IntStream.of(nums)
            .mapToObj(String::valueOf).collect(Collectors.joining(" ")));
}

Answer 5

static void sort(int[] a) {
        for (int i = a.length - 2; i >= 0; i--) {
            boolean flag = true;
            for (int j = 0; j <= i; j++) {
                if (a[j] > a[j + 1]) {
                    flag = false;
                    int temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
            if (flag)
                break;
        }
    }

Answer 6

正如许多其他人已经说过的那样，在比较步骤中将swap设置为false是不正确的。如果循环中的最终比较不会导致交换，则代码将提前终止。

由于您询问的是bubbleSort，您实施的内容实际上并不是冒泡排序。 classic BubbleSort使用一对嵌套的for循环。外循环找到列表中的最大数字，并确保它从索引n-1开始，然后是n-2等，从而冒泡到数组中的顶部位置。

内部循环扫描从索引0到外部循环设置的所有元素，并成对地比较元素，如果它们乱序则交换它们。

这是经典的bubbleSort：

class BubbleSort{

     /**
      * Swaps to elements in array data at index1 and index2
      *
      * @param data the array whose elements should be swapped
      * @param index1 index of first element to be swapped
      * @param index2 index of second elememt to be swapped with the first
      *
      */
     private static <T extends Comparable<T>>  void swap(T[] data, int index1, int index2)
        {
          T temp       = data[index1];
          data[index1] = data[index2];
          data[index2] = temp;
        }       

    /**
     * Sorts the specified array of objects using a bubble sort algorithm.
     *
     * @param data the array to be sorted
     */
    public static <T extends Comparable<T>> void bubbleSort(T[] data)
    {
        int position, scan;

        for (position =  data.length - 1; position >= 0; position--)
        {
            for (scan = 0; scan <= position - 1; scan++)
            {
                if (data[scan].compareTo(data[scan+1]) > 0)
                    swap(data, scan, scan + 1);
            }
        }
    }


public static void main(String args[]){
   Integer nums [] = {5, 4, 6, 3, 12, 1};

   bubbleSort(nums);

   System.out.print("Sorted: ");
   for(int j=0 ; j<nums.length ; j++)
      System.out.print(nums[j] + " ");
   System.out.println("");
  }
}

Java Bubble Sort仅返回部分排序

6 个答案: