k-shifted数组插入排序的时间复杂度

Question

This problem was asked in my algorithm course homework.

You have an n sized, sorted array at first. Lets say n=10 and the array is [1,2,3,4,5,6,7,8,9,10] . Then it is circularly shifted to the right by k . Lets say k=3 . Now the array is [8,9,10,1,2,3,4,5,6,7] .

What is the time complexity if you apply insertion sort on this array, depending on n and k ?

I researched this question a lot, but couldn't find a solution on the inte.net. How to determine the time complexity of insertion sort on such shifted array?

Answer 1

First of all, the insertion sort:

static void insertionSort(int[] array) {
    for (int i = 1; i < array.length; i++) {
        int key = array[i];
        int j = i - 1;

        while (j >= 0 && array[j] > key) {
            array[j + 1] = array[j];
            j--;           
        }

        array[j + 1] = key;
    }
}

The time complexity mostly depends on the following lines because that's where comparing and swapping operations are done.

while (j >= 0 && array[j] > key) {
    array[j + 1] = array[j];
    j--;
}

Take a paper, draw a swap table for each j value.

Eventually, you will understand that the algorithm gets into while loop (nk) times, and whenever it gets in, it does swap operation k times. So, time complexity is (nk)*k .

Lets prove it.

Put a swap counter variable to the algorithm.

static int insertionSort(int[] array) {
    int swapCount = 0;

    for (int i = 1; i < array.length; i++) {
        int key = array[i];
        int j = i - 1;
        while (j >= 0 && array[j] > key) {
            array[j + 1] = array[j];
            j--;
            swapCount++;
        }

        array[j + 1] = key;
    }

    return swapCount;
}

Now, lets try it on our array described in the question.

public class App {
    public static void main(String[] args) throws Exception {
        int[] baseArray = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

        int n = baseArray.length;
        int k = 3;

        // Shift base array by k
        int[] shiftedArray = shiftArray(baseArray, k);

        // Calculate how many swaps done by the insertion sort
        int swapCount = InsertionSort.insertionSort(shiftedArray);

        // Theroitical value is calculated by using the formula (n-k)*k
        int timeComplexityTheoritical = (n - k) * k;

        System.out.print("Theoritical Time Complexity based on formula: " + timeComplexityTheoritical);

        System.out.print(" - Swap Count: " + swapCount);

        System.out.print(" - Is formula correct:" + (timeComplexityTheoritical == swapCount) + "\n");
    }

    // Shift array to the right circularly by k positions
    static int[] shiftArray(int[] array, int k) {
        int[] resultArray = array.clone();

        int temp, previous;
        for (int i = 0; i < k; i++) {
            previous = resultArray[array.length - 1];
            for (int j = 0; j < resultArray.length; j++) {
                temp = resultArray[j];
                resultArray[j] = previous;
                previous = temp;
            }
        }

        return resultArray;
    }

    static class InsertionSort {

        static int insertionSort(int[] array) {
            int swapCount = 0;

            for (int i = 1; i < array.length; i++) {
                int key = array[i];
                int j = i - 1;
                while (j >= 0 && array[j] > key) {
                    array[j + 1] = array[j];
                    j--;
                    swapCount++;
                }

                array[j + 1] = key;
            }

            return swapCount;
        }
    }
}

The output:

Theoritical Time Complexity based on formula: 21 - Swap Count: 21 - Is formula correct:true

I've tried on array sized 2^16 and shifted it 2^16-1 times, each time the formula was correct.

The time complexity we found is not an upper bound or lower bound, it is the exact tight bound for this case. Therefore it is Theta. Θ((nk)k) .