排序算法C++实现

//*************************
//1. Bubble sort O(n2)
void bubbleSort(int data[], int len)
{
    bool flag;
    for(int i = len - 1; i > 0; --i)
    {
        flag = false;
        for(int j = 0; j < i; ++j)
        {
            if(data[j] > data[j+1])
            {
                swap(data[j], data[j+1]);
                flag = true;
            }
        }
        if(flag == false)
        {
            return;
        }
    }
}
//*******************************
// 2. Select sort O(n2)
void SelectSort(int data[], int len)
{
    int index_min;
    for(int i = 0; i < len - 1; ++i)
    {
        index_min = i;
        for(int j = i + 1; j < len; ++j)
        {
            if(data[j] < data[index_min])
            {
                index_min = j;
            }
        }
        if(i != index_min)
        {
            swap(data[i], data[index_min]);
        }
    }
}
//**********************************
// 3. Insert sort O(n2)
void InsertSort(int data[], int len)
{
    int tmp;
    for(int i = 1; i < len; ++i)
    {
        tmp = data[i];
        int j;
        for(j = i; j > 0 && tmp < data[j-1]; --j)
        {
            data[j] = data[j - 1];
        }
        data[j] = tmp;
    }
}
//**********************************
// 3.1 折半插入排序 O(n2)
// 对于带排序的数据类型移动比较复杂时有效
void BS_SIS(int array[], int len)
{
    int tmp, low, high, mid;
    for(int i = 1; i < len; ++i)
    {
        tmp = array[i];
        low = 0;
        high = i - 1;
        while(low <= high)
        {
            mid = low + (high - low) / 2;
            if(tmp < array[mid])
            {
                high = mid -1;
            }
            else
            {
                low = mid + 1;
            }
        }
        for(int j = i -1; j >= high + 1; --j)
        {
            array[j+1] = array[j];
        }
        array[high+1] = tmp;
    }
}
//**********************************
// 4.(1) QuickSort
void QuickSort2(int *ints, int start, int end)
{
    if(ints == NULL || start < 0 )
    {
        cout << "err" << endl;
    }
    if(start >= end)
    {
        return;
    }
    else
    {
        int i_data = ints[start];
        int i_index = start;
        int i = start, j = end;
        while(i < j)
        {
            while(i < j && i_data < ints[j]){ j--;}
            if(i < j)
            {
                ints[i++] = ints[j];
            }
            while(i < j && ints[i] < i_data){ i++;}
            if(i < j)
            {
                ints[j--] = ints[i];
            }
        }
        ints[i] = i_data;
        QuickSort2(ints, start, i-1);
        QuickSort2(ints, i+1, end);
    }
}
//*****************************************
// 4. (2) QuickSort
void QuickSort(int array[], int start, int end)
{
    int i = start + 1;
    int j = end;
    int tmp = array[start];
    while(i < j)
    {
        if(tmp <= array[j])
        {
            --j;
        }
        if(tmp > array[i])
        {
            ++i;
        }
    }
}
int Partition(int array[], int left, int right)
{
    int i = left + 1;
    int j = right;
    int tmp = array[left];
    while(i < j)
    {
        
    }
}
//***********************************
// 5.Merge Sort
void merge(int array[], int start, int end1, int end2)
{
    int *left = NULL, *right = NULL;
    int len_1 = end1 - start + 1;
    int len_2 = end2 - end1;
    
    left = (int*)malloc(sizeof(int) * len_1);
    right = (int*)malloc(sizeof(int) * len2);
    if(left && right)
    {
        for(int i = 0; i < len_1; ++i)
            left[i] = array[start+i];
        for(int i = 0; i < len_2; ++i)
            right[i] = array[end1+i+1];
            
        int i = 0, j = 0, k = start;
        while(i < len_1 && j < len_2)
        {
            if(left[i] < right[j])
            {
                array[start++] = left[i++];
            }
            else
            {
                array[start++] = right[j++];
            }
        }
        for(; i < len_1; i++)
            array[start++] = left[i];
        for(; j < len_2; j++)
            array[start++] = right[j];
    }
}
void MergeSort(int array[], int start, int end)
{
    if(start < end)
    {
        int mid = ( start + end)/2;
        MergeSort(array, start, mid);
        MergeSort(array, mid + 1, end);
        merge(array, start, mid, end);
    }
}
//**********************************************
// 6. Heap Sort
// 满堆，从[0]开始存东西，
void HeapAdjust(int array[], int start, int size)
{
    int index_max;
    for(int i = start, j = 2*i+1; j < size;)
    {
        if(j + 1 < size)
        {
            if(array[j] < array[j+1])
                index_max = j+1;
            else
                index_max = j;
        }
        else
            index_max = j;
        if(array[i] < array[index_max])
        {
            swap(array[i], array[index_max])
            i = index_max;
            j = i * 2 + 1;
        }
        else
            break;
    }
}
void CreateHeap(int array[], int size)
{
    for(int i = size /2 - 1; i >= 0; --i)
    {
        HeapAdjust(array, i, size);
    }
}
void HeapSort(int array[], int size)
{
    CreateHeap(array, size);
    
    for(int i = size -1; i > 1; --i)
    {
        swap(array[0], array[i]);
        HeapAdjust(array, 0, i);
    }
    swap(array[0], array[1]);
}
//**************************************
// 7.希尔排序
// http://blog.csdn.net/cscmaker/article/details/7392980
//************************************