数据结构与算法5---插入排序

 

---

排序（上）——为什么插入排序比冒泡排序更受欢迎？

同为稳定性排序算法，时间复杂度也一样，插入排序的效率比冒泡排序要好，尤其是数据量大的时候，差距更明显。为什么？

冒泡排序移动数据的操作更多，只要是小于后一个元素，就移动一次。所以它的效率低。看测试结果，八万的时候，就是数量级的差距了。

 

插入排序>冒泡排序>选择排序

（数据交换少）>    (选择排序复杂度为一直最差 O（），且不稳定)

---

目录

 

 

插入排序

1.简介 

1.1 算法原理

1.2 优化实现 --flag

1.3  局部变量，数据移动代替swap

---

 

插入排序

对基本有序的数组最好用

稳定

与冒泡排序区别： 冒泡为相邻两数据对比，不符合顺序交换；冒泡排序用于对比的最小数据随时可变。

选择排序从排序开始第二个位置，按照大小顺序依次往前对比，符合时插入并停止，插入的数据是不变的。

1.简介 

       类似在有序的扑克牌中，插入一张牌进去，使之符合之前的顺序。从边界位置依次往前插。

1.1 算法原理

1.      从起始第二位置开始遍历到截止位置
2.     与前数据比较，符合顺序不动，若将不符合 ，交换位置
3.     重复2直到符合顺序时截止

1.2 优化实现 --flag

#include<iostream>
#include<ctime>
#include<algorithm>
#include<string.h>
#include<vector>
using namespace std;

class InsertSort{
public:    
    InsertSort(){};
    ~InsertSort(){};
    
int sort(vector<int>&arr){
    for(int i=1; i<arr.size(); ++i){
        for(int j=i; j>0; --j){
            if(arr[j]<arr[j-1]){
                swap(arr[j],arr[j-1]);
            }else{
                break;
            }
        }
    }
    return 0;
};

void GenRandArr(vector<int> &arr)
{
    srand(time(0));
    for(int i=0; i<arr.size(); ++i){
        arr[i]=rand()%10;
    }
};

void print(const vector<int> &arr)
{
    for(int i=0; i<arr.size(); ++i){
        cout<< arr[i]<<" ";
    }
     cout<<endl;
} 

void compare(vector<int>& arr1, vector<int>&arr2)   
{
    for(int i=0; i<arr1.size(); ++i)
    {
        if(arr1[i]!=arr2[i]){
          cout<<"compare wrong" <<endl;
          return;
        } 
    }
    cout<<"compare right"<<endl;
};
private:   
   void swap(int &a ,int&b){
       int tmp =a;
       a =b;
       b= tmp;
   };
    
    
};

bool cmp(const int &a ,const int &b){
    return (a<b);
}


#define ARR_SIZE 10
int main(){
    vector<int> arr1(ARR_SIZE);
    vector<int> arr2(ARR_SIZE);
    InsertSort Ins;
    Ins.GenRandArr(arr1);
    Ins.print(arr1);
    memcpy((void*)&arr2[0],(void*)&arr1[0], ARR_SIZE*sizeof(int));
    Ins.print(arr2);   
    sort(arr2.begin(), arr2.end() ,cmp);
    Ins.sort(arr1);
    Ins.print(arr1);
    Ins.print(arr2);
    Ins.compare(arr1,arr2);
    
}

1.3  优化局部变量，数据移动代替swap

int sort(vector<int>&arr){
    for(int i=1; i<arr.size(); ++i){
        int index = i;
        for(int j=i; j>0; --j){
            if(arr[i]<arr[j-1]){
                //swap(arr[j],arr[j-1]);
                index = j-1;
            }else{
                break;
            }
        }
        cout<< index<<" "<<i<<endl;
        mov(arr,index,i);
        print(arr);
    }
    return 0;
};

void mov(vector<int> &arr,int index ,int end){
    int tmp = arr[end];
    for(int i=end; i>index; --i){
        arr[i]=arr[i-1];
    }
    arr[index]= tmp;
}

1.4 插入排序减少数据交换次数

int sort(vector<int>&arr){
    int value;
    int j;
    for(int i=1; i<arr.size(); ++i){
        value = arr[i];
        for(j=i; j>0; --j){
            if(value<arr[j-1]){
                arr[j]=arr[j-1];
            }else{
                break;
            }
        }
        arr[j]=value;
    }
    return 0;
};