八大排序算法对比

vectorInsertSort(vectornums)
{
for (int i = 1; i < nums.size(); i++)
{
int j = i;
int temp;
while (j >= 1)
{
if (nums[j] < nums[j - 1])
{
temp = nums[j - 1];
nums[j - 1] = nums[j];
nums[j] = temp;
}
j–;
}
}
return nums;
}
vectorShellSort(vectornums)
{
int gap = nums.size() / 2;
while (gap >= 1)
{
for (int i = gap; i < nums.size(); i++)
{
int j = i;
int temp;
while (j >= gap)
{
if (nums[j] < nums[j - gap])
{
temp = nums[j - gap];
nums[j - gap] = nums[j];
nums[j] = temp;
}
j = j - gap;
}
}
gap /= 2;
}
return nums;
}
vectorBubbleSort(vectornums)
{
for (int i = 0; i < nums.size(); i++)
{
int temp;
for (int j = nums.size() - 1; j>i; j–)
{
if (nums[j] < nums[j - 1])
{
temp = nums[j];
nums[j] = nums[j - 1];
nums[j - 1] = temp;
}
}
}
return nums;
}
vectorSelectionSort(vectornums)
{
for (int i = 0; i < nums.size(); i++)
{
int temp;
for (int j = i + 1; j < nums.size(); j++)
{
if (nums[j] < nums[i])
{
temp = nums[j];
nums[j] = nums[i];
nums[i] = temp;
}
}
}
return nums;
}
vectorQuickSort(vectornums)
{
if (nums.size() <= 1)
return nums;
int i = 1;
int j = nums.size() - 1;
int temp = nums[0];
int p = 0;
while (i < j)
{
if (nums[i]>temp)
{
if (nums[j] > temp)
j–;
else
{
int temp2;
temp2 = nums[i];
nums[i] = nums[j];
nums[j] = temp2;
j–;
}
}
else
{
if (nums[j] >= temp)
j–;
else
i++;
}
}
vectortempV = { nums[0] };
if (nums[0] > nums[i])
{
int temp2 = nums[0];
nums[0] = nums[i];
nums[i] = temp2;
p = i;
}
vectornums1;
vectornums11;
nums1.assign(nums.begin(), nums.begin() + p);
vectornums2;
vectornums22;
nums2.assign(nums.begin() + p + 1, nums.end());
nums11 = QuickSort(nums1);
nums22 = QuickSort(nums2);
vectornums3;
nums3.insert(nums3.end(), nums11.begin(), nums11.end());
nums3.insert(nums3.end(), tempV.begin(), tempV.end());
nums3.insert(nums3.end(), nums22.begin(), nums22.end());
return nums3;
}
void QuickSortAddress(vector&nums, int left, int right)
{
if (right > left)
{
int i = left + 1;
int j = right;
int temp = nums[left];
int p = left;
while (i < j)
{
if (nums[i]>temp)
{
if (nums[j] > temp)
j–;
else
{
int temp2;
temp2 = nums[i];
nums[i] = nums[j];
nums[j] = temp2;
j–;
}
}
else
{
if (nums[j] >= temp)
j–;
else
i++;
}
}
if (nums[left] > nums[i])
{
int temp2 = nums[left];
nums[left] = nums[i];
nums[i] = temp2;
p = i;
}
QuickSortAddress(nums, left, p - 1);
QuickSortAddress(nums, p + 1, right);
}
}
vectorHeapSort(vectornums)
{
HeapBuild(nums);
for (int i = 0; i < nums.size(); i++)
{
int temp;
temp = nums[0];
nums[0] = nums[nums.size() - 1 - i];
nums[nums.size() - 1 - i] = temp;
HeapPop(nums, i + 1, (nums.size() - 1 - i) / 2,1);
}
reverse(nums.begin(), nums.end());
return nums;
}
void HeapBuild(vector&nums)
{
int n = nums.size();
int m = n / 2;
for (int i = m; i >= 1; i–)
{
HeapPop(nums, 0, m,i);
}
}
void HeapPop(vector&nums, int K, int M,int start)
{
int n = nums.size() - K;
int m = M;
int i = start;
while (i <= m)
{
if (n % 2 == 0 && i == m)
{
if (nums[2 * i - 1] < nums[i - 1])
{
int temp;
temp = nums[2 * i - 1];
nums[2 * i - 1] = nums[i - 1];
nums[i - 1] = temp;
}
i = i * 2;
}
else
{
if (nums[i - 1] > nums[2 * i] || nums[i - 1] > nums[2 * i - 1])
{
if ((nums[i - 1]<=nums[2 * i] && nums[i - 1]>nums[2 * i - 1]) || (nums[i - 1]>nums[2 * i] && nums[2 * i]>nums[2 * i - 1]))
{
int temp = nums[2 * i - 1];
nums[2 * i - 1] = nums[i - 1];
nums[i - 1] = temp;
i = i * 2;
}
else
{
int temp = nums[2 * i ];
nums[2 * i ] = nums[i - 1];
nums[i - 1] = temp;
i = i * 2+1;
}

            }
            else
                i = 2*i;
        }
    }
}
vector<int>RadixSort(vector<int>nums)
{
    int maxZ = 0;
    int maxF = 0;
    vector<int>Z;
    vector<int>F;
    for (int i = 0; i < nums.size(); i++)
    {
        if (nums[i] >= 0)
        {
            maxZ = max(maxZ, nums[i]);
            Z.push_back(nums[i]);
        }
        else
        {
            maxF = min(maxF, nums[i]);
            F.push_back(nums[i]);
        }
    }
    int countZ = 1;
    int countF = 1;
    if (maxZ == 0)
        countZ = 0;
    if (maxF == 0)
        countF = 0;
    while (maxZ >= 1)
    {
        vector<vector<int> >Z10(10);
        maxZ = maxZ / 10;
        for (int i = 0; i < Z.size(); i++)
        {
            int a = pow(10, (countZ - 1));
            int b = Z[i] / a;
            int c = b % 10;
            Z10[c].push_back(Z[i]);
        }
        Z.clear();
        for (int j = 0; j < 10; j++)
        {
            for (int k = 0; k < Z10[j].size(); k++)
                Z.push_back(Z10[j][k]);
        }
        countZ++;
    }
    while (maxF <= -1)
    {
        vector<vector<int> >F10(10);
        maxF = maxF / 10;
        for (int i = 0; i < F.size(); i++)
        {
            int a = pow(10, (countF - 1));
            int b = F[i] / a;
            int c = b % 10 + 9;
            F10[c].push_back(F[i]);
        }
        F.clear();
        for (int j = 0; j < 10; j++)
        {
            for (int k = 0; k < F10[j].size(); k++)
                F.push_back(F10[j][k]);
        }
        countF++;
    }
    vector <int>re;
    re.insert(re.end(), F.begin(), F.end());
    re.insert(re.end(), Z.begin(), Z.end());
    return re;
}
vector<int> MergeSortStep2(vector<int> a)
{
    int n = a.size();
    MergeSortStep1(a, 0, n);
    return a;
}
void MergeSortStep1(vector<int> &a, int first, int last)
{

    if (first < last)
    {
        if (last - first == 1)
        {
            //temp = a;
        }
        else
        {
            int mid = (first + last) / 2;
            MergeSortStep1(a, first, mid);
            MergeSortStep1(a, mid , last);
            MergeSortedNum(a, first, mid, last); //再将二个有序数列合并
        }
    }       
}

void MergeSortedNum(vector<int>&nums, int left, int middle,int right)
{
    if (right>left)
    {
        vector<int>temp;
        int i = left;
        int j = middle;
        while (i <middle&&j < right)
        {
            if (nums[i] < nums[j])
            {
                temp.push_back(nums[i]);
                i++;
            }
            else
            {
                temp.push_back(nums[j]);
                j++;
            }
        }
        if (i == middle  && j < right)
        {
            for (int k = j; k < right;k++)
                temp.push_back(nums[k]);
        }
        if (j == right  && i < middle)
        {
            for (int k = i; k < middle;k++)
                temp.push_back(nums[k]);
        }
        for (int i = left; i < right; i++)
            nums[i] = temp[i - left];
    }
}