数据结构拾遗——排序(时间复杂度O(n^2))

复习完数据结构后，决定挑选重要的部分总结一下，顺序暂定从后向前

所以一开始是排序

不多说直接上代码

swap.h

#pragma once　　//编译一次
#include <vector>　　//数据结构决定简单的使用向量

template <typename T>　　//模板编程适用变量更多
void swapLHW(vector<T> &v, int i, int j) {　　//单纯的交换向量中的两个元素
    T tmp = v[i];
    v[i] = v[j];
    v[j] = tmp;
}

c++自带了swap，不过还是定义了一个自己的

BubbleSort.h

#pragma once
#include <vector>
#include "swap.h"
template <typename T>
void BubbleSort0 (vector<T> &v) {
    for (auto i = 0; i < v.size(); i++)
        for (auto j = i + 1; j < v.size(); j++)
            if (v[i] > v[j])
                swapLHW(v, i, j);
}

template <typename T>
void BubbleSort1(vector<T> &v) {
    for (auto i = 0; i <v.size(); i++)
        for (auto j = v.size() - 1; j > i; j--)
            if (v[j] < v[j - 1])
                swapLHW(v, j, j - 1);
}

template <typename T>
void BubbleSort3(vector<T> &v) {
    bool flag = true;
    for (auto i = 0; i < v.size() && flag; i++)
    {
        flag = false;
        for (auto j = v.size() - 1; j > i; j--) 
        {
            if (v[j] < v[j - 1]) 
            {
                swapLHW(v, j, j - 1);
                flag = true;
            }
        }
    }
}

0是简易的冒泡，每次只比较固定的v[i]和递增的v[j]

事实上v[i]如果是最小了，后面的比较久没有意义

1是普通的冒泡，每次比较v[j-1]和v[j]，两个都是递减的

如果较小的在后面，可以不断上浮

如果被更小的截止，更小的可以接着上浮

2只是简单的判断了一下一次循环有没有交换元素

如果没有，说明已经排序好，跳出循环

SelectSort.h

#pragma once
#include "swap.h"
#include <vector>
template <typename T>
void SelectSort(vector<T> &v) {
    for (auto i = 0; i < v.size(); i++)
    {
        int pos = i;
        for (auto j = i + 1; j < v.size(); j++)
        {
            if (v[j] < v[pos])
            {
                pos = j;
            }
        }
        if (pos != i)
        {
            swapLHW(v, i, pos);
        }
    }
}

选择排序

简单的想法，每次扫描未排序好的部分

选择最小的放前面

StraightInsertSort.h

#pragma once
#include "swap.h"
#include <vector>
using namespace std;
template <class T>
void StraightIS(vector<T> &v) {
    T tmp;
    for (auto i = 1; i < v.size(); i++)
    {
        tmp = v[i];
        if (v[i] < v[i - 1])
        {
            int j = i - 1;
            for (; j >= 0 && v[j] > tmp; j--)
            {
                v[j + 1] = v[j];
            }
            v[j + 1] = tmp;
        }
        
    }
}

直接插入排序

从第二个开始，依次取第二、三……个元素

插入到前面的位置

比这个元素大的元素，向后移动一个位置