确定此算法的Big-O(Determining the Big-O of this algorithm)

 我试图了解下面代码中的Big-O是什么。 
 
 代码应该做什么 
 
 本质上，我试图选择随机节点的子集（max size = selectionSize）以及它们之间存在的任何边。 随机节点的选择在while循环中完成。 完成后，我想选择所选节点之间存在的任何边。 
 
 我认为是什么和为什么 
 
 我认为运行时间是O = n^2 ，其中n=selectionSize 。 原因是：即使我可以增加nodes元素的大小（例如使其为10000），我不相信它会影响算法，因为我只是循环遍历selectionSize的最大值。 我有点担心这是错误的唯一原因是因为while循环，我从列表中选择随机元素，直到我有足够的。 虽然这可能需要很长时间（因为它是随机的），但我认为它不会影响整体输出的时间。 编辑 ：呃第二个想法......没关系...... nodes大小确实影响它（因为node.getNeighbors()最多可以是nodes的大小）..所以我认为如果selectionSize等于大小nodes的运行时间为O=n^2 ，其中n=size of nodes 。 
 
 任何提示/提示将不胜感激。 
 
 码 
 
// nodes and selectionSize are my input:
int[] nodes = {1,2,3...,1000}; // 1000 elements
int selectionSize = 500; // This can be at most the size of the elements (in this case 1000)

run_algo(nodes, selectionSize);

public void run_algo(int[] nodes, int selectionSize) {
    randomNodesList = {};

    while(randomNodesList < selectionSize) {
        randomNode = selectRandomNode(nodes); // Assume O(1)

        if(!randomNodesList.exists(randomNode)) { // Assume O(1)
            randomNodesList.push_back(randomNode); // Assume O(1)
        }
    }

    foreach(node in randomNodesList) {
        foreach(neighbor in node.getNeighbors()) { // Max. nodes size (in this case 1000)
            if (!randomNodesList.exists(neighbor)) { // Assume O(1)
                AddEdge(node, neighbor); // Takes O(1) time
            }
        }
    }
}

I'm trying to understand what the Big-O is of the code below. 
 
What the code is supposed to do
 
Essentially, I am trying to select a subset (max size = selectionSize) of random nodes and any edges that exists between them. The selection of random nodes is done in the while loop. After having done that, I want to select any edges that exist between the selected nodes. 
 
What I think it is & why
 
I think the running time is O = n^2 where n=selectionSize. The reason is: even though I can increase the size of the elements in nodes (e.g. make it 10000), I don't believe it can affect the algorithm since I am only looping through the maximum of selectionSize. The only reason I am a bit worried that this is wrong is because of the while loop, where I select random elements from the list up until I have enough. While this can take quite long (because it is random), I don't think it affects the overall output in terms of time. Edit: ugh on second thoughts... Nevermind... The nodes size does affect it (since node.getNeighbors()can be at most the size of the nodes).. So I think that if the selectionSize is equal to the size of nodes, the running time is O=n^2 where n=size of nodes.
 
Any tips/hints would be appreciated.
 
Code
 
// nodes and selectionSize are my input:
int[] nodes = {1,2,3...,1000}; // 1000 elements
int selectionSize = 500; // This can be at most the size of the elements (in this case 1000)

run_algo(nodes, selectionSize);

public void run_algo(int[] nodes, int selectionSize) {
    randomNodesList = {};

    while(randomNodesList < selectionSize) {
        randomNode = selectRandomNode(nodes); // Assume O(1)

        if(!randomNodesList.exists(randomNode)) { // Assume O(1)
            randomNodesList.push_back(randomNode); // Assume O(1)
        }
    }

    foreach(node in randomNodesList) {
        foreach(neighbor in node.getNeighbors()) { // Max. nodes size (in this case 1000)
            if (!randomNodesList.exists(neighbor)) { // Assume O(1)
                AddEdge(node, neighbor); // Takes O(1) time
            }
        }
    }
}

原文：https://stackoverflow.com/questions/44936927