C++经典函数、算法

递归函数

• 递归是调用自身

#include <iostream>
using namespace std;

// 递归方式求阶乘
int factorial(int n)
{
    // 基准情况
    if (n == 1)
        return 1;
    else
        return factorial(n - 1) * n;
}

int main()
{
    cout << "5! = " << factorial(5) << endl;

    cin.get();
}

斐波那契数列

• 斐波那契数列（Fibonacci sequence），又称[黄金分割] F(0)=1，F(1)=1, F(n) = F(n - 1) + F(n - 2)（n ≥ 2，n ∈ N*）

#include <iostream>
using namespace std;

int fib(int n)
{
    // 基准情况
    if (n == 1 || n == 2)
        return 1;
    return fib(n - 2) + fib(n - 1);
}

int main()
{
    cout << "fib(9) = " << fib(9) << endl;
    cin.get();
}

二分查找

• 二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法，前提是数据对象必须先排好序。二分查找事实上采用的是一种“分治”策略，它充分利用了元素间的次序关系。

#include <iostream>

using namespace std;

// 可以递归调用的二分查找
int search(const int (&a)[10], int start, int end, int target)
{
    // 基准情况：目标值超出范围，或者start > end，说明没有找到
    if (target < a[start] || target > a[end] || start > end)
        return -1;

    // 取二分的中间坐标
    int mid = (start + end) / 2;
    // 比较中间值和目标值的大小
    if (a[mid] == target)
        return mid; // 找到了
    else if (a[mid] > target)
        return search(a, start, mid - 1, target); // 比目标值大，在更小的部分找
    else
        return search(a, mid + 1, end, target); // 比目标值小，在更大的部分找
}

int main()
{
    int arr[10] = {1, 2, 3, 4, 5, 6, 9, 12, 25, 38};

    int key = 25;
    int size = sizeof(arr) / sizeof(arr[0]);
    int result = search(arr, 0, size - 1, key);

    result == -1
        ? cout << "在数组中没有找到" << key << "!" << endl
        : cout << "在数组中找到" << key << "，索引下标为：" << result << endl;

    cin.get();
}

快速排序

• 通过一次扫描，将待排记录分隔成独立的两部分，其中一部分的值全比另一部分的小；接下来分别对这两部分继续进行排序，最终全部排完。这种算法更加高效，被称为“快速排序”。

#include <iostream>
using namespace std;

void quickSort(int (&)[10], int, int);
int partition(int (&)[10], int, int);

void printArr(const int (&)[10]);
void swap(int (&)[10], int, int);

int main()
{
    int arr[10] = {23, 45, 18, 6, 11, 19, 22, 18, 12, 9};

    printArr(arr);

    int size = sizeof(arr) / sizeof(arr[0]);
    quickSort(arr, 0, size - 1);

    printArr(arr);

    cin.get();
}

// 快速排序
void quickSort(int (&a)[10], int start, int end)
{
    // 基准情况
    if (start >= end)
        return;
    // 分区，返回分区点下标
    int mid = partition(a, start, end);

    // 递归调用，分别对两部分继续排序
    quickSort(a, start, mid - 1);
    quickSort(a, mid + 1, end);
}

// 按照pivot分区的函数
int partition(int (&a)[10], int start, int end)
{
    // 选取一个分区的“支点”
    int pivot = a[start];

    int left = start, right = end;

    while (left < right)
    {
        // 分别从左右两边遍历数组
        while (a[left] <= pivot && left < right)
            ++left;
        while (a[right] >= pivot && left < right)
            --right;

        // 左右互换
        swap(a, left, right);
    }
    if (a[left] < pivot)
    {
        swap(a, start, left);
        return left;
    }
    else if (a[left] > pivot)
    {
        swap(a, start, left - 1);
        return left - 1;
    }
}

// 数组中两元素互换的函数
void swap(int (&a)[10], int i, int j)
{
    int temp = a[i];
    a[i] = a[j];
    a[j] = temp;
}

// 打印输出一个数组
void printArr(const int (&a)[10])
{
    for (int num : a)
        cout << num << "\t";
    cout << endl;
}

遍历二叉树

• 对于树的遍历，主要有这样三种方式
  • 先序遍历：先访问根节点，再访问左子树，最后访问右子树
  • 中序遍历：先访问左子树，再访问根节点，最后访问右子树
  • 后序遍历：先访问左子树，再访问右子树，最后访问根节点

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

struct TreeNode
{
    string name;
    TreeNode *left;
    TreeNode *right;
};

void printTreePreOrder(TreeNode *root)
{
    // 基准情况，如果是空树，直接返回
    if (root == nullptr)
        return;

    cout << root->name << "\t";

    // 递归打印左右子树
    printTreePreOrder(root->left);
    printTreePreOrder(root->right);
}

// 中序遍历打印二叉树
void printTreeInOrder(TreeNode *root)
{
    // 基准情况，如果是空树，直接返回
    if (root == nullptr)
        return;

    printTreeInOrder(root->left);
    cout << root->name << "\t";
    printTreeInOrder(root->right);
}

// 后序遍历打印二叉树
void printTreePostOrder(TreeNode *root)
{
    // 基准情况，如果是空树，直接返回
    if (root == nullptr)
        return;

    printTreePostOrder(root->left);
    printTreePostOrder(root->right);
    cout << root->name << "\t";
}

int main()
{
    // 定义一棵二叉树
    TreeNode nodeG = {"G", nullptr, nullptr};
    TreeNode nodeF = {"F", nullptr, nullptr};
    TreeNode nodeE = {"E", &nodeG, nullptr};
    TreeNode nodeD = {"D", nullptr, nullptr};
    TreeNode nodeC = {"C", nullptr, &nodeF};
    TreeNode nodeB = {"B", &nodeD, &nodeE};
    TreeNode nodeA = {"A", &nodeB, &nodeC};

    TreeNode *tree = &nodeA;

    printTreePreOrder(tree);

    cout << endl
         << endl;

    printTreeInOrder(tree);

    cout << endl
         << endl;

    printTreePostOrder(tree);

    cin.get();
}