四种排序算法（冒泡排序、选择排序、归并排序、快速排序）的实现

本文用C++实现了四种基础的排序算法，冒泡排序、选择排序、归并排序、快速排序

#include <bits/stdc++.h>

using namespace std;

void Swap(int* a, int* b)
{
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;
    return;
}

void BubbleSort(int num[], int len, bool flag)
{
    int temp=0, i=0, j=0;

    // If flag is true, ascend sorting.
    // If flag is false, descend sorting.
    if(flag == true)
    {
        for(i = 0; i < len - 1; i++)
        {
            for(j = 0; j < len - 1 - i; j++)
            {
                // Every loop, put the largest of rest elements last.
                if(num[j] > num[j + 1])
                {
                    Swap(num + j, num + j + 1);
                }
            }
        }
    }
    else
    {
        for(i = 0; i < len - 1; i++)
        {
            for(j = 0; j < len - 1 - i; j++)
            {
                if(num[j] < num[j + 1])
                {
                    Swap(num + j, num + j + 1);
                }
            }
        }
    }

}

void SelectionSort(int num[], int len, bool flag)
{
    int temp=0, i=0, j=0, pos=0;

    // if flag is true, ascend sorting.
    // if flag is false, descend sorting.
    if(flag)
    {
        for(i = 0; i < len; i++)
        {
            pos = i;
            for(j = i; j < len; j++)
            {
                // Select the smallest element and put it at the correct position.
                if(num[j] < num[pos])
                {
                    pos = j;
                }
            }
            Swap(num + i, num + pos);
        }
    }
    else
    {
        for(i = 0; i < len; i++)
        {
            pos = i;
            for(j = i; j < len; j++)
            {
                // Select the largest element and put it at the correct position.
                if(num[j] > num[pos])
                {
                    pos = j;
                }
            }
            Swap(num + i, num + pos);
        }
    }
}

void MergeSort(int* num, int len, bool flag)
{
    int i=0, j=0, k=len/2, temp[10];
    if(len == 1) return;
    MergeSort(num, k, flag);
    MergeSort(num + k, len - k, flag);

    // if flag is true, ascend sorting.
    // if flag is false, descend sorting.
    if(flag)
    {
        // Merge and order two different part.
        for(i = 0; i < len; i++)
        {
            if(j < len/2 && k < len)
            {
                if(num[j] < num[k])
                {
                    temp[i] = num[j];
                    j++;
                }
                else if(num[j] >= num[k])
                {
                    temp[i] = num[k];
                    k++;
                }
            }
            else if(j >= len/2)
            {
                temp[i] = num[k];
                k++;
            }
            else if(k >= len)
            {
                temp[i] = num[j];
                j++;
            }
        }
        for(i = 0; i < len; i++)
        {
            num[i] = temp[i];
        }
    }
    else
    {
        // Merge and order two different part.
        for(i = 0; i < len; i++)
        {
            if(j < len/2 && k < len)
            {
                if(num[j] > num[k])
                {
                    temp[i] = num[j];
                    j++;
                }
                else if(num[j] <= num[k])
                {
                    temp[i] = num[k];
                    k++;
                }
            }
            else if(j >= len/2)
            {
                temp[i] = num[k];
                k++;
            }
            else if(k >= len)
            {
                temp[i] = num[j];
                j++;
            }
        }
        for(i = 0; i < len; i++)
        {
            num[i] = temp[i];
        }
    }
}

void QuickSort(int num[], int len, bool flag)
{
    int temp, left=1, right=len-1, pos=0;
    // if flag is true, ascend sorting.
    // if flag is false, descend sorting.
    if(flag)
    {
        if(len == 0 || len == 1) return;
        // Find a position which split the data into two part.
        // on the left of the position, elements are smeller than it.
        // on the right of the position, elements are larger than it.
        while(true)
        {
            while(num[left] <= num[pos] && left < len) left++;
            while(num[right] >= num[pos] && right > 0) right--;
            if(left >= right) break;
            else
            {
                Swap(num + left, num + right);
            }
        }
        Swap(num, num + right);
        pos = right;
        QuickSort(num, pos, flag);
        QuickSort(num + pos + 1, len - pos - 1, flag);
    }
    else
    {
        if(len == 0 || len == 1) return;
        while(true)
        {
            while(num[left] > num[pos] && left < len) left++;
            while(num[right] < num[pos] && right >= 0) right--;
            if(left >= right) break;
            else
            {
                Swap(num + left, num + right);
            }
        }
        Swap(num, num + right);
        pos = right;
        QuickSort(num, pos, flag);
        QuickSort(num + pos + 1, len - pos - 1, flag);
    }
}

int main()
{
    int num[10]={5, 0, 1, 2, 6, 4, 7, 3, 2, 8}, len=10;
    // Ascending sorting.
    BubbleSort(num, 10, true);
    SelectionSort(num, 10, true);
    MergeSort(num, 10, true);
    QuickSort(num, 10, true);
    for(int i = 0; i < 10; i++)
    {
        cout << num[i];
    }
    cout << endl;
    // descending sorting.
    BubbleSort(num, 10, false);
    SelectionSort(num, 10, false);
    MergeSort(num, 10, false);
    QuickSort(num, 10, false);
    for(int i = 0; i < 10; i++)
    {
        cout << num[i];
    }
    return 0;
}