Question

我编码了2个bubblesort算法。一个是没有递归，另一个是递归。我很想知道这两个中哪一个更有效，并解释原因。

递归bubbleSort：

private static int list[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};

public int[] recursiveBubble(int[] args, int startIndex, int endIndex) {
    if(startIndex > endIndex){
        System.out.println("Recursive bubblesort:");
        System.out.println(Arrays.toString(args));
        return args;
    }

    if (startIndex == endIndex - 1) {
        recursiveBubble(args, 0, endIndex - 1);
    } else if (args[startIndex] > args[startIndex+1]) {
        int currentNumber = args[startIndex];
        args[startIndex] = args[startIndex + 1];
        args[startIndex + 1] = currentNumber;

        recursiveBubble(args, startIndex + 1, endIndex);
    } else  {
        recursiveBubble(args, startIndex + 1, endIndex);
    } 
    return args;
}

BubbleSort使用循环：

 public int[] bubblesort(int[] args) {
    System.out.println("Normal BubbleSort:");
    for (int j = 0; j < args.length; j++) {
        for (int i = 0; i < args.length; i++) {
            int currentNumber = args[i];
            if (i + 1 < args.length) {
                if (currentNumber > args[i + 1]) {
                    args[i] = args[i + 1];
                    args[i + 1] = currentNumber;
                }
            }
        }
    }
    System.out.println(Arrays.toString(args));
    return args;
}

Answer 1

我不确定你的意思是哪个更好但是冒泡排序本质上必须具有最佳和最坏情况的性能时间本质上算法的工作方式。最佳情况O（n）最坏情况O（n ^ 2）见http://en.wikipedia.org/wiki/Bubble_sort。迭代与递归不应该产生太大的差别。我认为递归会占用更多的堆栈内存。递归往往比迭代更难编写和跟踪。由于两者都是实际的冒泡排序实现没有时间好处，我会坚持迭代。

Answer 2

在上面的例子中，你更不用将循环替换为递归。在java中，递归版本可能不好，因为它可能导致基于长数组长度的堆栈溢出错误。复杂性明智我没有看到任何区别。如果你比较JVM的内存管理，那么递归版本将在内存中占用比普通循环更多的空间。如果增加变量的长度，您可能会注意到这种差异，或者您可能会遇到基于已分配的内存生成大小的堆栈溢出异常。

递归冒泡排序与正常冒泡排序

2 个答案: