面试笔试排序算法

// 冒泡排序
// 2个相邻的元素相互比较，不满足顺序则交换；每遍历一次数组，使一个元素处于最终位置。
void BubbleSort(std::vector<int>& nums)
{
    if(nums.empty())
    {
        return;
    }

    bool sorted = false; // 假设没有排好序
    size_t n = nums.size();

    while(!sorted)
    {
        sorted = true; // 假设已经排好序
        for(int i = 1; i < n; ++i)
        {
            if(nums[i-1] > nums[i])
            {
                std::swap(nums[i-1], nums[i]);
                sorted = false; // 恢复为已排好序
            }
        }
        --n; // 已经排好序的元素不必再参与排序了
    }
}

// 快速排序
// 随机在数组中选择一个元素，作为划分元素，将数组中比划分元素小的交换到左侧，
// 比划分元素大的交换到右侧，最后将划分元素交换到左右区间的连接处，则划分元素处于了最终位置；
// 递归地对左右区间进行快速排序。
int Partition(vector<int>& vec, int low, int up)
{
    int pivot = vec[up];
    int i = low - 1;

    for(int j = low; j < up; ++j)
    {
        if(vec[j] <= pivot)
        {
            ++i;
            std::swap(vec[i], vec[j]);
        }
    }
    std::swap(vec[i+1], vec[up]);

    return i+1;
}

void QuickSort(vector<int>& vec, int low, int up)
{
    if(low < up)
    {
        int mid = Partition(vec, low, up);

        QuickSort(vec, low, mid - 1);
        QuickSort(vec, mid + 1, up);
    }
}

 

/*
    插入排序
*/
void InsertionSort(std::vector<int>& vec)
{
    int num = vec.size();

    for (int i = 1; i < num; ++i)
    {
        for (int j = i; j > 0 && vec[j] < vec[j - 1]; --j)
        {
            std::swap(vec[j], vec[j - 1]);
        }
    }
}

 

/*
    归并排序
*/

class MergeSort
{
public:
    void merge(std::vector<int>& vec, int low, int mid, int high)
    {
        int i = low; int j = mid + 1;

        for (int k = low; k <= high; ++k)
        {
            aux_[k] = vec[k];
        }

        for (int k = low; k <= high; ++k)
        {
            if (i > mid)
            {
                vec[k] = aux_[j++];
            }
            else if (j > high)
            {
                vec[k] = aux_[i++];
            }
            else if (aux_[j] < aux_[i])
            {
                vec[k] = aux_[j++];
            }
            else
            {
                vec[k] = aux_[i++];
            }
        }
    }

    void merge_sort(std::vector<int>& vec, int low, int high)
    {
        if (low >= high)
        {
            return;
        }

        int mid = low + (high - low) / 2;

        merge_sort(vec, low, mid);
        merge_sort(vec, mid + 1, high);
        merge(vec, low, mid, high);
    }

    void sort(std::vector<int>& vec, int low, int high)
    {
        aux_.resize(vec.size());
        merge_sort(vec, 0, vec.size() - 1);
    }

private:
    static std::vector<int> aux_;
};

std::vector<int> MergeSort::aux_;

 

/*
选择排序
*/
void SelectionSort(std::vector<int>& vec)
{
    int num = vec.size(); // 向量大小

    for (int i = 0; i < num; ++i) // 外循环 从下标0开始
    {
        int min = i; // 最小元素的下标

        for (int j = i + 1; j < num; ++j) // 从i的下一个元素开始
        {
            if (vec[j] < vec[min])
            {
                min = j;
            }
        }
        std::swap(vec[i], vec[min]);
    }
}