Sorting 我对选择排序的分析正确吗？

这里的业余爱好者，我正在阅读CLS，我在分析方面遇到了问题。主要是因为我不太擅长从不同类型的循环和东西中求和。无论如何，我写了一个解释和一些示例代码来告诉你我的意思。我认为这是对的，但是我从很多不同的来源得到了不同的信息。首先，这里有一些C++中的示例代码，您会注意到它包含对整数N的引用以及它的几个增量。把这些放在那里是为了计算每一个陈述作为检查它的方式的次数

int *intSelSort(int a[], int size, int &n){
    int i, k, in; 
    for(int j = 0; ++n && j < size -1; j++){
        k = a[j]; 
        n++;
        for(int i = j+1; ++n && i < size; i++)

            if(++n && a[i] < k){
                k = a[i];
                in = i;
            } 

        a[in] = a[j];
        a[j] = k; 
        n+=2;
    }
    return a; 
}

int*intSelSort（int a[]，int size，int&n）{
int i，k，in；
对于（int j=0；++n&&j

此示例与长度为5的数组一起使用时，n的值为41。除了最内层for循环的情况外，计数都被删除，计数为14。这对以后很重要

无论如何，CLS做的事情有点不同，首先它使用伪代码和从1开始的数组索引。我写了一些来反映他们的工作

//[1][2][3][4][5]
//Highest j is 4, i is 5

int k, index;                           //O(1)
n = A.Size                              //O(1)
for j = 1, j < n, j++ do                //O(N)
    k = A[j]                            //O(N - 1)
    for i = j + 1, i <= n, i++ do       //O((n^2 + n - 2)/2)
            if(A[i] < k)                //O((n^2 - n)/2)    
                k = A[i]                //O(c)
                index = i               //O(c)
    A[index] = A[j]                     //O(N - 1)
    A[j] = k                            //O(N - 1)

/[1][2][3][4][5]
//最高的j是4，i是5
int k，索引//O（1）
n=A.尺寸//O（1）
对于j=1，j
和（n）（0->n=n-2）-和（n）（0->n=n-2）=

n（n-2+1）-（n-1）（n-2））/2=（n^2+n-2）/2

如果n=5，则得到14。测试中的确切步骤数


对于该For循环中的if

求和（n-n-1）(0->n=n-2）

=（n^2+n-2）/2-和（1）-（0->n=n-2）

=（n^2+n-2）/2-（n-1）=（n^2-n）/2，或者在本例中为10

单独测试最内部的if语句也会产生10个比较


C取决于if语句是否为真。
案例一：列表已经排序，if语句永远不会被排序
是的，所以这里的语句永远不会被调用

案例二：列表是反向排序的，调用if语句
楼层（N/2）次

5 4 3 2 1

14325

123445

9876554321

187665429

1 2 7 6 5 4 3 8 9

1234564789

123456789

在其他情况下，if语句的正确次数是否更多？
有没有办法证明if语句的子语句
时间复杂度n或更小，所以我可以忽略它们？它们是O（n）吗？
我在这里犯了什么严重的错误吗？我看到过一些网站有着不同的风格
这个的求和公式，所以我不确定
 我认为你的分析是正确的

对于您最后的问题：

对于序列
n，1，2，…，n-1
if语句是n-1倍true（和n-1倍交换两个元素）
对于相反的顺序，它不是地板（N/2）。是的

N-1+N-3+N-5+…+0=∑i=0，。。⌊N/2⌋ N-1-2⋅i&大约；（（N-1）⋅ N） /2

及⌊N/2⌋ 两个元素的互换次数

但由于if语句体中操作的O（1）复杂性，if语句的正确频率并不重要。你的分析非常准确。如果使用big-O表示法，这是不必要的。让我简化你的例子：

int k, index;                      // O(1)
n = A.Size                         // O(1)
for j = 1, j < n, j++ do           // O(N)  - runs n-1 times
    k = A[j]                       // O(1)  - takes only 1 step but is executet O(N) times.
    for i = j + 1, i <= n, i++ do  // O(N)  - the first run takes n-1 steps    -+  
            if(A[i] < k)           // O(1)  - this can be evaluated in 1 step   |- together 1 to 3 steps. So the whole if block is in O(1).
                k = A[i]           // O(1)  - this is at worst 1 more step     -+
                index = i          // O(1)  - this also
    A[index] = A[j]                // O(1)  - one step executet O(N) times
    A[j] = k                       // O(1)  - one step executet O(N) times

int k，index；//O（1）
n=A.尺寸//O（1）
对于j=1，j