算法 | 子集数&排列树&满m叉树&二分搜索&归并排序&快速排序

子集树：O(2^n)

一个序列的所有子集为2^n，即可看成具有2^n个叶节点的满二叉树

int backtrack(int k)     //k表示扩展结点在解空间树中所处的层次
{
    
    if(k>n)             //n标识问题的规模
        output(x);      //x是存放当前解的一维数组
    
    if(constraint(k))   //约束函数
    {  
         //做相关标识
        backtrack(k+1)
        //做相关标识的反操作 
    }    
    if(bound(k))       //限定函数
    {
        //做相关标识
        backtrack(k+1)
        //做相关标识的反操作 

    }
    
}

常用于：解空间为子集树的常见问题：
（1）0-1背包问题；
（2）子集和问题；
（3）装载问题；
（4）最大团问题。 

---

排序树：O(n!)

int backtrack(int t)      //t表示扩展结点在解空间树中所处的层次
{
    
    if(t>n)              //n标识问题的规模
        output(x);       //x是存放当前解的一维数组
    else
    {
        for(int i=t;i<=n;i++)
        {
            swap(x[t],x[i]);              //实现两个位置的交换
            if(constraint(t)&&bound(t))   //约束函数与限定函数
            backtrack(t+1)                //递归
            swap(x[t],x[i]);              //恢复原状
            
        }
        
    }
    
}

解空间为排列树的常见问题：

（1）n皇后问题；
（2）旅行商问题；
（3）园排列问题；
（4）电路板排列问题。

---

满m叉树：O（n*m^n）

地图着色问题：

每个元素有M种选择

---

 二分搜索法：最好：O（1）   最坏：O（logn）

二分搜索法（Binary Search）是一种在有序数组中查找某一特定元素的搜索算法。搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。

最好时间复杂度：
在二分搜索法中，如果我们要查找的元素正好是数组的中间元素，那么我们只需要一次比较就能找到它。因此，最好的情况下，二分搜索的时间复杂度是 O(1)。但是，严格来说，我们通常说二分搜索的最好时间复杂度是 O(log n)，因为这只是平均情况或最好情况的一种特例，而平均情况或最好情况通常需要 log n 次比较（当 n 是数组的长度时）。

最坏时间复杂度：
在二分搜索法中，最坏的情况是我们要查找的元素不在数组中，或者它在数组的最左边或最右边。在这种情况下，我们需要不断地缩小搜索范围，直到搜索范围为空。每次比较，我们都将搜索范围减半，因此，在最坏的情况下，我们需要 log n 次比较（这里 log 是以 2 为底的对数）。所以，二分搜索的最坏时间复杂度是 O(log n)。

---

归并排序

#include <iostream>  
using namespace std;

void Merge(int A[], int low, int mid, int high)
{
    int* B = new int[high - low + 1];
    int i = low, j = mid + 1, k = 0;
    while (i <= mid && j <= high)
    {
        if (A[i] <= A[j])
            B[k++] = A[i++];
        else
            B[k++] = A[j++];
    }
    while (i <= mid) B[k++] = A[i++];
    while (j <= high) B[k++] = A[j++];
    // 修正：复制B到A时，确保k从0开始  
    for (int p = 0; p < k; p++)
        A[low + p] = B[p]; // 使用low + p来确保复制到正确的位置  
    delete[] B; // 释放动态分配的内存  
}

void MergeSort(int A[], int low, int high)
{
    if (low < high)
    {
        int mid = (low + high) / 2;
        // 修正：递归调用应该包括mid  
        MergeSort(A, low, mid);
        MergeSort(A, mid + 1, high);
        Merge(A, low, mid, high);
    }
}

int main()
{
    int a[] = { 1, 2, 54, 25, 76, 23 };
    int n = sizeof(a) / sizeof(a[0]); // 计算数组长度  
    MergeSort(a, 0, n - 1); // 修正：传入正确的high值  
    for (int i = 0; i < n; i++) // 修正：打印所有元素  
        cout << a[i] << " "; // 添加空格分隔符  
    cout << endl; // 打印换行符  
    return 0;
}

这三行代码是归并排序（Merge Sort）算法中的关键步骤。归并排序是一种分治（Divide and Conquer）策略的排序算法。

1. MergeSort(A, low, mid);

这行代码是递归地调用归并排序函数本身，用于对数组的左半部分进行排序。这
2. MergeSort(A, mid + 1, high);

这行代码与第一行类似，但它是用于对数组的右半部分进行排序。
3. Merge(A, low, mid, high);

当左半部分和右半部分都已经被排序后，这行代码用于将这两个已排序的子数组合并成一个已排序的完整数组。

---

快速排序

void QuickSort(int array[], int low, int high) {
    int i = low; 
    int j = high;
    if(i >= j) {
        return;
    }
 
    int temp = array[low];
    while(i != j) {
        while(array[j] >= temp && i < j) {
            j--;
        }
	while(array[i] <= temp && i < j) {
            i++;
        }
	if(i < j) {
            swap(array[i], array[j]);
        }
    }
 
    //将基准temp放于自己的位置，（第i个位置）
    swap(array[low], array[i]);
    QuickSort(array, low, i - 1);
    QuickSort(array, i + 1, high);
}