软件设计师考试中需要掌握的一些常用算法，基于C++实现

查找算法

算法思想

1、顺序查找：

顾名思义，就是从头到尾进行遍历，直到找到与目标值相等的元素位置；找到则告知具体位置，否则告知未找到。

2、二分查找：

该算法要求待查找的数据是有序排列的，比如数组！确定中间点的位置mid=(low+high)/2，将目标值与mid位置的值进行比较；若相等则查找成功；若不相等则按mid位置分为左右区间，根据比较结果在左右区间确定下一个mid位置，继续与目标值比较。

3、哈希表查找：

在哈希查找的过程中，首先需要对给定的key应用哈希函数，将其转换为对应的数组下标，然后查找数组中是否存储了待查找的value。C++中的unorder_map正是基于哈希表实现的，其特点是key无序。

上代码

#include <iostream>
#include <unordered_map>
using namespace std;

int orderSearch(int arr[], unsigned int length, int target)
{
    int index = 0;
    while (index <= length)
    { 
        if (arr[index] == target) 
            return index;
        else
            index++;
    }

    return -1; // 表示没有找到目标元素
}

int binarySearch(int arr[], int low, int high, int target)
{
	if(low > high)
	{
		return -1;
	}
    while (low <= high)
    { 
        int mid = low + (high - low) / 2;

        if (arr[mid] == target) 
            return mid;
        else if (arr[mid] < target) 
            low = mid + 1;
        else 
            high = mid - 1;
    }

    return -1; // 表示没有找到目标元素
}

void HashSearch()
{
    unordered_map<string, int> hash_map;
    // 初始化哈希表
    hash_map["hello"] = 1;
    hash_map["world!"] = 2;
    hash_map["how"] = 3;
    hash_map["are"] = 4;
    hash_map["you?"] = 5;
    hash_map["are"] = 6;
    hash_map["you"] = 7;
    hash_map["ok?"] = 8;
    // 查找哈希表中是否存在指定的键
    if (hash_map.find("you") != hash_map.end())
    {  // 参数值为要查找的键
        cout << "The key 'you' is found in the hash map, the value is "<< hash_map["you"] << "." << endl;
    }
    else
    {
        cout << "The key 'you' is not found in the hash map." << endl;
    }
}

int main() {
    int arr[] = {2, 5, 8, 12, 16, 23, 38, 56, 72, 91};
    int n = sizeof(arr) / sizeof(arr[0]);

    int target = 23;
    //顺序查找
    int index = orderSearch(arr, n, target);
    if (index == -1) 
        cout << "顺序查找: 目标元素未找到" << endl;
    else 
        cout << "顺序查找: 目标元素在数组中的下标为：" << index << endl;
    //二分查找
    target = 56;
    index = binarySearch(arr, 0, n-1, target);
    if (index == -1) 
        cout << "二分查找: 目标元素未找到" << endl;
    else 
        cout << "二分查找: 目标元素在数组中的下标为：" << index << endl;
    //哈希表查找
    HashSearch();
    return 0;
}

排序算法

算法思想

交换类排序

1、冒泡排序

通过不断地比较相邻的元素，从而在一次遍历中将最大的元素交换到最后面。每一次遍历都可以确定一个元素的最终位置，因此要进行n-1次遍历。冒泡排序的时间复杂度为O(n^2)。
下面示例中，采用的是冒泡排序的一种优化方法，即设置一个flag变量，记录本次遍历是否发生了交换，如果没有交换则说明已经排好序了，可以直接退出循环，从而避免后续不必要的遍历比较。

2、快速排序

通过分治和递归的方式将一个序列分成两个子序列，左序列所有元素都小于等于枢轴元素，右序列所有元素都大于等于枢轴元素，然后对这两个子序列分别进行同样的操作，直到序列只剩下一个元素或空序列为止。

上代码

#include <iostream>
using namespace std;
//冒泡排序
void bubbleSort(int arr[], int n)
{
    bool flag = true;
    for (int i = 0; i < (n - 1) && flag; i++){
        flag = false;
        for (int j = 0; j < (n - i - 1); j++){
            if (arr[j] > arr[j+1]){
                std::swap(arr[j], arr[j+1]);
                flag = true;
            }
        }
    }
}
//快速排序
void quickSort(int arr[], int left, int right)
{
    if (left >= right) return; // 如果左下标大于等于右下标，直接返回
    int i = left, j = right, pivot = arr[left]; //定义枢轴
    while (i < j)
    {
        while (i < j && arr[j] >= pivot) j--; // 从右往左找第一个小于枢轴的数
        arr[i] = arr[j];
        while (i < j && arr[i] <= pivot) i++; // 从左往右找第一个大于枢轴的数
        arr[j] = arr[i];
    }
    arr[i] = pivot; // 将枢轴元素放到正确的位置上
    quickSort(arr, left, i - 1); // 递归排序左子序列
    quickSort(arr, i + 1, right); // 递归排序右子序列
}
//测试
int main() {
    int arr1[] = { 4, 3, 6, 1, 7, 2, 5 };
    int n = sizeof(arr1) / sizeof(int);
    bubbleSort(arr1, n);
    for (int i = 0; i < n; i++)
    {
        cout << arr1[i] << " ";
    }
    cout << endl;
    
    int arr2[] = { 4,2,6,5,7,3,9,1,8 };
    n = sizeof(arr2) / sizeof(int);
    quickSort(arr2, 0, n - 1);
    for (int i = 0; i < n; i++)
    {
        cout << arr2[i] << " ";
    }
    cout << endl;

    return 0;
}

插入类排序

1、直接插入

2、希尔排序

归并排序