几大常见的算法

几大算法的实现程序：

1.直接插入
原理：第一个for循环对从第二个开始的所有的数字遍历，嵌套的for循环是每次遍历数字时都取无序区的一个元素与有序区的元素比较，如果比有序区的要小则交换，直到合适的位置。

void InsertSort(int arr[],int n)
{
    for (int i =1;i <= n;++i)
    {
        for(int j = i;j > 0;--j)
        {
            if(arr[j] < arr[j -1])
            {
                int temp = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = temp;
            }
        }
    }
}

改进之后引进了vector(矢量)：
Vector类 是在 java 中可以实现自动增长的对象数组，vector在C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。

void InsertSort2(vector<int> &num)
{
    for(int i = 1;i < num.size();++i)
    {
        for(int j = i;j > 0;--j)
        {
            if(num[j] < num[j - 1])
            {
                int temp = num[j];
                num[j] = num[j-1];
                num[j-1] = temp;
            }
        }
    }
}

2.冒泡排序
原理：第一个for循环是遍历所有元素，第二个for循环是每次遍历元素时都对无序区的相邻两个元素进行一次比较，若反序则交换

void BubbleSort(int arr[], int len)
{
 int i,temp;
 //记录位置，当前所在位置和最后发生交换的地方
 int current,last = len - 1;
 while(last > 0) 
 {
  for(i = current = 0;i < last;++i)
  {
   if(arr[i] > arr[i+1])
   {
    temp = arr[i];
    arr[i] = arr[i+1];
    arr[i+1] = temp;
    //记录当前的位置，如果没有发生交换current值即for循环初始化的0
    current = i;
   }
  }
  //若current = 0即已经没有可以交换的元素了，即已经有序了
  last = current;
 }
}

3.快速排序
原理：将待排序记录划分成独立的两部分，左侧的元素均小于轴值，右侧的元素均大于或等于轴值，然后对这两部分再重复，直到整个序列有序，过程是和二叉搜索树相似，就是一个递归的过程。
排序函数

void OnceSort(int arr[], int first, int end)
    {
        int i = first, j = end;
        //当i<j即移动的点还没到中间时循环
        while (i < j)
        {
            //右边区开始，保证i<j并且arr[i]小于或者等于arr[j]的时候就向左遍历
            while (i < j && arr[i] <= arr[j])
                --j;
            //这时候已经跳出循环，说明j>i 或者 arr[i]大于arr[j]了，如果i<j那就是arr[i]大于arr[j]，那就交换
            if (i < j)
            {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
            //对另一边执行同样的操作
            while (i < j && arr[i] <= arr[j])
                ++i;
            if (i < j)
            {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        //返回已经移动的一边当做下次排序的轴值
        return i;
    }

4.堆排序
原理：堆的结构类似于完全二叉树，每个结点的值都小于或者等于其左右孩子结点的值，或者每个节点的值都大于或等于其左右孩子的值，堆排序过程将待排序的序列构造成一个堆，选出堆中最大的移走，再把剩余的元素调整成堆，找出最大的再移走，重复直至有序来看一下实现程序：

void max_heapify(int data[], int i, int heapsize)
//以某个节点为根节点的子树进行调整，调整为大顶堆
{
    int l = 2 * i + 1;
    int r = 2 * i + 2;
    int largest = i;
    if (l<heapsize&&data[l]>data[i])
    {
        largest = l;
    }
    if (r<heapsize&&data[r]>data[largest])
    {
        largest = r;
    }
    if (largest != i)
    {
        int temp = data[largest];
        data[largest] = data[i];
        data[i] = temp;
        max_heapify(data, largest, heapsize);
    }
}

//建堆的过程，通过自底向上地调用max_heapify来将一个数组data【1……n】变成一个大顶堆，
//只需要对除了叶子节点以外的节点进行调整
void bulid_max_heap(int data[], int heapsize)

{　　　　　　　　　　　　　　　　　　　　　　　　　
    for (int i = heapsize / 2 - 1; i >= 0; i--)
        max_heapify(data, i, heapsize);
}

//堆排序算法实现主体：先用bulid_max_heap将输入数组构造成大顶堆，
//然后将data【0】和堆的最后一个元数交换，继续进行调整。
void heap_sort(int data[], int heapsize）
{　　　　　　　　　　　　　　　　　　　　　　　
    bulid_max_heap(data, heapsize);
    for (int i = heapsize - 1; i>0; i--)
    {
        int t = data[0];
        data[0] = data[i];
        data[i] = t;
        max_heapify(data, 0, i);

    }
}

5.归并排序
原理：归并排序的基本思想是将若干个序列进行两两归并，直至所有待排序记录都在一个有序序列为止

void Merge(int arr[], int reg[], int start, int end) {
    if (start >= end)return;
    int len = end - start, mid = (len >> 1) + start;
    //分成两部分
    int start1 = start, end1 = mid;
    int start2 = mid + 1, end2 = end;
    //然后合并
    Merge(arr, reg, start1, end1);
    Merge(arr, reg, start2, end2);


    int k = start;
    //两个序列一一比较,哪的序列的元素小就放进reg序列里面,然后位置+1再与另一个序列原来位置的元素比较
    //如此反复,可以把两个有序的序列合并成一个有序的序列
    while (start1 <= end1 && start2 <= end2)
        reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];

    //然后这里是分情况,如果arr2序列的已经全部都放进reg序列了然后跳出了循环
    //那就表示arr序列还有更大的元素(一个或多个)没有放进reg序列,所以这一步就是接着放
    while (start1 <= end1)
        reg[k++] = arr[start1++];

    //这一步和上面一样
    while (start2 <= end2)
        reg[k++] = arr[start2++];
    //把已经有序的reg序列放回arr序列中
    for (k = start; k <= end; k++)
        arr[k] = reg[k];
}

void MergeSort(int arr[], const int len) {
    //创建一个同样长度的序列,用于临时存放
    int  reg[len];
    Merge(arr, reg, 0, len - 1);
}

上面代码都有注释，可以理解的很好啦。