数据结构和算法视频学习

数据结构和算法学习

排序

快速排序—分治

步骤：

1. 确定分界点x,可以是左边界可以是右边界可以是中点
2. 调整区间（左边段小于等于x，右边段大于等于x）重点和难点 ⭐
3. 递归处理左右两端（最终使左右两断有序，因为左边始终小于等于右边，所以整个有序）

#include <iostream>

using namespace std;
const int N = 1e6 + 10;
int n;
int q[N];

void quick_sort(int q[], int l, int r) {
    if (l >= r) return;
    int x = q[l], i = l - 1, j = r + 1;//选择左右都是可以的
    while (i < j) {
        do {
            i++;
        } while (q[i] < x);
        do {
            j--;
        } while (q[j] > x);
        if (i < j) {
            swap(q[i], q[j]);
        }
    }
    quick_sort(q, l, j);
    quick_sort(q, j + 1, r);
}

int main() {
    scanf("%d", &n);
    for (int i = 0; i < n; ++i) {
        scanf("%d", &q[i]);
    }
    quick_sort(q, 0, n - 1);
    for (int i = 0; i < n; ++i) {
        printf("%d", n);
    }
    return 0;
}

归并排序—分治

步骤：

1. 确定分界点—中点
2. 递归排序左右两边
3. 将左右两个数组合并成一个有序的数组—归并 ⭐

#include <iostream>

using namespace std;
const int N = 1e6;
int n;
int a[N];

void merge_sort(int s[], int l, int r) {
    if (l >= r) return;
    int mid = (l + r) / 2;
    merge_sort(s, l, mid);
    merge_sort(s, mid + 1, r);
    int i = l, j = mid + 1;
    int k = 0, temp[r - l + 1];
    while (i <= mid && j <= r) {
        if (s[i] <= s[j]) temp[k++] = s[i++];
        else temp[k++] = s[j++];
    }
    while (i <= mid) temp[k++] = s[i++];
    while (j <= r) temp[k++] = s[j++];
    for (int i = 0, j = l; j <= r; ++i, ++j) {
        s[j] = temp[i];
    }
}

int main() {
    cin >> n;
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }
    merge_sort(a, 0, n - 1);
    for (int i = 0; i < n; ++i) {
        cout << a[i] << ' ';
    }
    return 0;
}

---

二分

二分的本质并不是单调性，通过二分保证答案在区间内

整数二分

步骤：

针对有序数组

1. 找出中间值
2. 判断中间值是否为真，根据情况更新区间 注意是否需要+1 处理边界问题

#include <iostream>
//using namespace std;
//const int N = 100000;
//int n,m;
//int q[N];
using namespace std;

int main() {
    //scanf("%d%d",&n,&m);
    //读入从n个数的数组中读取m的开始位置和结束位置
    int n = 6, m = 3;
    bool flag = true;
    int q[6] = {1, 2, 3, 3, 3, 6};
    while (flag) {
        int l = 0, r = n - 1;
        while (l < r) {
            int midNum = l + r >> 1;
            if (q[midNum] >= m) {
                r = midNum;
            } else {
                l = midNum + 1;
            }
        }
        if (q[l] != m) {
            cout << "-1 -1" << endl;
            flag = false;
        } else {
            cout << l << " ";
            l = 0, r = n - 1;
            while (l < r) {
                int midNum = l + r + 1 >> 1;
                if (q[midNum] <= m) {
                    l = midNum;
                } else {
                    r = midNum - 1;
                }
            }
            cout << l << endl;
            flag = false;
        }
    }
    return 0;
}

浮点数二分

不用考虑边界问题

#include <iostream>

using namespace std;

int main(){
    int n;
    scanf("%d",&n);
    double l = 0, r = n;
    double minigap = 1e-8;
    while ((r - l) > minigap) {
        double midnum = (l + r) / 2;
        if ((midnum * midnum) <= n) l = midnum;
        else r = midnum;
    }
    if (1) cout << 0 << endl;
    printf("%f", l);

    return 0;
};

---

高精度

C++中存在的问题

• 大整数的存储问题，是将数据存储到数组中，从索引0开始到最后，分别存储个位、十位、百位…最高位，因为运算过程中可能存在进位问题，数组在尾部加数据更加方便。

A + B 类型

#include <iostream>
#include <vector>
using namespace std;
int N = 100000 + 10;

vector<int> addbignum (vector<int> &A, vector<int> &B){
    int t = 0;
    vector<int> C;
    for (int i = 0; i < A.size()|| i < B.size(); ++i) {
        if (i < A.size()) t += A[i];
        if (i < B.size()) t += B[i];
        C.push_back(t % 10);
        t /= 10;
    }
    if (t) C.push_back(1);
    return C;
}

int main(){
    //高精度大整数相加
    //1.先将两个大整数倒叙写入到各自的vector集合(头文件需要定义)中
    //2.调用自定义的add函数实现相加和进位，最终以集合返回
    //3.倒叙遍历输出最终结果

    //大整数用string
    string a = "12",b = "30";//例如a = 123456
    vector<int> A,B;//最为A,B的集合存放数据
    for (int i = a.size() - 1; i >= 0; --i) {
        A.push_back(a[i] - '0');
    }
    for (int i = b.size() - 1; i >= 0; --i) {
        B.push_back(b[i] - '0');
    }
    vector<int> C = addbignum(A, B);
    for (int i = C.size() - 1 ; i >= 0; --i) {
        cout << C[i];
    }
    return 0;
}

A - B 类型

#include <iostream>
#include <vector>

using namespace std;

bool cmp(vector<int> &A, vector<int> &B) {
    //减法计算前需要判断AB的大小关系
    //分几种情况，AB长度相同，不相同
    if (A.size() != B.size()) return A.size() - B.size();
    else {
        for (int i = A.size() - 1; i >= 0; --i) {
            if (A[i] != B[i]) {
                return A[i] - B[i];
            }
        }
        return true;
    }
}

vector<int> dec(vector<int> &A, vector<int> &B) {
    vector<int> C;//存放结果的数组
    int t = 0;
    for (int i = 0; i < A.size(); ++i) {
        t = A[i] - t;
        if (i < B.size()) t = t - B[i];
        C.push_back((t + 10) % 10);
        if (t < 0) t = 1;
        else t = 0;
    }
    while (C.size() > 1 && C.back() == 0) C.pop_back();//解决输出结果为0009这些情况
    return C;
}

int main() {
    string a = "10", b = "1";//a,b两个大正整数
    vector<int> A, B;//集合AB存放数据
    for (int i = a.size() - 1; i >= 0; --i) {
        A.push_back(a[i] - '0');
    }
    for (int i = b.size() - 1; i >= 0; --i) {
        B.push_back(b[i] - '0');
    }
    vector<int> C;
    //首先需要判断AB谁大，是谁减谁
    if (cmp(A, B)) {
        //true 则A >= B
        C = dec(A, B);
        for (int i = C.size() - 1; i >= 0; --i) {
            printf("%d", C[i]);
        }
    } else {
        //B > A
        C = dec(B, A);
        cout << '-';
        for (int i = C.size() - 1; i >= 0; --i) {
            printf("%d", C[i]);
        }
    }
    return 0;
}

A * a 类型

#include <iostream>
#include <vector>

using namespace std;
vector<int> mul(vector<int> &A, int b) {
    vector<int> C;
    int t =0;
    for (int i = 0; i < A.size() || t; ++i) {
        if (i < A.size()) t = b * A[i] + t;
        C.push_back((t) % 10);
        t /= 10;
    }
    return C;
}
int main(){
    string a = "999";
    int b = 9;
    vector<int> A, C;
    for (int i = a.size() - 1; i >= 0; --i) {
        A.push_back(a[i] - '0');
    }
    C = mul(A, b);
    for (int i = C.size() - 1; i >= 0; --i) {
        printf("%d",C[i]);
    }
    return 0;
}

A / a 类型

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

vector<int> div(vector<int> &A, int b, int &r) {//余数通过引用&返回回去
    vector<int> C;
    for (int i = A.size() - 1; i >= 0; --i) {
        r = r * 10 + A[i];
        C.push_back(r / b);
        r = r % b;
    }
    reverse(C.begin(), C.end());//得反转以下，否则输出不一致
    while (C.size() > 1 && C.back() == 0) C.pop_back();
    return C;
}

int main() {
    string a = "1247";
    int b = 4, r = 0;
    vector<int> A, C;
    for (int i = a.size() - 1; i >= 0; --i) {
        A.push_back(a[i] - '0');
    }
    C = div(A, b, r);
    for (int i = C.size() - 1; i >= 0; --i) {
        printf("%d", C[i]);
    }
    cout << endl << r << endl;
    return 0;
}