第1讲 基础算法

最新推荐文章于 2024-05-16 04:42:20 发布
最新推荐文章于 2024-05-16 04:42:20 发布
阅读量127 收藏
点赞数 1
分类专栏： acwing算法基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wsfhdhjs/article/details/116998017
版权

快速排序

在这里插入图片描述


#include <iostream>

using namespace std;

const int N = 100010;

int q[N];

void quick_sort(int q[], int l, int r)
{
    if (l >= r) return;        //这个表示  区间 只有 一个数了 就 不用 排序，直接退出就好

    int i = l - 1, j = r + 1, x = q[l + r >> 1];            //x表示 q中 的 中间的 值
    while (i < j)
    {
        do i ++ ; while (q[i] < x);         //i是从左边开始 遍历，直到找到q[i]>=x停止；j是从右边 开始 遍历，直到找到q[j]<=x为止； 我们要保证左边的值都小于x，右边的值都大于x
        do j -- ; while (q[j] > x);
        if (i < j) swap(q[i], q[j]);        //如果i<j，交换
    }

    quick_sort(q, l, j);            //先给 左边 递归 处理
    quick_sort(q, j + 1, r);        //再给 右边 递归 处理
}

int main()
{
    int n;
    scanf("%d", &n);            //输入n

    for (int i = 0; i < n; i ++ ) scanf("%d", &q[i]);       //读入 所有 的 数字

    quick_sort(q, 0, n - 1);            //对q，进行 0~n-1中的 一个排序

    for (int i = 0; i < n; i ++ )
        printf("%d ", q[i]);                       //输出 q[i]

    return 0;
}

第k个数


#include<iostream>
using namespace std;

const int maxn=100010;

int n,k;

int q[maxn];

void quick_sort(int q[],int l,int r)
{
    if(l>=r)
        return ;
    int i=l-1,j=r+1,x=q[l+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()
{
    cin >> n >> k;

    for(int i=0; i<n; i++)
        cin >> q[i];

    quick_sort(q,0,n-1);

    cout << q[k-1];

    return 0;
}

归并排序

在这里插入图片描述


#include <iostream>

using namespace std;

const int N = 1e5 + 10;

int a[N], tmp[N];

void merge_sort(int q[], int l, int r)
{
    if (l >= r) return;     //如果 区间 中的 元素 只有 1个 或者 没有 直接 返回

    int mid = l + r >> 1;           //归并 排序 第1步：先确定 中点

    merge_sort(q, l, mid), merge_sort(q, mid + 1, r);       //归并 排序 第2步：归并排序 左边 或者 右边

    int k = 0, i = l, j = mid + 1;      //tmp表示 临时 数组，k表示 temp中的 元素的 个数
    //i,j是 两个 指针

    while (i <= mid && j <= r)      //i小于 左半边的边界；j小于 右半边的 边界
        if (q[i] <= q[j])       //将小的数字 放到 临时 数组中
            tmp[k ++ ] = q[i ++ ];      //q[i]小 将 q[i]放到 临时 数组中
        else tmp[k ++ ] = q[j ++ ];     //q[j]小 将 q[j]放到 临时 数组中

    while (i <= mid) tmp[k ++ ] = q[i ++ ];         //那个 没完，将 那个 放进去
    while (j <= r) tmp[k ++ ] = q[j ++ ];

    for (i = l, j = 0; i <= r; i ++, j ++ ) q[i] = tmp[j];      //现在 需要 更新 q 这个 数组，j去遍历 temp数组；i去遍历q数组
}

int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; i ++ ) scanf("%d", &a[i]);       //输入n个数字

    merge_sort(a, 0, n - 1);        //从0~n-1进行  归并 排序

    for (int i = 0; i < n; i ++ ) printf("%d ", a[i]);      //输出 a[i]

    return 0;
}

逆序对的数量

在这里插入图片描述

#include <iostream>

using namespace std;

typedef long long LL;

const int N = 1e5 + 10;

int a[N], tmp[N];

LL merge_sort(int q[], int l, int r)
{
    if (l >= r) return 0;

    int mid = l + r >> 1;

    LL res = merge_sort(q, l, mid) + merge_sort(q, mid + 1, r);     

    int k = 0, i = l, j = mid + 1;
    
    while (i <= mid && j <= r)
        if (q[i] <= q[j]) tmp[k ++ ] = q[i ++ ];
        else
        {
            res += mid - i + 1;
            tmp[k ++ ] = q[j ++ ];
        }
    while (i <= mid) tmp[k ++ ] = q[i ++ ];
    while (j <= r) tmp[k ++ ] = q[j ++ ];

    for (i = l, j = 0; i <= r; i ++, j ++ ) q[i] = tmp[j];

    return res;
}

int main()
{
    int n;
    scanf("%d", &n);                //输入n 
    for (int i = 0; i < n; i ++ ) scanf("%d", &a[i]);       //输入n个 数字

    cout << merge_sort(a, 0, n - 1) << endl;        //直接merge_sort

    return 0;
}

数的范围

在这里插入图片描述
在这里插入图片描述


#include <iostream>

using namespace std;

const int N = 100010;

int n, m;
int q[N];

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i ++ ) scanf("%d", &q[i]);       //输入q[i]

    while (m -- )
    {
        int x;
        scanf("%d", &x);        //输入x

        int l = 0, r = n - 1;               //这个就是 找到 第一个 x的 位置，使用第1中 模板
        while (l < r)
        {
            int mid = l + r >> 1;
            if (q[mid] >= x) r = mid;
            else l = mid + 1;
        }

        if (q[r] != x) cout << "-1 -1" << endl;
        else        //否则，就是 q[l]==x
        {
            cout << l << ' ';       //输出 起点

            int l = 0, r = n - 1;           //这个就是 需要 找到 最后一个 x的 位置，使用第2个中的 模板
            while (l < r)
            {
                int mid = l + r + 1 >> 1;
                if (q[mid] <= x) l = mid;
                else r = mid - 1;
            }

            cout << l << endl;
        }
    }

    return 0;
}

数的三次方根


#include <iostream>

using namespace std;

int main()
{
    double x;       //设置一个double类型的 x
    
    cin >> x;   //输入x

    double l = -100, r = 100;
    while (r - l > 1e-8)
    {
        double mid = (l + r) / 2;
        if (mid * mid * mid >= x) r = mid;     //说明 应该 在 左半边 寻找
        else l = mid;
    }

    printf("%.6lf\n", l);
    return 0;
}

高精度加法

#include <iostream>
#include <vector>

using namespace std;

vector<int> add(vector<int> &A, vector<int> &B)
{
    if (A.size() < B.size()) return add(B, A);

    vector<int> C;
    int t = 0;             //t表示 进位
    for (int i = 0; i < A.size(); i ++ )
    {
        t += A[i];         //A[i]是头一个 数字 必须 要 加的
        if (i < B.size()) t += B[i];        //如果 在 长度 之内，继续加B[i]
        C.push_back(t % 10);            //将 余数 放到 数组C中
        t /= 10;        //t/=10，表示 进位
    }

    if (t) C.push_back(t);      //如果t还是 有的话，继续  进位
    return C;
}

int main()
{
    string a, b;
    vector<int> A, B;
    cin >> 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');

    auto C = add(A, B);     //相加

    for (int i = C.size() - 1; i >= 0; i -- ) cout << C[i];     //然后 倒着 输出 出来就是 结果
    cout << endl;

    return 0;
}

高精度减法

6,color_FFFFFF,t_70)

#include <iostream>
#include <vector>

using namespace std;

bool cmp(vector<int> &A, vector<int> &B)
{
    if (A.size() != B.size()) return A.size() > B.size();       //如果A，B长度 不同，如果A的长度>B的长度，返回true，否则返回 false

    //这里表示A，B的长度 相同，从高位开始 比较，如果A的某一位不等于B的某一位，则如果A[i]>B[i]，则直接返回true
    for (int i = A.size() - 1; i >= 0; i -- )
        if (A[i] != B[i])
            return A[i] > B[i];

    return true;
}

vector<int> sub(vector<int> &A, vector<int> &B)
{
    vector<int> C;
    for (int i = 0, t = 0; i < A.size(); i ++ )
    {
        t = A[i] - t;               //t表示 当前这一位的值
        if (i < B.size()) t -= B[i];
        C.push_back((t + 10) % 10);         //如果t<0，则需要借一位则为10
        if (t < 0)          //t<0,表示 有进位，则t为1，因为 再次循环的话，需要-t
            t = 1;
        else       //否则，表示 没有 进位
            t = 0;
    }
    
    //下面这一步 是 去掉 前导0  比如123-120 得到的 结果 是003，所以 这一步的 作用是 去掉0
    while (C.size() > 1 && C.back() == 0) C.pop_back();             //C.back()表示C的最后 一位，如果为0，则直接 干掉
    return C;
}

int main()
{
    string a, b;
    vector<int> A, B;
    cin >> 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;

    if (cmp(A, B)) C = sub(A, B);           //如果A>B，则直接 减
    else C = sub(B, A), cout << '-';            //如果A<B，则B-A，完了，加上 负号

    for (int i = C.size() - 1; i >= 0; i -- ) cout << C[i];
    cout << endl;

    return 0;
}

高精度乘法


#include <iostream>
#include <vector>

using namespace std;


vector<int> mul(vector<int> &A, int b)
{
    vector<int> C;

    int t = 0;          //t表示 当前 这一位的 数字 
    for (int i = 0; i < A.size() || t; i ++ )         //t不为0
    {
        if (i < A.size()) t += A[i] * b;
        C.push_back(t % 10);
        t /= 10;
    }

    while (C.size() > 1 && C.back() == 0) C.pop_back();

    return C;
}


int main()
{
    string a;
    int b;          

    cin >> a >> b;      //输入a，b 用 a 乘 b

    vector<int> A;
    for (int i = a.size() - 1; i >= 0; i -- ) A.push_back(a[i] - '0');         //将A放进去

    auto C = mul(A, b);         //直接 相乘

    for (int i = C.size() - 1; i >= 0; i -- ) printf("%d", C[i]);           //i=C.size()-1

    return 0;
}

高精度除法

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

using namespace std;

vector<int> div(vector<int> &A, int b, int &r)
{
    vector<int> C;
    r = 0;      //r表示  余数  
    for (int i = A.size() - 1; i >= 0; i -- )
    {
        r = r * 10 + A[i];
        C.push_back(r / b);
        r %= b;
    }
    reverse(C.begin(), C.end());                            
    while (C.size() > 1 && C.back() == 0) C.pop_back();
    return C;
}

int main()
{
    string a;
    vector<int> A;

    int B;
    cin >> a >> B;
    for (int i = a.size() - 1; i >= 0; i -- ) A.push_back(a[i] - '0');

    int r;      //r表示 余数
    auto C = div(A, B, r); 

    for (int i = C.size() - 1; i >= 0; i -- ) cout << C[i];

    cout << endl << r << endl;

    return 0;
}

前缀和


#include<iostream>
using namespace std;

const int maxn=1000010;

int n,m;

int a[maxn],s[maxn];

int main()
{
    cin >> n >> m;
    for(int i=1; i<=n; i++)
        cin >> a[i];

    for(int i=1; i<=n; i++)
        s[i]=s[i-1]+a[i];

    while(m--)
    {
        int l,r;
        cin >> l >> r;
        cout << s[r]-s[l-1] << endl;
    }

    return 0;
}

子矩阵的和

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#include <iostream>

using namespace std;

const int N = 1010;

int n, m, q;
int s[N][N];

int main()
{
    scanf("%d%d%d", &n, &m, &q);

    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= m; j ++ )
            scanf("%d", &s[i][j]);          //输入 每个 位置 上的 数字

    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= m; j ++ )
            s[i][j] += s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1];     //s[i][j]+=s[i-1][j]+s[i][j-1]-s[i-1][j-1]

    while (q -- )
    {
        int x1, y1, x2, y2;
        scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
        printf("%d\n", s[x2][y2] - s[x1 - 1][y2] - s[x2][y1 - 1] + s[x1 - 1][y1 - 1]);      //
    }

    return 0;
}

差分

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#include <iostream>

using namespace std;

const int N = 100010;

int n, m;
int a[N], b[N];

void insert(int l, int r, int c)
{
    b[l] += c;
    b[r + 1] -= c;
}

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i ++ ) scanf("%d", &a[i]);      //输入n个数字

    for (int i = 1; i <= n; i ++ ) insert(i, i, a[i]);
    //此时b[i]表示的是a[i]的差分，就是b[i]=a[i]-a[i-1]，反过来a是b的前缀和，比如a[3]=b[1]+b[2]+b[3]


    while (m -- )
    {
        int l, r, c;
        scanf("%d%d%d", &l, &r, &c);
        insert(l, r, c);        //l到r这个 区间 每个 数字 加上 c
    }

    for (int i = 1; i <= n; i ++ ) b[i] += b[i - 1];        //由于b是a的差分，所以

    for (int i = 1; i <= n; i ++ ) printf("%d ", b[i]);

    return 0;
}

差分矩阵

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述


#include <iostream>

using namespace std;

const int N = 1010;

int n, m, q;
int a[N][N], b[N][N];

void insert(int x1, int y1, int x2, int y2, int c)
{
    b[x1][y1] += c;
    b[x2 + 1][y1] -= c;
    b[x1][y2 + 1] -= c;
    b[x2 + 1][y2 + 1] += c;
}

int main()
{
    scanf("%d%d%d", &n, &m, &q);        //输入n行，m列，q个询问

    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= m; j ++ )
            scanf("%d", &a[i][j]);                    //输入 a[i][j]

    for (int i = 1; i <= n; i ++ )          //这是对b数组的  一种 小操作
        for (int j = 1; j <= m; j ++ )
            insert(i, j, i, j, a[i][j]);

    while (q -- )
    {
        int x1, y1, x2, y2, c;          
        cin >> x1 >> y1 >> x2 >> y2 >> c;           //输入x1,y1,x2,y2,c
        insert(x1, y1, x2, y2, c);      
    }

    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= m; j ++ )
            b[i][j] += b[i - 1][j] + b[i][j - 1] - b[i - 1][j - 1];

    for (int i = 1; i <= n; i ++ )
    {
        for (int j = 1; j <= m; j ++ ) printf("%d ", b[i][j]);
        puts("");
    }

    return 0;
}

最长连续不重复子序列

在这里插入图片描述

在这里插入图片描述

自己根据 例子 写写 就出来了


#include <iostream>

using namespace std;

const int N = 100010;

int n;
int q[N], s[N];     //s数组 存放的是 每个 数字 出现 多少次

int main()
{
    scanf("%d", &n);a
    for (int i = 0; i < n; i ++ ) scanf("%d", &q[i]);

    int res = 0;
    for (int i = 0, j = 0; i < n; i ++ )
    {
        s[q[i]] ++ ;        //在s中 将 q[i] 对应的值 ++
        while (j < i && s[q[i]] > 1) s[q[j ++ ]] -- ;
        res = max(res, i - j + 1);
    }

    cout << res << endl;

    return 0;
}

数组元素的目标和


#include <iostream>

using namespace std;

const int N = 1e5 + 10;

int n, m, x;
int a[N], b[N];

int main()
{
    scanf("%d%d%d", &n, &m, &x);
    for (int i = 0; i < n; i ++ ) 
        scanf("%d", &a[i]);
    for (int i = 0; i < m; i ++ ) 
        scanf("%d", &b[i]);

    //双指针 思路
    for (int i = 0, j = m - 1; i < n; i ++ )        //i去遍历 a数组，j去遍历b数组
    {
        while (j >= 0 && a[i] + b[j] > x)
            j -- ;
        if (j >= 0 && a[i] + b[j] == x) 
            cout << i << ' ' << j << endl;
    }

    return 0;
}

判断子序列

在这里插入图片描述
在这里插入图片描述

#include <iostream>
#include <cstring>

using namespace std;

const int N = 100010;

int n, m;
int a[N], b[N];

int main()
{
    scanf("%d%d", &n, &m);
    
    for (int i = 0; i < n; i ++ ) 
        scanf("%d", &a[i]);             //输入a数组
        
    for (int i = 0; i < m; i ++ ) 
        scanf("%d", &b[i]);                 //输入b数组

    int i = 0, j = 0;
    while (i < n && j < m)
    {
        if (a[i] == b[j])
            i ++ ;
        j ++ ;                          //从前往后 扫描 b这个 数组
    }

    if (i == n) puts("Yes");
    else puts("No");

    return 0;
}

二进制中1的个数

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#include <iostream>

using namespace std;

int main()
{
    int n;
    scanf("%d", &n);        //输入n
    
    while (n -- )
    {
        int x, s = 0;
        scanf("%d", &x);        //x表示当前输入的 数字

        for (int i = x; i; i -= i & -i) 
            s ++ ;

        printf("%d ", s);
    }

    return 0;
}

区间和

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述



//下标就是 映射的值

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

using namespace std;

typedef pair<int, int> PII;

const int N = 300010;  //n，m的取值范围是10^5，由于n个位置和m个查询，一个是n+2m,m个查询有两个下标，有可能查询的这两个下标不在n给出的中

int n, m;           //这个值 是 n和m
int a[N], s[N];         //s数组表示 前缀和
//a数组 是  存的 数

vector<int> alls;       //alls存储的是 所有 离散化后的值

vector<PII> add, query;     //将 插入和 查询的 操作读入到 add和query中

int find(int x)     //求x离散化后的 结果
{
    int l = 0, r = alls.size() - 1;
    //通过 二分 的 方式 找到 大于x的最小的数字
    while (l < r)
    {
        int mid = l + r >> 1;
        if (alls[mid] >= x) r = mid;
        else l = mid + 1;
    }
    return l + 1;           //映射 为 从1开始
}



int main()
{
    cin >> n >> m;                 //输入n和m

    for (int i = 0; i < n; i ++ )
    {
        int x, c;
        cin >> x >> c;          
        add.push_back({x, c});      //将所有操作 放入 add中   在下标为x的位置加上c
        alls.push_back(x);      //这个x其实 就是 离散化后的值，放入到alls中
    }

    for (int i = 0; i < m; i ++ )
    {
        int l, r;
        cin >> l >> r;          //读入所有的 左右 区间
        query.push_back({l, r});        //将要查询的结果放入到  query中

        alls.push_back(l);
        alls.push_back(r);      //同时也要将 左右下标 放入到 alls中
    }

    // 去重
    sort(alls.begin(), alls.end());         //先对alls进行 排序
    alls.erase(unique(alls.begin(),alls.end()), alls.end());       //去除掉alls中的 重复 元素

    // 处理插入操作
    for (auto item : add)
    {
        int x = find(item.first);           //x其实就是 离散化 后的  下标
        a[x] += item.second;        //在这个位置 加上 item.second
    }

    // 预处理前缀和
    for (int i = 1; i <= alls.size(); i ++ ) s[i] = s[i - 1] + a[i];

    // 处理询问
    for (auto item : query)
    {
        int l = find(item.first), r = find(item.second);        //直接处理完 左右 边的 下标
        cout << s[r] - s[l - 1] << endl;        //直接 输出 结果
    }

    return 0;
}

区间合并

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述


#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

const int maxn=100010;

int n;

vector<pair<int,int>> seg;

void merge(vector<pair<int,int>> &seg)
{
    vector<pair<int,int>> res;

    sort(seg.begin(),seg.end());

    int st=-2e9,ed=-2e9;

    for(auto item:seg)
        if(ed<item.first)
        {
                if(st!=-2e9)
                {
                    res.push_back({st,ed});
                }
                st=item.first,ed=item.second;
        }
        else
        {
            ed=max(ed,item.second);
        }

    if(st!=-2e9)
    res.push_back({st,ed});

    seg=res;

}

int main()
{
    cin >> n;
    for(int i=0; i<n; i++)
    {
        int l,r;
        cin >> l >> r;
        seg.push_back({l,r});
    }

    merge(seg);

    cout << seg.size();

    return 0;
}
wsfhdhjs
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第二讲 数据结构
wsfhdhjs的博客
05-09 305
单链表 #include <iostream> using namespace std; const int N = 100010; // head 表示头结点的下标 // e[i] 表示节点i的值 // ne[i] 表示节点i的next指针是多少 // idx 存储当前已经用到了哪个点 int head, e[N], ne[N], idx; // 初始化 void init() { head = -1; idx = 0; } // 将x插到头结点 void
第1章绪论第5讲-算法分析基础1
02-15
数据结构第5版教程视频
第二周学习总结
qq_52641489的博客
01-28 297
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、栈、队列、串二、二分1.整数型二分2.浮点型二分三、前缀和与差分1.前缀和2.差分四、位运算总结 提示：以下是本篇文章正文内容，下面案例可供参考 一、栈、队列、串 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、二分 1.整数型二分 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.pyplot a
用数组模拟双链表
J-Proton博客
10-08 177
#include<iostream> using namespace std; const int N = 100010; int l[N],r[N],e[N],idx; void add(int k,int x){ e[idx] = x; l[idx] = k; r[idx] = r[k]; l[r[k]] = idx; r[k] = idx;...
一些高效技巧与算法-学习笔记
null
03-31 110
打表 用空间换时间的技巧，一般指将所有可能需要用到的结果事先计算出来，这样后面需要用到时就可以直接查表获得。 常见用法： 1.在程序中一次性计算出所有需要用到的结果，之后的查询直接取这些结果 这是最常用到的用法，在一个需要查询大量Fibonacci数F(n)的问题中，显然每次从头开始计算是非常耗时的，对q次查询会产生nq的时间复杂度；如果进行预处理，即把所有Fibonacci数预先计算并存在数组中，那么每次查询就只需要O(1)的时间复杂度，q次查询只需要n+q的时间复杂度。 2.在程序b中分一次或多次计算出
acwing算法基础课(第一讲 基础算法)(1)
2401_84584817的博客
05-16 732
阿里伤透我心，疯狂复习刷题，终于喜提offer 哈哈~好啦，不闲扯了1、JAVA面试核心知识整理（PDF）：包含JVMJAVA集合JAVA多线程并发，JAVA基础，Spring原理微服务，Netty与RPC，网络，日志，ZookeeperKafkaRabbitMQ，Hbase，MongoDB设计模式负载均衡数据库一致性哈希JAVA算法数据结构，加密算法，分布式缓存，Hadoop，Spark，Storm，YARN，机器学习，云计算共30个章节。2、Redis学习笔记及学习思维脑图。
算法零基础100讲 第一讲
weixin_43752644的博客
03-13 1126
题目描述：给你一个整数 n，请你判断该整数是否是 2 的幂次方。如果是，返回 true ；否则，返回 false 。 如果存在一个整数 x 使得 n == 2x ，则认为 n 是 2 的幂次方。 leetcode地址 bool isPowerOfTwo(int n){ if(n==0){ return false; } int x = (int)(log2(n)+1e-8); return fabs(n - pow(2,
算法基础课：第一讲——基础算法
m0_52806260的博客
07-02 635
包括快速排序、归并排序、二分、高精度、前缀和与差分、双指针、位运算、离散化、区间合并
《算法零基础》第16讲 ：变量交换算法
Sauron7i的博客
11-05 1681
位操作：变量交换算法
《零基础学算法》（第一讲）位运算的奇技淫巧
Ceylan__的博客
04-22 1341
《零基础算法小课堂》（第一讲）位运算，学会位运算的奇技淫巧，你不来看看吗？
【算法基础——第八讲】离散化
m0_63233163的博客
05-05 3791
大家好，我是quicklysleep，欢迎大家光临我的博客,算法学习笔记系列持续更新中~ 文章目录一、前言二、排序算法的介绍三、排序算法的运用1.快速排序模板2.冒泡排序模板3.归并排序模板最后 一、前言 排序算法是最基本的算法之一。 二、排序算法的介绍 排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排.
第1章绪论第5讲-算法分析基础2
02-15
数据结构第5版教学视频
第2讲matlab基础完整.pptx
11-14
MATLAB是一种高性能的计算语言和开发环境，广泛应用于科学计算、数据分析、可视化、算法开发等领域。本资源摘要信息将对MATLAB的基础知识点进行总结，涵盖MATLAB的基本使用方式、常用的操作命令和快捷键、信息类型、...
acwing算法第三讲
04-30
acwing算法第三讲 -acwing算法第三讲中，闫学灿强调了编程语言语法是次要的，思维是主要的。学习循环语句需要抓住一个要点——代码执行顺序。 一、 while 循环 while 循环可以简单理解为循环版的 if 语句。如果...
自动驾驶控制算法第一讲1
08-03
在龚建伟的《无亙驾驶车辆模型预测控制》第二版中，尽管可能存在着一些错误，但MPC方法的核心思想是通过预测未来一段时间内的车辆动态行为，来制定当前的最佳控制决策。这种方法能够考虑系统的约束和多目标优化，...
2024.8.24.zip
08-25
2024.8.24.zip
中国移动实习项目-车票管理系统_ticket-management-system.zip
最新发布
08-25
中国移动实习项目-车票管理系统_ticket-management-system
ant-design-3.20.4.zip
08-25
ant-design，一套企业级 UI 设计语言和 React 组件库 提炼自企业级中后台产品的交互语言和视觉风格 开箱即用的高质量 React 组件
NOS量表（英文）.pdf
08-25
NOS量表（英文）.pdf
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值