排序算法的时间复杂度

Question

I came across the following question while I was doing some exercise:

A sorting algorithm starts from start of the list, scan until two succeeding items that are in the wrong order are found. Swap those items and go back to the beginning. The algorithm ends when the end of the list is reached.

What is the worst-case running time for a list of size n?

I feel that it is similar with bubble sort, but probably worse that that because it doesn't finish the whole pass of scanning the list. But I can't figure out how to calculate its time complexity. I am not sure if the code I came up below for this algorithm is correct. Many thanks for your help!

for (int i=0, i<n , i++){//n is the size of the array
     if (array[i]>array[i+1]){
          swap (array[i], array[i+1]);
          i=0;
     }
}

Answer 1

The number of comparisons for the worst case (I wont prove the worst case is n, n-1, ... 1 but I assume it is) is a tetrahedral number .

Why?

imagine a sequence

n, n-1, .... 1

so for 1, will be swap when everything before is already on place. So the number of comparisons when is in the last place will be n-1 before is swapped to the second last place. From the second last place it will have to do n - 2 comparisons. Following this logic, and extending to the previous numbers we have for different n:

In other words, for position ni will need to move one number down (1), from position n - 1 I will need to move 2, (1 & 2), from n-2 (1, 2 & 3). Assuming 1,2,3... n is the valid order and they start as n,...3, 2,1.

n = 3 -> 2 + 1 * 2 = 4 
n = 4 -> 3 + 2 * 2 + 3= 10 
n = 5 -> 4 + 3 * 2 + 2 * 3 + 4 = 20 
n = 6 -> 5 + 4 * 2 + 3 * 3 * 2 * 4 + 5 = 35
n = 7 -> 6 + 5 * 2 + 4 * 3 + 3 * 4 + 2 * 5 + 6 = 56 
n = 8 -> 7 + 6 * 2 + 5 * 3 + 4 * 4 + 3 * 5 + 2 * 6 + 7= 84

And this sequence is the tetrahedral numbers.

And as a binomial coeficient:

So, it seems that it is O(n^3)

Answer 2

This is a bad form of insertion sort. In insertion sort, the complexity of insertion is linear in the length of the array, here it is quadratic. Hence the worst case time complexity of this algorithm is IMO O(n^3).

If the initial array was 4, 3, 2, 1, then the steps of the algorithm would be:

4 3 2 1
3 4 2 1
3 2 4 1
2 3 4 1
2 3 1 4
2 1 3 4
1 2 3 4

Note that each step in this sequence has a linear time complexity because to get the position of the earliest 'inversion' you scan the entire array from the beginning.

Answer 3

An array may contain O(n^2) inversions. Every run corrects only one inversion and executes O(n) steps (comparisons). So overall time complexity is O(n^3).
The worst case - backward-sorted array with N*(N-1)/2 inversions, exact runtime analysis has already been done by Raul Guiu.

Answer 4

您所描述的是一种冒泡类型： http ： //en.wikipedia.org/wiki/Bubble_sort冒泡排序具有最坏情况和平均复杂度О(n2)

Answer 5

First, this algorithm looks like bubble-sort but slower than that.

Second, this algorithm is doing some non-sense operations, ie Swap those items and go back to the beginning. For example your initial array is as follows,

10 11 12 13 14 15 16 17 18 19 9

You will iterate till the end, when you see 9, swap it with 18 then go to the beginning of the array and start comparing if(arr[0] < arr[1]) but you already know that it is smaller.

The worst case running time of this is O(n^3). The pseudo code will be something like this:

for i = 0:n-1
    if(arr[i] > arr[i+1]){
        swap(arr[i], arr[i+1])
        i = 0;
    }

Answer 6

Now Compare both your Code and Bubble sort because it seems to be..

Your code It will give Max O(n^3)

Bubble sort

void bubbleSort(int arr[])
{
    int n = arr.length;
    for (int i = 0; i < n-1; i++)
        for (int j = 0; j < n-i-1; j++)
            if (arr[j] > arr[j+1])
            {
                // swap temp and arr[i]
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
}

It will give in worst case O(n^2) and even if array is sorted.