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 链表插入排序