直接插入排序，折半查找，希尔排序，归并方法

直接插入排序
在排序的过程中，记录序列R[1..n]的状态为：
-----------------------------------------
有序序列R[1..(i-1)] R[i] 无序序列R[(i+1)..n]
-----------------------------------------
基本思想：将记录R[i]插入倒有序子序列R[1..i-1]中，使记录的有序序列从R[1..i-1]到R[1..i]
算法实现：

int main(){
   //int a[] = {9,8,7,6,5,4,3,2,1,0};
    //BinSort(a,10);
    //StrInsSort1(a,10);
    //StrInsSort(a,10);
   retrun 0;  
}

void StrInsSort(int R[],int size){
    //本算法对R［0，，size-1］进行直接插入排序
    for(int i = 1;i<size;i++){//假定地一个记录有序
        //i表示的待比较的元素，我们会对每一个元素进行比较，因此比较 i<size
        int temp = R[i];
        int j = i-1;
        while(j>=0 && temp<R[j]){
            //从后向前查找插入位置，同时将大于待排序记录的元素向后移动；
            R[j+1] = R[j];
            j--;
        }
        R[j+1] = temp;//将待排序元素放到合适的位置
        //while循环外的j表示大于R［j］小于或等于temp，
        //所以temp的位置应该j的后一个位置，即j+1的位置
    }
    for(int i = 0;i<size;i++){
        printf("%d\n",R[i]);
    }
}

 

上面的while循环中的j>=0为了避免向前查找合适位置而导致j值超出数组界限，
可以使用监视哨来改建算法，减少循环中比较的次数；--》我们可以利用摸个元素来存放当前待排序记录，来达到避免数组超界和减少比较次数的目的

void StrInsSort1(int a[],int size){
    //使用监视哨，减少循环比较的次数
    //监视哨，就是利用数组的某个元素来存放当前待排序记录，
    //来达到避免数组越界和减少比较次数
    //int *A = (int*)malloc(sizeof(int)*(size+1));
    int A[size+1];
    A[0] = 0;
    for(int i = 1;i<=size;i++){
        A[i] = a[i-1];
    }
    //A[0]
    for(int i = 1;i<=size;i++){
        A[0] = A[i];
        int j = i-1;
        while(A[0]<A[j]){
            A[j+1] = A[j];
            j--;
        }
        A[j+1] = A[0];
    }

    for(int i = 1;i<=size;i++){
        printf("%d\n",A[i]);
    }
}

=======================

折半排序算法
基本思想：在直接插入排序算法中，当第i个记录要插入倒前面i-1个记录序列中，可利用折半查找的方式来确定插入位置，减少比较次数；
关键点：边界值的选取！！！----》1，选择插入点 2，移动数据 3，插入第i个记录
算法：

void BinSort(int R[],int size){
    //直接插入排序，当n很小时，较为适用，但是当n较大时，效率不高
    //将第i个元素插入到前i-1个有序的序列时，折半查找
    //对R［1，，n］进行这般查找
    for(int i = 1;i<size;i++){//假定第一个元素有序
        int temp = R[i];
        int low = 0;
        int high = i-1;
        while(low <= high){
            int m = (low+high)/2;//折半
            if(temp<R[m])
                high = m-1;//插入点低半区----这里是关键，跳出while的地方，low>high
            else
                low = m+1;
        }
        int j = i-1;
        while(j>=high+1){
            R[j+1] = R[j];
            j--;
        }
        //在这里想一想，low<=high意味着什么
        //意味着low>high，所以插入点应该在high的某一侧（就是high的右侧，high+1的位置）
        //到底是那一侧呢？我们得看一看吧；
        //关键点在high = m-1这一句
        R[j+1] = temp;
        //R[high+1] = temp
    }
    for(int i = 0;i<size;i++){
        printf("%d\n",R[i]);
    }
}

模式记忆：
在排序数组a[0,1..n]中利用折半方式搜索某个数target，
low = 0;(下标表示)
high = n;(下标表示，不考虑元素个数)
while(low<=high){
　　mid = low+(high-1ow)/2;
　　if(target<a[mid])
　　　　high = mid-1;//target在低半区
　　else if(target>a[mid])
　　　　low = mid+1;//target在高半区
　　else
　　　　return mid;//find the solution!!!
}
while循环结束后，如果low>high，那么target应该在high的右侧，就是high+1的位置
如果low==high，那么target就在mid的位置；
我们照这上面的分析写一个查找算法例子：

int main(){
    int a[100];
    for(int i = 0;i<100;i++){
        a[i] = i;
    }
    int low,high,mid;
    double target;
    low = 0;
    high = 100;
    cout<<"input>>";
    cin>>target;
    while(low<=high){
        mid = low + (high-low)/2;
        if(target<a[mid]){
            high = mid-1;//target at the low-part
        }else if(target>a[mid]){
            low = mid+1;//target at the high-part
        }else{
            cout<<"a[mid]="<<mid<<endl;
            cout<<"high="<<high<<endl;
            cout<<"low="<<low<<endl;
            break;//find the solution;
        }
    }
    cout<<"high="<<high<<endl;
    cout<<"low="<<low<<endl;
    return 0;
}

执行结果:

input>>45
a[mid]=45
high=45
low=45
============
input>>23.5
high=23//表示23.5应该在high的右侧，就是a[high+1]=a[24]的位置
low=24

 

 

------------------------------------------
希尔排序（缩小增量排序）：
思想：当待排序记录个数较少，并且待排记录基本有序；
1，将待排序的记录划分为几组，从而减少参与直接排序的数据量
2，当经过几次分组排序后，记录的排序已经基本有序，再对所有的记录实施最后的直接插入排序；

========
归并排序的归并方法：
很经典的while循环

/*
 * meger.h
 *
 *  Created on: Apr 12, 2016
 *      Author: lizhen
 */

#ifndef MEGER_H_
#define MEGER_H_
#include <vector>
using namespace std;
class Solution {
public:
    double meger(vector<int>& nums1, vector<int>& nums2) {
        vector<int> result;
        int lengtha = nums1.size();
        int lengthb = nums2.size();
        int i = 0,j = 0;
        for(;i<lengtha && j<lengthb;){
            if(nums1[i]<=nums2[j]){
                result.push_back(nums1[i++]);
            }else{
                result.push_back(nums2[j++]);
            }
        }//for
        for(;i<lengtha;){
            result.push_back(nums1[i++]);
        }
        for(;j<lengthb;){
            result.push_back(nums2[j++]);
        }
        vector<int>::iterator vit = result.begin();
        for(;vit!=result.end();){
            cout<<*vit++<<" ";
        }cout<<endl;
        return -1;
    }
};
#endif /* MEGER_H_ */

main函数

/*
 * main.cpp
 *
 *  Created on: Apr 9, 2016
 *      Author: lizhen
 */
#include <iostream>
#include <vector>
//#include "listnode.h"
//#include "remoelistd2.h"
//#include "searchRotatedSA2.h"
//#include "findMiniRotatedSortedArray2.h"
//#include "medianTwoSortArray.h"
#include "meger.h"
using namespace std;
int main(){
    vector<int> vit1 = {1,2,3,4};
    vector<int> vit2 = {1,2,3,4};
    Solution s;
    cout<<s.meger(vit1,vit2)<<endl;
    return 0;
}