选择 插入 快速 冒泡排序算法的比较

测试的效率：

1.快速排序 >直接 插入排序 >选择排序 >冒泡排序

算法描述：

①快速排序：暂时留着

②直接插入排序：将待排序的数据分为两组，一组是排序的，一组是未排序的。然后选择没有排序的一个元素往已经排序的数据中插入。直到排序完截止。

3.选择排序：每次选出一个最小的，然后和最初比较的进行交换。

④冒泡排序：相邻的两个元素进行比较，然后交换。如果某次排序中没有交换则停止。

void Sort: :QuickSort(int a[], int p, int r)
 {
    if (p < r)
    {
        int q = Partition(a, p, r);
        QuickSort(a, p, q - 1);
        QuickSort(a, q + 1, r);

    }

}


int Sort: :Partition(int a[], int p, int r)
 {
    int x = a[r];
    //通常，拿最后一个值，作为预期的中间值
    int middle = p;
    //记录“较小的一段数据”的最大下标。通常这个值在p和r的中间，故起名middle
    for (int j = p; j < r; j++) {
        if (a[j] < x)
        {
            if (j != middle)
            {
                int temp = a[middle];
                a[middle] = a[j];
                a[j] = temp;

            }
            middle++;

        }

    }
    int temp = a[r];
    a[r] = a[middle];
    a[middle] = temp;
    return middle;

}
//插入排序
void Sort: :InsertSort(int iList[], int iNum)
 {
    int iTemp,
    j;
    for (int i = 1; i < iNum; i++)
    {
        iTemp = iList[i];
        for (j = i; j > 0 && iList[j - 1] > iTemp; j--)
        {
            iList[j] = iList[j - 1];

        }
        iList[j] = iTemp;

    }

}
//冒泡排序算法
void Sort: :BubleSort(int iList[], int iNum)
 {
    int iTemp;
    bool bChange = true;
    for (int i = 0; (i < iNum - 1) && bChange; ++i)
    {
        bChange = false;
        for (int j = 0; j < iNum - 1 - i; ++j)
        {
            if (iList[j] > iList[j + 1])
            {
                SWAP(iList[j], iList[j + 1], iTemp);
                bChange = true;

            }

        }

    }

}
//选择排序算法
void Sort: :SelectSort(int iList[], int iNum)
 {
    int iTemp,
    iMin;
    for (int i = 0; i < iNum; ++i)
    {
        iMin = i;
        for (int j = i + 1; j < iNum; ++j)
        {
            if (iList[iMin] > iList[j])
            {
                iMin = j;

            }

        }
        SWAP(iList[iMin], iList[i], iTemp);

    }

}