時間復雜度（Java，Quicksort）

Question

關於計算時間復雜度，我有一個非常普遍的問題（Big O表示法）。 當人們說QuickSort的最差時間復雜度是O（n ^ 2）（每次選擇數組的第一個元素作為數據透視，並且數組被反向排序）時，他們認為哪個操作得到O（n ^ 2）？ 人們會計算if / else語句的比較嗎？ 或者他們只統計它所做的掉期總數？ 一般來說，您如何知道計算Big O表示法的“步驟”。

我知道這是一個非常基本的問題，但我幾乎閱讀了谷歌上的所有文章，但仍然沒有弄明白

Answer 1

最糟糕的快速排序案例
最糟糕的情況是快速排序是對數組進行反向排序，正常排序和所有元素相等。

---

了解大哦
話雖如此，讓我們先了解一下Big-Oh是什么意思。

當我們只有漸近上界時，我們使用O符號。 對於給定函數g（n），我們用O（g（n））表示函數集合，O（g（n））= {f（n）：存在正c和n _o ，
所有n> = n _o } 0 <= f（n）<= cg（n）

---

我們如何計算Big-Oh？
Big-Oh基本上意味着程序的復雜性隨輸入大小而增加。

這是代碼：

import java.util.*;
class QuickSort
{
    static int partition(int A[],int p,int r)
    {
        int x = A[r];
        int i=p-1;
        for(int j=p;j<=r-1;j++)
        {
            if(A[j]<=x)
            {
                i++;
                int t = A[i];
                A[i] = A[j];
                A[j] = t;
            }
        }

        int temp = A[i+1];
        A[i+1] = A[r];
        A[r] = temp;
        return i+1;
    }
    static void quickSort(int A[],int p,int r)
    {
        if(p<r)
        {
            int q = partition(A,p,r);
            quickSort(A,p,q-1);
            quickSort(A,q+1,r);
        }
    }
    public static void main(String[] args) {
        int A[] = {5,9,2,7,6,3,8,4,1,0};
        quickSort(A,0,9);
        Arrays.stream(A).forEach(System.out::println);
    }
}

考慮以下陳述：

第1塊：

int x = A[r];
int i=p-1;

第2塊：

if(A[j]<=x)
{
     i++;
     int t = A[i];
     A[i] = A[j];
     A[j] = t;
}

第3塊：

int temp = A[i+1];
A[i+1] = A[r];
A[r] = temp;
return i+1;

第4塊：

if(p<r)
{
    int q = partition(A,p,r);
    quickSort(A,p,q-1);
    quickSort(A,q+1,r);
}

假設每個語句占用一個恆定的時間c 。 讓我們計算每個塊的計算次數。

第一塊執行2C倍。 第二塊，執行圖5c次。 的口渴塊執行圖4c次。

我們將其寫為O（1），這意味着即使輸入的大小變化，語句執行的次數也相同。 所有2c，5c和4c都是O（1）。

但是，當我們在第二個塊上添加循環時

for(int j=p;j<=r-1;j++)
{
    if(A[j]<=x)
    {
        i++;
        int t = A[i];
        A[i] = A[j];
        A[j] = t;
    }
 }

它運行n次（假設rp等於n，輸入的大小），即nO（1）次，即O（n）。 但這並不是每次都運行n次。 因此，我們有平均情況O（log n），即至少遍歷log（n）個元素。

我們現在確定該分區運行O（n）或O（log n）。 最后一個塊，即quickSort方法，最終在O（n）中運行。 我們可以把它看作一個運行n次的封閉循環。 因此，整個復雜性是O（n ² ）或O（nlog n）。

Answer 2

它主要取決於可以增長的大小（n），因此對於快速排序數組，它是數組的大小。 您需要多少次訪問數組的每個元素？ 如果您只需要訪問每個元素，那么它就是O（n）等等。

隨着n增長而增長的臨時變量/局部變量將被計算在內。 當n增長時沒有顯着增長的其他變量可以計為常數：O（n）+ c = O（n）

Answer 3

只是為了補充其他人所說的內容，我同意那些說你算上一切的人，但是如果我從大學的算法課程中正確地回憶起來，與比較時間相比，交換開銷通常很小，在某些情況下是0（如果有問題的列表已經排序）。

例如。 線性搜索的公式是

T = K * N / 2。

其中T是總時間; K是定義總計算時間的常數; N是列表中元素的數量。

平均而言，比較次數為N / 2。

但我們可以將其重寫為以下內容：

T =（K / 2）* N.

或重新定義K，

T = K * N.

這清楚地表明時間與N的大小成正比，這正是我們真正關心的。 隨着N的顯着增加，它成為唯一真正重要的事情。

另一方面，二進制搜索以對數方式增長（O log（N））。