直接插入排序和冒泡排序比较

直接插入排序 ：

---

思想：将数组中的所有元素依次和前面的已经排好序的元素相比较（依次），如果选择的元素比已排序的元素小，则交换，直到全部元素都比较过。

代码实现：

Sort.h:

#pragma once

#include <iostream>
using namespace std;

#include <assert.h>


//直接插入排序
 void InsertSort (int* a,size_t n)
 {
     assert(a);
     for(size_t i = 1;i < n; ++i)//用end的位置控制边界
     {
         //单趟排序
         int end = i - 1 ;
         int tmp = a[i];
         while( end >= 0 )//循环继续条件
         {
             if( a[end] > tmp )
             {
                 a[end+1] = a[end];
                 --end;
             }
             else
                 break;
         }
         a[end+1] = tmp;
     }
 }

test.cpp :

#include "Sort.h"

 void Print(int a[],int len)
{
    for(int i = 0; i < len; ++i)
    {
        cout<<a[i]<<" ";
    }
    cout<<endl;
}

 void test()
 {
     //升序排序
     int a [] = {2,5,7,6,12,4,3,9,0};
     int len = sizeof(a)/sizeof(a[0]);
     cout<<"before sort :";
     Print(a,len);

     InsertSort(a,len);
     cout<<"after sort :";
     Print(a,len);

 }
int main ()
{
    test();
    return 0;
}

冒泡排序 ：

---

基本思想就是：从无序序列头部开始，进行两两比较，根据大小交换位置，直到最后将最大（小）的数据元素交换到了无序队列的队尾，从而成为有序序列的一部分；下一次继续这个过程，直到所有数据元素都排好序。

算法的核心在于每次通过两两比较交换位置，选出剩余无序序列里最大（小）的数据元素放到队尾。

代码实现：

void BubbleSort(int* a,size_t n)
{
    assert(a);
    size_t end = n;
    int exchange = 0;
    while( end > 0 )//end作为每趟排序的终止条件
    {
        for( size_t i = 1; i < end ; ++i )
        {
            if( a[i-1] > a[i] )
            {
                swap(a[i-1],a[i]);
                exchange = 1;
            }
        }
        if( 0 == exchange )//数组本身为升序，如果一趟排序结束，并没有进行交换，那么直接跳出循环（减少循环次数，升高效率）
            break;
        --end;
    }
}

直接插入排序和冒泡排序比较(哪个更优) ：

---

1. 两者的时间复杂度和空间复杂度还有稳定性相同

2 .插入排序相比较来说更优：

像这种特殊情况时，直接插入排序总共比较了n次；e而冒泡排序比较了（n-1）+（n-2）次。