算法复习笔记01：插入排序

插入排序

最近研一算法课老师讲到插入排序，自己课后进行了总结并且选取力扣部分习题练习，在此进行总结。
插入排序是一种稳定的排序，它的时间开销与输入规模、输入序列的特性有关
最佳运行时间：输入数组已经排好序
最差运行时间：问题最终要求按递增的顺序排列，但输入数组按递减顺序排列
时间复杂度：O(n²)
插入排序的python代码（从第i个元素开始向前比较，如果小于前一个元素，交换位置）

def insertsort(list):
   for i in range(1,len(list)):
       j=i-1
       for j in range(j,0,-1):
           if(list[j]<list[i]):
              list[j],list[j-1]=list[j-1],list[j]

def insertionSort(arr): 
    for i in range(1, len(arr)): 
        key = arr[i] 
        j = i-1
        while j >=0 and key < arr[j] : 
                arr[j+1] = arr[j] 
                j -= 1
        arr[j+1] = key 

优化：

def insertsort(list):
   for j in range(1,len(list)):
      i=j
      while i>0:
         if list[i]<list[i-1]:
            list[i],list[i-1]=list[i-1],list[i]
            i--
        else:
           break

链表的插入排序（力扣147：对链表进行插入排序）

方法一：将链表转化为数组，数组进行插入排序，再将数组转化为链表，空间复杂度过高。

class Solution {
public:
    ListNode* insertionSortList(ListNode* head) {
        if(head->next==nullptr){
            return head;
        }
        ListNode* p=head;
        ListNode* q=head;
        vector<int>temp;
        while(head!=nullptr){
            temp.push_back(head->val);
            head=head->next;
        }
        for(int i=1;i<temp.size();i++){
            int key=temp[i];
            int j=i-1;
            while(j>0&&temp[j]<key){
                temp[j+1]=temp[j];
                j--;            
            }
            temp[j+1]=key;
        }
        sort(temp.begin(),temp.end());
        for(int i=0;i<temp.size();i++){
            p->val=temp[i];
            p=p->next;
        }
        return q;
    }
};

方法二：直接针对链表进行插入排序

class Solution {
public:
    ListNode* insertionSortList(ListNode* head) {
        if(head==nullptr)
        {
            return head;
        }
        ListNode* dummyHead=new ListNode(0);
        dummyHead->next=head;
        ListNode* last=head;
        ListNode* cur=head->next;
        while(cur!=nullptr){
            if(cur->val>last->val){
                last=last->next;
            }
            else{
                ListNode* pre=dummyHead;
                while(pre->next->val<cur->val)//从头结点开始找到可以插入的位置
                {
                    pre=pre->next;
                }
                last->next=cur->next;
                cur->next=pre->next;
                pre->next=cur;
            }
            cur=last->next;
        } 
        return dummyHead->next;
    }
};