使用数组的冒泡排序算法

Question

好的，我今天已经为此工作了一段时间，我知道它非常接近完成。我一直在试图找到一个能够最终返回列表的转义子句。这是我处理过的所有代码。

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package algorithm;

import java.util.Arrays;
import java.util.Collections;

/**
 *
 * 
 */
public class Algorithm {

    /**
     * @param args the command line arguments
     */
    private static int list[] = {10, 9, 8, 7, 6};

    public static void main(String[] args) {
        Algorithm alg = new Algorithm();
        alg.bubblesort(list);
    }

    public Algorithm() {
    }

    public int[] bubblesort(int[] i) {
        for (int a = 0; a < i.length;) {
            for (int b = 1; b < i.length + 1;) {
                int currentNumber = i[a];
                if (b < i.length) {
                    if (currentNumber > i[b]) {
                        i[a] = i[b];
                        i[b] = currentNumber;
                        a++;
                        b++;
                    } else if (currentNumber < i[b]) {
                        a++;
                        b++;
                    }
                } else if (b == i.length) {
                    a = 0;
                    b = 1;
                }
            }
        }
        return i;
    }

    public void isSorted(int[] i) {
        for (int x = 0; x < i.length;) {
            if (i[x + 1] < i[i.length - 1]) {
                if (i[x] < i[x + 1]) {
                    x++;
                }
            }
        }

        System.out.println(Arrays.toString(i));
    } 
}

好的，我的问题是如何才能返回最终的排序列表？

Answer 1

这是一个用 Java 实现的冒泡排序......

public class BubbleSort {

static int intArray[] = { 10, 5, 100, 1, 10000 };

public static void doSort() {
    for (int outer = 0; outer < intArray.length; outer++) {
        for (int inner = 0; inner < intArray.length - outer- 1; inner++) {
            if (intArray[inner] > intArray[inner + 1]) {
                int temp = intArray[inner];
                intArray[inner] = intArray[inner + 1];
                intArray[inner + 1] = temp;
            }
        }
    }
}

public static void printArray() {
    for (int i = 0; i < intArray.length; i++) {
        System.out.print("  " + intArray[i]);
    }
}

public static void main(String args[]) {
    System.out.print("Array Before Sorting->");
    printArray();
    doSort();
    System.out.print("\nArray After Sorting ->");
    printArray();
}

}

对于上述程序和冒泡排序的详细解释，请查看链接-http://www.javabrahman.com/algorithms-in-java/bubble-sort-in-java/

Answer 2

进行冒泡排序最简单的方法是使用while 循环，这样您就不必嵌入for 循环。

试试这个：

public int[] bubblesort(int[] i) {
    int temp;
    int a = 0;

    while(a < (i.length - 1)) {
        if(i[a+1] < i[a]) {
            //Swap i[a] with i[a+1]
            temp = i[a];
            i[a] = i[a+1];
            i[a+1] = temp;
            //Reset counter
            a = 0;
        } else {
            //Increment counter if two elements are already in order
            a++;
        }
    }

    return i;
}

编辑：为你的尝试添加这个：

if(a == (i.length-1) {
    break;
}

一旦你的外循环结束（意味着它应该被排序），这应该会打破循环。代码如下所示：

public int[] bubblesort(int[] i) {
    for (int a = 0; a < i.length;) {
        for (int b = 1; b < i.length + 1;) {
            int currentNumber = i[a];
            if (b < i.length) {
                if (currentNumber > i[b]) {
                    i[a] = i[b];
                    i[b] = currentNumber;
                    a++;
                    b++;
                } else if (currentNumber < i[b]) {
                    a++;
                    b++;
                }
            } else if (b == i.length) {
                a = 0;
                b = 1;
            }
        }
        //Break out of loop when it gets to the end
        if(a == (i.length - 1)) {
            break;
        }
    }
    return i;
}

Answer 3

首先，您应该决定是（1）直接更改list还是（2）不。

alg.bubblesort(list);

我认为这句话的意思是（1），因为你没有抓住结果。如果你想做（2），它应该是

int[] result = alg.bubblesort(list);

并且，如果 (1) 更好，则修复 bubblesort 的定义

public void bubblesort (int[] args)

另外，你不应该使用int[] i，因为变量i通常表示数组的索引。