基础算法

冒泡排序

void bubbeSort(int r[],int n)
{
    int bound,exchange = n-1;
    while(exchange!=0)
    {
        bound = exchange;
        exchange = 0;
        for(int i =0;i<bound;i++){
            if(r[i] >r[i+1]){
                int temp=r[i];
                r[i]=r[i+1];
                r[i+1] =temp;
                exchange =i;
            }
        }
    }
}

选择排序

void selectedSort(int r[],int n)
{
    int i,j,index,temp;
    for(i =0;i<n-1;i++){
        index =i;
        for(j=i+1;j<n;j++){
            if(r[j] < r[index]){
            index =j;
            }
        }
        if(index !=i){
            temp = r[i];
            r[i] = r[index];
            r[index]=temp;
        }
    }
}

快速排序：

划分：选出一个轴值，使得数组左侧全部小于轴值，右侧全部大于轴值。

这样分解成2个子问题：
子问题1：左侧机选选轴值划分
子问题2：右侧继续选轴值划分。
通过递归操作最终实现排序。

int fastSort(int r[],int first , int end){
    int i=first,j=end;
    while(i<j){
        while(i<j && r[i]<=r[j])j--;
        if(i<j){
            int temp;
            temp = r[i];
            r[i]= r[j];
            r[j] = temp;
            i++;
        }
        while(i<j&&r[i]<=r[j])i++;
        if(i<j){
            int temp ;
            temp =r[i];
            r[i] = r[j];
            r[j] = temp;
            j--;
        }
    }
    return i;
}

void test(int r[],int first ,int end){
    int pivot;
    if(first < end){
        pivot = fastSort(r,first,end);
        fastSort(r,first,pivot-1);
        fastSort(r,pivot+1,end);
    }
}

汉诺塔问题:

分治递归想法：
1.单有一个碟子是，直接A—>C
2.多个碟子时，先把n-1个碟子 从A借助C移到到B上，然后再把最后一个从A—>C
3.之后再把剩下的n-1个碟子，从B借助A移动到C上
一直递归，知道n=1为止。

算法：

void hanoi(int n,char A,char B,char C)
{
    if(n == 1)
         cout<< A << "---->" << C <<endl;
     else
         hanoi(n-1,A,C,B);
         cout<< A << "---->" <<C<<endl;
         hanoi(n-1,B,A,C);
}

插入排序

描述：将整个带排序的序列化分成有序区和无序区，初始时有序区为待排序记录序列中的第一个记录，无序区包括所有的剩余带排序的记录。
将无序区的第一个记录插入到有序区的合适位置，从而实无序区减少一个记录，有序区增加一个记录。

重复执行上述操作，知道无序区中没有记录为止。

算法:

void insertSort(int r[] , int n)
{
    int x;
    for(int i=1;i<n;i++){
        x=r[i];
        for(int j=i-1;x<r[j];j--){
            r[j+1] =r[j];
        }
        r[j+1]=x;
    }
}

二分法

int binarySerach(int a[],int n,int data)
{
    int i=0,j=n-1,m;
    while(i<j)
    {
        m=(i+j)/2;
        if(a[m] == data)
            return m;
        else if(a[m] > data)
            j=m-1;
        else
            i=m+1;

    }
    return -1;
}