11.25快速排序细节，sort函数，二分使面积差最小

快速排序

i从左边开始，遇到大于等于x的停下来，j遇到小于等于x的停下来，然后如果i

递归可能有两种写法，即开始，左-1，左，结束

与开始，右，右+1，结束

对于左指针而言，左边的值是确定的，一定小于等于x;

然后对于右指针而言，j右边的值，一定都是大于等于x

当基值 

#include 
#include 
#include 
#include
#include
#include 
using namespace std;
int arr[1005], n;
void fp() {
    for (int i = 0; i < n; i++) {
        cout << arr[i];
        if (i != n - 1) {
            cout << " ";
        }
    }
    cout << endl;
}
void quick(int begin, int end) {
    if (begin > end) {
        return;
    }
    int l = begin, r = end, p = arr[begin];
    while (l != r) {
        while (r > l && arr[r] >= p) {
            r--;
        }
        while (r > l && arr[l] <= p) {
            l++;
        }
        if (r > l) {
            swap(arr[r], arr[l]);
        }
    }
    arr[begin] = arr[l];
    arr[l] = p;
    fp();
    quick(begin, l - 1);
    quick(l + 1, end);
}
int main() {
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> arr[i];
    }
    quick(0, n - 1);
    return 0;
}

如果比

sort函数

 

sort函数至少需要两个参数，为起点与终点，只传入数组名，数组名就是数组的起点，加数，就是对应的长度

二分，使面积差最小

这个check函数就是说，输入一个中间值，这个值就是划分的分界线，然后在函数里，计算左边的面积，以及右边的面积，对于每个矩形

每个矩形，记录它左边和右边，然后有一个函数getd，用来得到左右面积差值，如果左边在边界后，就全加在右面积里，如果都在边界前，就全部加在左面积里

记录一个最小面积差

#include 
#include 
#include 
#include
#include
#include 
using namespace std;
#define ll long long
const int N = 105;
struct node {
    int l, r, w, h;
}s[N];
int n;
ll getd(int mid) {
    ll sl = 0, sr = 0;
    for (int i = 1; i <= n; i++) {
        if (s[i].r <= mid) {
            sl += (ll)s[i].w * s[i].h;
        }
        else if (s[i].l >= mid) {
            sr += (ll)s[i].w * s[i].h;
        }
        else {
            sl += (ll)s[i].h * (mid - s[i].l);
            sr += (ll)s[i].h * (s[i].r - mid);
        }
    }
    return sl - sr;
}
//就是说，地图上有很多块，然后划一条线，使这条线上所有左侧的块都归属于A
//剩下的都给B，然后要让A>>B
//自左到右，累积的岛屿面积是不断增加的
//也就是说每个x坐标轴都对应一个值，这个值就是自左到右的岛屿面积，类似于分布函数

int main() {
    cin >> n;
    int R = 0, L = 1000;
    for (int i = 1; i <= n; i++) {
        int x, y, w, h;
        cin >> x >> y >> w >> h;
        s[i].l = x, s[i].r = x + w, s[i].w = w, s[i].h = h;
        R = max(R, s[i].r);
        L = min(L, s[i].l);
    }
    int ans = -1;
    ll da = 1e10;
    while (L <= R) {
        int mid = (L + R) >> 1;
        ll t = getd(mid);
        if (t < 0) {
            L = mid + 1;
        }
        else {
            da = min(da, t);
            R = mid - 1;
            ans = mid;
        }
    }
  //  while (ans < R && getd(ans + 1) == da) {
    //    ans++;
    //}
    cout << ans;
    return 0;
}

 二叉树的中序遍历

#include 
#include 
#include 
#include
#include
#include 
#include
using namespace std;
struct node {
    char data;
    node* lchild, * rchild;
    node(char x) :data(x), lchild(nullptr), rchild(nullptr) {}
};
int index = 0;
node* buildtree(string preorder) {
    if (index >= preorder.length()) {
        return nullptr;
    }
    char t = preorder[index++];
    if (t == '#') {
        return nullptr;
    }
    node* root = new node(t);
    root->lchild = buildtree(preorder);
    root->rchild = buildtree(preorder);
    return root;
}
void in(node* root) {
    if (root == nullptr) {
        return;
    }
    in(root->lchild);
    cout << root->data;
    in(root->rchild);
}
int main() {
    string preorder;
    cin >> preorder;
    node* root = buildtree(preorder);
    in(root);
    return 0;
}

#include 
#include 
#include 
#include
#include
#include 
#include
using namespace std;
int n, i, j;
int arr[100], target[100];
int main() {
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> arr[i];
    }
    for (int i = 0; i < n; i++) {
        cin >> target[i];
    }
    for (i = 0; i < n - 1 && target[i] <= target[i + 1]; i++);
    for (j = i + 1; target[j] == arr[j] && j < n; j++);
    if (j == n) {
        cout << "Insertion Sort" << endl;
        sort(arr, arr + i + 2);
    }
    else {
        cout << "Merge Sort" << endl;
        int flag = 1, k = 1;
        while (flag) {
            flag = 0;
            for (int i = 0; i < n; i++) {
                if (arr[i] != target[i]) {
                    flag = 1;//如果有一个不相同，就说明还没归并到这个阶段，就继续模拟进行归并
                }
                k = k << 1;
                for (int i = 0; i < n / k; i++) {
                    sort(arr + i * k, arr + (i + 1) * k);
                }
                sort(arr + n / k * k, arr + n);
            }
        }      
    }
    for (int i = 0; i < n; i++) {
        if (i) {
            cout << " ";
        }
        cout << arr[i];
    }
    return 0;
}