Question

我的AP组合课程刚刚在一些基本的排序算法中超越了Big O.我对它如何与递归一起工作有点困惑，当我去其他堆栈溢出答案时，我不太确定他们是如何获得递归函数的每个级别的n的倍数并将它们添加到他们的最终答案。

我想在我创建的这个类中找到node.nodeSortTest（int [] someArray）的Big-O表示法。我怎样才能得到答案？它会是什么？

public class node{

    public int value;

    public node higher = null;
    public node lower = null;

    //Making it a public static object was just easier for the test
    public static int addIndex = 0;

    public node(int i){
        value = i;
    }

    public void addToNode(int i){
        if(i>=value)
            if(higher != null) higher.addToNode(i);
            else higher = new node(i);
        else
            if(lower != null) lower.addToNode(i);
            else lower = new node(i);   
    }

    public static void nodeSortTest(int[] nums){
        if(nums.length<2)
            return;
        node keyNode = new node(nums[0]);
        for(int i = 1; i < nums.length; i++)
            keyNode.addToNode(nums[i]);
        node.addIndex = 0;
        keyNode.addTo(nums);
    }

    public void addTo(int[] nums){
        if(lower != null) lower.addTo(nums);
        nums[addIndex] = value;
        addIndex++;
        if(higher != null) higher.addTo(nums);
    }
}

Answer 1

我们通常有两个组成部分：

呼叫树的深度
每次通话中的迭代广度。

在这种情况下，您在每次递归调用时将问题大致分成两半：这会让您深入调用log2（n）。

在每个级别，你处理数组的每个元素：挖掘代码，看看它是如何发生的;使用纸和铅笔，如果这有助于您可视化工作。这为该调用堆栈中的每个深度级别添加了 n 因子。

结果是David Choweller给你的n * log2（n）复杂性。

Answer 2

我添加了一些代码来提示值n并计算n个随机整数数组的操作数。测试似乎与O(n log2n)理论一致：

import java.util.Random;
import java.util.Scanner;

public class Node{

    public int value;

    public Node higher = null;
    public Node lower = null;

    //Making it a public static object was just easier for the test
    public static int addIndex = 0;
    public static int numOps = 0;

    public Node(int i){
        value = i;
    }

    public void addToNode(int i){
        if(i>=value)
            if(higher != null) higher.addToNode(i);
            else higher = new Node(i);
        else
            if(lower != null) lower.addToNode(i);
            else lower = new Node(i);
        numOps++;
    }

    public static void nodeSortTest(int[] nums){
        if(nums.length<2)
            return;
        Node keyNode = new Node(nums[0]);
        for(int i = 1; i < nums.length; i++)
            keyNode.addToNode(nums[i]);
        Node.addIndex = 0;
        keyNode.addTo(nums);
    }

    public void addTo(int[] nums){
        if(lower != null) lower.addTo(nums);
        nums[addIndex] = value;
        addIndex++;
        if(higher != null) higher.addTo(nums);
        numOps++;
    }
    public static void main(String args[]) {
        Random r = new Random();
        System.out.print("Enter size of array: ");
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();

        int [] arrayToSort = new int [n];
        for (int i=0; i < n; i++) {
            arrayToSort[i] = r.nextInt(100000);
        }
        for (int i: arrayToSort) {
            System.out.print(i+",");
        }
        System.out.println();
        nodeSortTest(arrayToSort);
        for (int i:arrayToSort) {
            System.out.print(i+",");
        }
        System.out.println();
        System.out.println("\n\n\nn=" + arrayToSort.length + ", numOps=" + numOps);
        double log2n = Math.log(n)/Math.log(2);
        System.out.println("\n\nValue of n=" + n + " times log2n=" + log2n + " = " + n*log2n);
        scan.close();
    }
}

大O与递归

2 个答案: