数据结构与算法（2）-CSDN博客

本文链接：https://blog.csdn.net/PasserbyKingTong/article/details/117706899

1 SequentialSearch(顺序查找)

6 InsertionSort(插入排序)

1 SequentialSearch(顺序查找)

对于没有排序的数据，只能运用顺序查找，速度很慢。

template<class T>
int SequentialSearch(T* list, const int len, const T a)
{
    for (int i = 0;i < len;i++)
    {
        if (list[i] == a)
            return i;
    }
    return -1;
}

2 BinarySearch(折半查找)

对于已升序或降序的数据，折半查找可以快速的查找出目标数据，其主要原理为通过先查找最中间的数，若目标数据大于查找数据，则进一步查找大的那一半数据的中位数，以此类推， $2^{20}$ （100万）数据只需要查找20次。

template<class T>
int BinarySearch(T* list, const int len, const T a)
{
    int low, high, mid;
    low = 0, high = len - 1;

    while (low <= high)
    {
        mid = (low + high) / 2;
        if (list[mid] == a)
            return mid;
        else if (list[mid] < a)
            low = mid + 1;
        else high = mid - 1;
    }
    return -1;
}

3 Recursion(递归)

简单的说，递归就是自己调用自己。如计算阶乘时。

long Factorial(int n)
{
    if (0 == n)
        return 1;
    else
        return n * Factorial(n - 1);
}

可以看出递归的缺点为速度慢，占用内存大；其优点为可读性强，好理解。

以下为迭代：

long Factorial1(int n)
{
    long ret = 1;
    for (int i = n;i > 0;i--)
        ret = ret * i;
    return ret;
}

4 折半查找的递归写法

template<class T>
int BinarySearch(T* list, const int left, const int right, const T a)
{
    if (left <= right)
    {
        int mid = (left + right) / 2;
        if (a < list[mid])
            return BinarySearch(list, left, mid - 1, a);
        else if (a > list[mid])
            return BinarySearch(list, mid + 1, right, a);
        return mid;
    }
    return -1;
}

5 Permutations(排列组合)

例如：abc -> abc -> abc

-> acb

-> bac -> bac

-> bca

-> cab -> cab

-> cba

void Permutations(char* p, const int k, const int m)
{
    if (k == m)
    {
        for (int i = 0;i <= m;i++)
            std::cout << p[i];
        std::cout << std::endl;
    }
    else
    {
        for (int i = k;i <= m;i++)
        {
            std::swap(p[k], p[i]);
            Permutations(p, k + 1, m);
            std::swap(p[k], p[i]);
        }
    }
}

其中k为第一个字母下标，m为最后一个字母下标。

6 InsertionSort(插入排序)

拿出一个数据，将其与之前拿出已排好序的数据作比较，插入正确的位置，直到所有数据均已拿出。

template<class T>
void InsertSort(T* list, const int len)
{
    int in, out;
    for (out = 1;out < len;++out)
    {
        T temp = list[out];
        in = out;
        while (in > 0 && list[in - 1] >= temp)
        {
            list[in] = list[in - 1];
            --in;
        }
        list[in] = temp;
    }
}

低级排序中插入排序速度最快。到此低级排序算法共三个已经结束，详情参考我的上一篇文章。高级排序算法将会在下一篇文章开始。