02插入排序

1.基本思想

不斷將沒有排好序的數插入到排好序的數組中。
對數組 [2, 1, 7, 9, 5, 8] 進行插入排序。

2.C++代碼實現

#include <iostream>
using namespace std;

//插入排序
void insertionSort(int arr[], int n) {
	int i, key, j;
	for (i = 1; i < n; ++i) {
		key = arr[i];//記錄當前值
		for (j = i - 1; j >= 0 && arr[j] > key; --j) {
			arr[j + 1] = arr[j];//如果arr[j]大於key，則將arr[j]向後移動一位
		}
		arr[j + 1] = key;//將當前值插入到正確的位置
	}
}

//顯示數組
void printArr(int arr[], int size) {
	for (int i = 0; i < size; ++i) {
		cout << arr[i] << " ";
	}
	cout << endl;
}

int main()
{
	int arr[] = { 2, 1, 7, 9, 5, 8 };
	int n = sizeof(arr) / sizeof(arr[0]);//計算數組大小

	cout << "排序前";
	printArr(arr, n);

	insertionSort(arr, n);

	cout << "排序前";
	printArr(arr, n);

	system("pause");
	return 0;
}

輸出

排序前2 1 7 9 5 8
排序前1 2 5 7 8 9
請按任意鍵繼續. . .

3.算法分析

空間複雜度：O(1)
時間複雜度：O(n*n)

1. 給定的數組按照順序排好。只需要進行n-1次比較，交換的次數爲0，這是最好的情況。
2. 給定的數組按照逆序排列。在這種情況下，需要進行n*(n-1)/2次比較，時間複雜度爲O(n*n)，這是最壞的情況。
3. 給定的數組雜亂無章。在這種情況下，平均時間複雜度爲O(n*n)。
   由此可見，插入排序和冒泡排序一樣，時間複雜度都是O(n*n)，也是一種穩定的排序算法。

4.leetcode練習

LeetCode 第 147 題，要求對一個鏈表進行插入排序。

解題思路：將原鏈表的元素一個一個取出來，然後按照順序插入到新鏈表中。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* insertionSortList(ListNode* head) {
        //思路：將元素從原鏈表中取出來，然後插入新的鏈表中
        //time: O(N*N) space: O(1)
        ListNode* dummy=new ListNode(-1), *cur=dummy;
        while(head){
            ListNode* tmp=head->next;
            cur=dummy;//每次從頭開始遍歷
            while(cur->next && cur->next->val<=head->val){
                cur=cur->next;
            }
            head->next=cur->next;
            cur->next=head;
            head=tmp;
        }
        return dummy->next;
    }
};

5.參考博客

1. Insertion Sort
2. [LeetCode] 147. Insertion Sort List 鏈表插入排序