C++后端编程 构建高性能后端的数据库、API 与 Web 服务器 3 深入解析算法

1. 初始化一个空的推荐列表。
2. 获取用户购买的书籍列表。
3. 确定所购书籍中最常见的类型。
4. 筛选平台书籍数据库，仅保留该类型的书籍。
5. 根据平均评分对筛选后的书籍进行排序。
6. 将评分最高的书籍添加到推荐列表中。
7. 返回推荐列表。

排序算法

void bubbleSort(int arr[], int n) {
    for(int i = 0; i < n-1; i++) {
       for(int j = 0; j < n-i-1; j++) {
           if(arr[j] > arr[j+1]) {
               // 交换 arr[j] 和 arr[j+1]
               int temp = arr[j];
               arr[j] = arr[j+1];
               arr[j+1] = temp;
           }
       }
   }
}

以下逐步解析展示了上述代码片段的工作原理：

void insertionSort(int arr[], int n) {
    for(int i = 1; i < n; i++) {
       int key = arr[i];
       int j = i - 1;
        // Move elements of arr[0..i-1] that are greater than key to one position ahead of their current position
       while(j >= 0 && arr[j] > key) {
           arr[j+1] = arr[j];
           j--;
       }
       arr[j+1] = key;
   }
}

void quickSort(int arr[], int low, int high) {
   if (low < high) {
       // pi is partitioning index, arr[pi] is now at right place
       int pi = partition(arr, low, high);
       // Separately sort elements before partition and after partition
       quickSort(arr, low, pi - 1);
       quickSort(arr, pi + 1, high);
   }
}
int partition(int arr[], int low, int high) {
    int pivot = arr[high]; // pivot
    int i = (low - 1); // Index of smaller element
    for (int j = low; j <= high - 1; j++) {
       // If current element is smaller than the pivot
       if (arr[j] < pivot) {
           i++; // increment index of smaller element
           swap(arr[i], arr[j]);
       }
   }
   swap(arr[i + 1], arr[high]);
   return (i + 1);
}

void mergeSort(int arr[], int l, int r) {
   if (l < r) {
       // Same as (l+r)/2, but avoids overflow for large l and h
       int m = l+(r-l)/2;
       // Sort first and second halves
       mergeSort(arr, l, m);
       mergeSort(arr, m+1, r);
       merge(arr, l, m, r);
   }
}
void merge(int arr[], int l, int m, int r) {
   int i, j, k;
    int n1 = m - l + 1;
    int n2 = r - m;
   /* create temp arrays */
   int L[n1], R[n2];
    /* Copy data to temp arrays L[] and R[] */
    for (i = 0; i < n1; i++)
       L[i] = arr[l + i];
    for (j = 0; j < n2; j++)
       R[j] = arr[m + 1+ j];
    /* Merge the temp arrays back into arr[l..r]*/
    i = 0; // Initial index of first subarray
    j = 0; // Initial index of second subarray
    k = l; // Initial index of merged subarray
    while (i < n1 && j < n2) {
       if (L[i] <= R[j]) {
           arr[k] = L[i];
           i++;
       } else {
           arr[k] = R[j];
           j++;
       }
       k++;
   }
    /* Copy the remaining elements of L[], if there are any */
   while (i < n1) {
       arr[k] = L[i];
       i++;
       k++;
   }
    /* Copy the remaining elements of R[], if there are any */
   while (j < n2) {
       arr[k] = R[j];
       j++;
       k++;
   }
}

int binarySearch(int arr[], int l, int r, int x) {
   if (r >= l) {
       int mid = l + (r - l) / 2;
       // If the element is present at the middle
       if (arr[mid] == x)
           return mid;
        // If element is smaller than mid, then it can only be present in left subarray
       if (arr[mid] > x)
           return binarySearch(arr, l, mid - 1, x);
       // Else the element can only be present in right subarray
       return binarySearch(arr, mid + 1, r, x);
   }
    // We reach here when element is not present in array
   return -1;
}

对于较大且已排序的数据集，二分搜索在最坏情况和平均情况下的时间复杂度均为 O(log n)，其速度明显快于线性搜索。 但二分搜索要求数据集必须预先排序，而实际情况中这并非总能满足。

#include <list>
#include <iostream>
class Graph {
   int V;
   std::list<int> *adj;
public:
   Graph(int V);
   void addEdge(int v, int w);
   void DFS(int v);
};
Graph::Graph(int V) {
   this->V = V;
   adj = new std::list<int>[V];
}
void Graph::addEdge(int v, int w) {
   adj[v].push_back(w);
}
void Graph::DFS(int v) {
   bool *visited = new bool[V];
    for (int i = 0; i < V; i++)
       visited[i] = false;
   std::list<int> stack;
   visited[v] = true;
   stack.push_back(v);
   while (!stack.empty()) {
       v = stack.back();
       std::cout << v << " ";
       stack.pop_back();
       std::list<int>::iterator i;
       for (i = adj[v].begin(); i != adj[v].end(); ++i)
           if (!visited[*i]) {
               stack.push_back(*i);
               visited[*i] = true;
           }
   }
}

尽管实现简单，深度优先搜索(DFS)仍是算法设计和问题解决中的强大工具。 但需注意，DFS 并非在所有情况下都是最高效或最合适的算法。 其效率和适用性取决于具体问题的特性和需求。

迭代算法

int fibonacci_iterative(int n) {
   if (n <= 1)
       return n;
   else {
       int fib = 1;
       int prevFib = 0;
       for(int i = 2; i <= n; ++i) {
           int temp = fib;
           fib += prevFib;
           prevFib = temp;
       }
       return fib;
   }
}

动态规划算法

动态规划，通常缩写为 DP，是一种强大的计算技术，通过将主要问题分解为多个更简单且更易处理的子问题来解决问题。 这一策略特别适用于解决优化问题，这类问题需要从多个潜在替代方案中选择最有利的行动方案。

"记忆化"思想是动态规划的基石，也是该方法的指导原则。 将每个子问题的解决方案系统地存储起来，确保每个问题只被解决一次的过程被称为"解决方案缓存"。 当需要再次解决特定子问题时，不再重新计算，而是直接使用先前存储的答案。 这显著减少了所需的计算时间和资源，使 DP 成为解决复杂问题的有效方法。