常用的七种排序算法封装

最近在看排序算法的原理和实现。所以干脆整合了一个类来实现其功能。

头文件内容

#pragma once
#ifndef MYSORT_H
class CMySort
{
public:
    CMySort();
    ~CMySort();
    void BubbleSort(int iNeedSortArry[],int iArrayCount);                //冒泡排序
    void InsertSort(int iNeedSortArry[], int iArrayCount);                //直接插入排序
    void ShellSort(int iNeedSortArry[], int iArrayCount);                //希尔排序
    void StraightSelectSort(int iNeedSortArry[], int iArrayCount);        //直接选择排序(简单选择排序)
    void QuickSort(int iNeedSortArry[], int iLeft, int iRight);            //快速排序

    void HeapAdjust(int iNeedSortArry[], int iParentNodeIndex, int iLength);            //辅助堆排序
    void HeapSort(int iNeedSortArry[], int iArrayCount);                                //堆排序

    void mergearray(int iSortArray[], int ifirst, int iHalf, int ilast, int temp[]);   //辅助归并排序
    void mergesort(int iSortArray[], int ifirst, int ilast, int temp[]);               //辅助归并排序
    bool MergeSort(int iNeedSortArry[], int iArrayCount);                               //归并排序
};
#endif // !MYSORT_H

CPP部分：

#include "MySort.h"
#include <algorithm>
CMySort::CMySort()
{

}

CMySort::~CMySort()
{

}

void CMySort::BubbleSort(int iNeedSortArry[], int iArrayCount)
{
    int iFinalNeedChangeIndex = iArrayCount;
    while (iFinalNeedChangeIndex > 0)
    {
        int k = iFinalNeedChangeIndex;    
        iFinalNeedChangeIndex = 0;
        for (int j = 1; j < k; j++)
        {
            if (iNeedSortArry[j - 1] > iNeedSortArry[j])
            {
                std::swap(iNeedSortArry[j - 1], iNeedSortArry[j]);
                iFinalNeedChangeIndex = j;
            }
        }
    }
}

void CMySort::InsertSort(int iNeedSortArry[], int iArrayCount) 
{
    for (int i = 1; i < iArrayCount; i++)
    {
        for (int j = (i - 1); j >= 0 && iNeedSortArry[j] > iNeedSortArry[j + 1]; j--)
        {
            std::swap(iNeedSortArry[j], iNeedSortArry[j + 1]);
        }
    }
}

void CMySort::ShellSort(int iNeedSortArry[], int iArrayCount)
{
    for (int gap = iArrayCount / 2; gap > 0; gap /= 2)
    {
        for (int i = gap; i < iArrayCount; i++)
        {
            for (int j = i - gap; j >= 0 && iNeedSortArry[j] > iNeedSortArry[j + gap]; j -= gap)
            {
                std::swap(iNeedSortArry[j], iNeedSortArry[j + gap]);
            }
        }
    }
}

void CMySort::StraightSelectSort(int iNeedSortArry[], int iArrayCount)
{
    for (int i = 0; i < iArrayCount; i++)
    {
        int iMinIndex = i; //找最小元素的位置  
        for (int j = (i + 1); j < iArrayCount; j++)
        {
            if (iNeedSortArry[j] < iNeedSortArry[iMinIndex])
                iMinIndex = j;
        }
        std::swap(iNeedSortArry[i], iNeedSortArry[iMinIndex]); //将这个元素放到无序区的开头  
    }
}

void CMySort::mergearray(int iSortArray[], int ifirst, int iHalf, int ilast, int temp[])
{
    int i = ifirst, j = iHalf + 1;
    int m = iHalf, n = ilast;
    int k = 0;

    while (i <= m && j <= n)
    {
        if (iSortArray[i] <= iSortArray[j])
            temp[k++] = iSortArray[i++];
        else
            temp[k++] = iSortArray[j++];
    }

    while (i <= m)
        temp[k++] = iSortArray[i++];

    while (j <= n)
        temp[k++] = iSortArray[j++];

    for (i = 0; i < k; i++)
        iSortArray[ifirst + i] = temp[i];
}

void CMySort::mergesort(int iSortArray[], int ifirst, int ilast, int temp[])
{
    if (ifirst < ilast)
    {
        int iHalf = (ifirst + ilast) / 2;
        mergesort(iSortArray, ifirst, ilast, temp);        //左边有序  
        mergesort(iSortArray, iHalf + 1, ilast, temp);        //右边有序  
        mergearray(iSortArray, ifirst, iHalf, ilast, temp); //再将二个有序数列合并  
    }
}

bool CMySort::MergeSort(int iNeedSortArry[], int iArrayCount)
{
    int *p = new int[iArrayCount];
    if (p == NULL)
        return false;
    mergesort(iNeedSortArry, 0, iArrayCount - 1, p);
    delete[] p;
    return true;
}

void  CMySort::QuickSort(int iNeedSortArry[], int iLeft, int iRight)
{
    if (iLeft >= iRight)//表示已经完成一个组
        return;

    int i = iLeft, j = iRight, iValue = iNeedSortArry[iLeft];
    while (i < j)
    {
        while (i < j && iNeedSortArry[j] >= iValue) // 从右向左找第一个小于x的数  
            j--;
        if (i < j)
            iNeedSortArry[i++] = iNeedSortArry[j];

        while (i < j && iNeedSortArry[i] < iValue) // 从左向右找第一个大于等于x的数  
            i++;
        if (i < j)
            iNeedSortArry[j--] = iNeedSortArry[i];
    }
    iNeedSortArry[i] = iValue;
    QuickSort(iNeedSortArry, iLeft, i - 1); // 递归调用   
    QuickSort(iNeedSortArry, i + 1, iRight);
}

void  CMySort::HeapAdjust(int iNeedSortArry[], int iParentNodeIndex, int iLength)
{
    int iLeft = 2 * iParentNodeIndex + 1;
    while (iLeft <= iLength)
    {    
        int iRight = iLeft + 1;  //右节点
        int j = iLeft;             //j指向左节点
        if (j < iLength && iNeedSortArry[iLeft] < iNeedSortArry[iRight])    //如果右节点大于左节点,把j指向右节点
            j++;    
        if (iNeedSortArry[iParentNodeIndex] < iNeedSortArry[j])                //如果父节点的值比孩子节点小，则将父节点与孩子节点交换（如果上面if为真，则iNeedSortArry[j]为右节点，如果为假iNeedSortArry[j]则为左节点）
            std::swap(iNeedSortArry[iParentNodeIndex], iNeedSortArry[j]);
        else         //说明比孩子节点都大，直接跳出循环语句
            break;
        iParentNodeIndex = j;
        iLeft = 2 * iParentNodeIndex + 1;
    }
}

void  CMySort::HeapSort(int iNeedSortArry[], int iArrayCount)
{
    int iMaxIndex = iArrayCount - 1;
    //堆构造
    for (int i = iMaxIndex / 2 - 1; i >= 0; i--) 
    { 
        HeapAdjust(iNeedSortArry, i, iMaxIndex);  
    }
    while (iMaxIndex >= 0) {
        std::swap(iNeedSortArry[0], iNeedSortArry[iMaxIndex--]);    //将堆顶元素与尾节点交换后，长度减1，尾元素最大
        HeapAdjust(iNeedSortArry, 0, iMaxIndex);                    //再次对堆进行调整
    }
}