冒泡、选择、插入、归并、快速排序代码

原理请查看：http://wuchong.me/blog/2014/02/09/algorithm-sort-summary/

冒泡排序

void bubble_sort(int * array, int len)
{
    int tmp;

    for (int i=0; i<len; ++i)
    {
        for (int j=0; j<(len-i-1); ++j)
        {
            if(array[j+1] < array[j])
            {
                //tmp = array[j+1];
                //array[j+1] = array[j];
                //array[j] = tmp;
                swap(array[j+1], array[j]);
            }
        }
    }
}

---

选择排序

void selection_sort(int * array, int len)
{
    int tmp;
    int k = 0;

    for (int i=0; i<len; ++i)//从第一个数值开始遍历
    {
        k = i;
        tmp = array[i];
        for (int j=i+1; j<len; ++j)//循环找出最小数值
        {
            if (tmp > array[j])
            {
                tmp = array[j];
                k = j;
            }
        }
        if (i != k)//有找到最小数值，则数据进行交换
        {
            //array[k] = array[i];
            //array[i] = tmp;
            swap(array[k], array[i]);
        }
    }
}

---

插入排序

void insertion_sort(int * array, int len)
{
    int tmp;

    for (int i=1;i<len;++i)//插入数值遍历
    {
        tmp = array[i];
        for (int j=i-1;j>=0;--j)//以自己一下的数值一个一个比较
        {
            if (array[j] <= tmp)//当比自己大于或等于数据，则插入这个数值前面
            {
                array[j+1] = tmp;
                break;
            }
            else//当比自己小数值，则将数值向前移动一位
            {
                array[j+1] = array[j];
            }

            if(0 == j)//如果比较到最后一个，直接插入自己值。
            {
                array[j] = tmp;
            }
        }

    }
}

---

归并排序

void Merge(int *vi, int low, int mid, int up)
{
#if 0
    int n1 = mid-low+1;
    int n2 = up-mid;
#else
    int n1 = mid-low;
    int n2 = up-mid+1;
#endif
    int *L = new int[n1+1];
    int *R = new int[n2+1];
    int i, j, k;

//  for (i=0; i<n1; i++){
//      L[i] = vi[low+i];
//  }
//  for (j=0; j<n2; j++){
//      R[j] = vi[mid+j+1];
//  }
#if 0
    memcpy(L, &vi[low], n1*sizeof(int));
    L[n1] = 0x7fffffff;

    memcpy(R, &vi[mid+1], n2*sizeof(int));
    R[n2] = 0x7fffffff;
#else
    memcpy(L, &vi[low], n1*sizeof(int));
    L[n1] = 0x7fffffff;

    memcpy(R, &vi[mid], n2*sizeof(int));
    R[n2] = 0x7fffffff;
#endif

    for (i=0, j=0, k=low; k<=up; k++)
    {
        if (L[i]<=R[j])
        {
            vi[k] = L[i];
            i++;
        }
        else
        {
            vi[k] = R[j];
            j++;
        }
    }

    delete []L;
    delete []R;
}

void MergeSort(int *vi, int low, int up)
{
    if (low < up)
    {
        int mid = (low+up)/2;
        MergeSort(vi, low, mid);
        MergeSort(vi, mid+1, up);
        Merge(vi, low, mid, up);
    }
}

int main()
{
    int array[] = {2,8,7,1,0,10,3};
    int len = sizeof(array);
    MergeSort(array, 0, len-1);
    return 0;
}

---

快速排序

int partition(int * vi, int low, int up)
{
    int pivot = vi[up];
    int i = low;
    for (int j = low; j < up; j++)
    {
        if(vi[j] <= pivot)
        {
            swap(vi[i], vi[j]);
            i++;
        }
    }
    swap(vi[i], vi[up]);//交换位置，防止同一个位置做基准
    return i;
}

//C++'s array range should be [low, up], the same as [low, up+1)
void quickSort(int * vi, int low, int up)
{
    if(low < up)
    {
        int mid = partition(vi, low, up);
        //mid这个值已经做为基准了，所以后面用mid-1和mid+1;
        //Watch out! The mid position is on the place, so we don't need to consider it again.
        //That's why below is mid-1, not mid! Otherwise it will occur overflow error!!!
        quickSort(vi, low, mid-1);
        quickSort(vi, mid+1, up);
    }
}

int main()
{
    int array[] = {2,8,7,1,0,10,3};
    int len = sizeof(array);
    quickSort(array, 0, len-1);
    return 0;
}