记录最近做的算法题

最新推荐文章于 2024-09-03 20:45:39 发布
最新推荐文章于 2024-09-03 20:45:39 发布
阅读量37 收藏
点赞数
文章标签： 算法 数据结构 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43983809/article/details/134039552
版权

P1972 [SDOI2009] HH的项链

P1972 [SDOI2009] HH的项链

题意是给你n个数，再给你m个查询，每次查询一个[l,r],求询问的区间内有多少种不同的数字。
这个题可以使用离线处理+树状数组的方式来处理。

#include <iostream>
#include<cstring>
#include<vector>
#include<algorithm>
#include<tuple>
using namespace std;
const int N = 1e6 + 5;
int tree[N];
int vis[N];
int arr[N];
tuple<int,int, int> qk[N];
int get_lowbit(int i) {
    return i&(-i);
}
void add(int i,int v) {
    while (i < N) {
        tree[i] += v;
        i += get_lowbit(i);
    }
}
int ask(int i) {
    int ans=0;
    if(i == 0)return 0;
    while (i)
    {
        ans+=tree[i];
        i-=get_lowbit(i);
    }
    return ans;
}
int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int n;
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>arr[i];
    }
    int m;
    cin>>m;
    for (int i = 0; i < m; i++) {
        int l,r;
        cin>>l>>r;
        get<0>(qk[i]) = l, get<1>(qk[i]) = r, get<2>(qk[i]) = i;
    }
    sort(qk, qk+m,[](const tuple<int, int, int>&p1, const tuple<int, int, int>& p2){
        return get<1>(p1) < get<1>(p2);
    });
    memset(vis, 0,sizeof vis);
    int idx = 0;
    vector<int>ans(m,0);
    for (int i = 1; i <= n; i++) {

        if (!vis[arr[i]]) {
            vis[arr[i]] = i;
        }
        else {
            add(vis[arr[i]], -1);
            vis[arr[i]] = i;
        }
        add(vis[arr[i]], 1);
        while ( idx <m && get<1>(qk[idx]) == i) {
            int l = get<0>(qk[idx]), r = get<1>(qk[idx]);
            ans[get<2>(qk[idx])] = ask(r) - ask(l-1);
            idx++;
            
        }
        if(idx == m)break;
    }
    for (int i = 0; i < m; i++) {
        cout<<ans[i]<<endl;
    }

}

树上颜色数目

树上颜色数目

给出一棵 n 个节点以 1 为根的树，节点 u 的颜色为 c_u，现在对于每个结点 u 询问 u 子树里一共出现了多少种不同的颜色。

dfs序+dus，

#include <iostream>
#include<cstring>
using namespace std;
const int N=1e5+5;
int h[N],e[N<<1], nx[N<<1];
int cnt=1;
int color[N];
int colorCnt[N];
int totColor = 0;
void add_edge(int a,int b){
  e[cnt] = b, nx[cnt] = h[a], h[a] = cnt++;
}
void add(int i){
    if(colorCnt[color[i]]==0)totColor++;
    colorCnt[color[i]]++;
}
void del(int i){
    colorCnt[color[i]]--;
    if(colorCnt[color[i]]==0)totColor--;
    
}
int big[N];
int son[N];
int ans[N];
int L[N], R[N],time1 = 0, Node[N];
void dfs0(int u,int f){
    int v = 0;
    L[u] = ++time1;
    Node[time1] = u;
    for(int i=h[u];i;i=nx[i]){
        int t=e[i];
        if(t!=f){
            dfs0(t,u);
            if(!big[u] || son[t] > v){
                v = son[t];
                big[u] = t;
            }
        }
    }
    R[u] = time1;
}

void dfs1(int u,int f, bool keep){
    for(int i=h[u];i;i=nx[i]){
        int t=e[i];
        if(t!=f && t!=big[u]){
            dfs1(t, u, false);
        }
    }
    if(big[u]){
        dfs1(big[u], u, true);
    }
    for(int i=h[u];i;i=nx[i]){
        int t=e[i];
        if(t!=f && t!=big[u]){
            for(int j=L[t];j<=R[t];j++){
                add(Node[j]);
            }
        }
    }
    add(u);
    ans[u] = totColor;
    if(!keep){
        for(int i=L[u];i<=R[u];i++){
            del(Node[i]);
        }
    }
}
int main()
{
    int n;
    cin>>n;
    for(int i=0;i<n-1;i++){
        int a,b;
        cin>>a>>b;
        add_edge(a,b);
        add_edge(b,a);
    }
    for(int i=1;i<=n;i++)cin>>color[i];
    dfs0(1,-1);
    dfs1(1, -1, 0);
    int m;
    cin>>m;
    for(int i=0;i<m;i++){
        int mi;
        cin>>mi;
        cout<<ans[mi]<<endl;
    }
}

E. Lomsat gelral

思路差不多,只不过求的是子树最大颜色编号之和,可能存在多个最大值

#include <iostream>
#include<cstring>
#include<unordered_map>
using namespace std;
const int N=1e5+5;
int h[N],e[N<<1], nx[N<<1];
int cnt=1;
int color[N];

void add_edge(int a,int b){
  e[cnt] = b, nx[cnt] = h[a], h[a] = cnt++;
}
// unordered_map<int,int>mp;
int colorCnt[N];
long long sum = 0;
int maxc = 0; //最大颜色数量
void add(int i){
    colorCnt[color[i]]++;
    if(colorCnt[color[i]] > maxc){
        maxc = colorCnt[color[i]];
        sum  = color[i];
    }else if(colorCnt[color[i]] == maxc){
        sum += color[i];
    }
}
void del(int i){
    colorCnt[color[i]]--;
}

int big[N];
int son[N];
long long ans[N];
int L[N], R[N],time1 = 0, Node[N];
void dfs0(int u,int f){
    L[u] = ++time1;
    Node[time1] = u;
    son[u] = 1;
    for(int i=h[u];i;i=nx[i]){
        int t=e[i];
        if(t!=f){
            dfs0(t,u);
            son[u] += son[t];
            if(!big[u] || son[big[u]] < son[t]){
                big[u] = t;
            }
        }
    }
    R[u] = time1;
}

void dfs1(int u,int f, bool keep){
    for(int i=h[u];i;i=nx[i]){
        int t=e[i];
        if(t!=f && t!=big[u]){
            dfs1(t, u, false);
        }
    }
    if(big[u]){
        dfs1(big[u], u, true);
    }
    for(int i=h[u];i;i=nx[i]){
        int t=e[i];
        if(t!=f && t!=big[u]){
            for(int j=L[t];j<=R[t];j++){
                add(Node[j]);
            }
        }
    }
    add(u);
    ans[u] = sum;
    if(!keep){
        for(int i=L[u];i<=R[u];i++){
            del(Node[i]);
        }
        sum = maxc = 0;
    }
}
int main()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)cin>>color[i];
    for(int i=0;i<n-1;i++){
        int a,b;
        cin>>a>>b;
        add_edge(a,b);
        add_edge(b,a);
    }
    dfs0(1,-1);
    dfs1(1, -1, 0);
    for(int i=1;i<=n;i++){
        cout<<ans[i]<<" ";
    }
}

小蓝的疑问

树上启发式合并

#include <iostream>
#include<vector>
#include<unordered_map>
#include<tuple>
using namespace std;
unordered_map<int,int> mp;//直接用有序列表记录深度为i的最大值
int cnt=1;
const int N=1e5+5;
int h[N], nx[N], e[N];
int arr[N];
void add_edge(int a,int b){
  e[cnt] = b, nx[cnt] = h[a], h[a] = cnt++;
}
int big[N],son[N];
vector<int>ans;
vector<pair<int,int>> qk[N];
int dept[N], time1=0, L[N], R[N], Node[N];
void dfs0(int u,int d){
  L[u] = ++time1;
  Node[time1] = u;
  dept[u] = d;
  son[u] = 1;
  for(int i=h[u];i;i=nx[i]){
    int t=e[i];
    dfs0(t, d+1);
    son[u] += son[t];
    if(!big[u] || son[big[u]]< son[t]){
      big[u] = t;
    }
  }
  R[u] = time1;
}
void add(int u){
  mp[dept[u]] = max(mp[dept[u]], arr[u]);
}
void del(int u){
  mp[arr[u]]--;
}
void dfs1(int u,bool keep){
  for(int i=h[u];i;i=nx[i]){
    int t=e[i];
    if(t!=big[u]){
      dfs1(t, false);
    }
  }
  if(big[u]){
    dfs1(big[u], true);
  }
  for(int i=h[u];i;i=nx[i]){
    int t=e[i];
    if(t!=big[u]){
      for(int j=L[t];j<=R[t];j++){
        add(Node[j]);
      }
    }
  }
  add(u);
//   cout<<u<<endl;
  for(auto&[k,v]:qk[u]){
    ans[v] = mp[dept[u] + k];
  }
  if(!keep){
    mp.clear(); //所有树上信息全部清空即可 这个很重要!!!!!!!!!!!!!!!!!!!!!!!!
  }
}
int main()
{
  // 请在此输入您的代码
  int n,q;
  cin>>n>>q;
  for(int i=1;i<=n;i++){
    cin>>arr[i];
  }
  for(int i=0;i<n-1;i++){
    int a,b;
    cin>>a>>b;
    add_edge(a,b);
  }
  ans.resize(q);
  for(int i=0;i<q;i++){
    int x,k;
    cin>>x>>k;
    qk[x].push_back({k, i});
  }
  dfs0(1,1);
  dfs1(1, 0);
  for(int i=0;i<q;i++){
    cout<<ans[i]<<endl;
  }
  return 0;
}

E. Blood Cousins Return

和上一题同样思路,上一题是求节点u的第k层最大值,用unordered_map<int,int>表示第k层最大值, 这题是求节点u的第k层不重复字符串,用unordered_map<int,set< string>>存放第k层字符串集合

#include <iostream>
#include<cstring>
#include<vector>
#include <algorithm>
#include<unordered_map>
#include<set>
using namespace std;
const int N = 2e5 + 5;
int h[N], e[N], nx[N];
int cnt = 1;
void add(int a, int b) {
    e[cnt] = b, nx[cnt] = h[a], h[a] = cnt++;

}
int time1 = 0;
int c[N];
int L[N],R[N];
int Node[N];
string arr[N];
int deep[N], big[N], son[N];
void dfs(int u, int d) {
    deep[u] = d;
    L[u] = ++time1;
    Node[time1] = u;
    son[u] = 1;
    for (int i = h[u]; i; i = nx[i]) {
        int t = e[i];
        dfs(t, d + 1);
        son[u] += son[t];
        if(!big[u] || son[big[u]] < son[t]){
            big[u] = t;
        }
    }
    R[u] = time1;
}
unordered_map<int, set<string>> mp;
vector<pair<int,int>>qk[N];
vector<int>ans;
void dfs1(int u,bool keep){
    for(int i=h[u];i;i=nx[i]){
        int t=e[i];
        if(t!=big[u]){
            dfs1(t, false);
        }
    }
    if(big[u]){
        dfs1(big[u], true);
    }
    for(int i=h[u];i;i=nx[i]){
        int t=e[i];
        if(t!=big[u]){
            for(int j = L[t];j<=R[t];j++){
                mp[deep[Node[j]]].insert(arr[Node[j]]);
            }
        }
    }
    mp[deep[u]].insert(arr[u]);
    for(auto&[k,v]:qk[u]){
        ans[k] = mp[deep[u] + v].size();
    }
    if(!keep){
        mp.clear();//直接清空就可以,因为mp存放的是当前子树的信息,以后都用不上了
    }
}
int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int n, q;
    cin >> n;
    for (int i = 1; i <= n; i++) {
        int f;
        cin >> arr[i] >> f;
        add(f, i);
    }
    cin >> q;
    dfs(0, 0);
    for(int i=0;i<q;i++) {
        int v, d;
        cin >> v >> d;
        qk[v].push_back({i,d});
    }
    ans.resize(q);
    dfs1(0,0);
    for(int i=0;i<q;i++){
        cout<<ans[i]<<endl;
    }
}

D. Tree Requests

题目大意是求子树所有点重新排序是否构成回文, 思路dfs序列+二分 或者dfs+dsu(但超时了)

#include <iostream>
#include<cstring>
#include<vector>
#include <algorithm>
using namespace std;
const int N = 5e5 + 5;
int h[N], e[N], nx[N];
int cnt = 1;
void add(int a, int b) {
    e[cnt] = b, nx[cnt] = h[a], h[a] = cnt++;

}
vector<int> dep[N][26];
int time1 = 0;
int c[N];
int in[N], out[N];
void dfs(int u, int d) {
    in[u] = ++time1;
    dep[d][c[u]].push_back(time1);
    for (int i = h[u]; i; i = nx[i]) {
        int t = e[i];
        dfs(t, d + 1);
    }
    out[u] = time1;
}
int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int n, q;
    cin >> n >> q;
    for (int i = 2; i <= n; i++) {
        int f;
        cin >> f;
        add(f, i);
    }
    string str;
    cin >> str;
    for (int i = 1; i <= n; i++) {
        c[i] = str[i - 1] - 'a';
    }
    dfs(1, 1);
    while (q--) {
        int v, d;
        cin >> v >> d;
        int in_t = in[v], out_t = out[v];
        int sum = 0;
        for (int i = 0; i < 26; i++) {
            if ((upper_bound(dep[d][i].begin(), dep[d][i].end(), out_t) - upper_bound(dep[d][i].begin(), dep[d][i].end(), in_t)) & 1) {
                sum++;
            }
            if (sum > 1)break;
        }
        if (sum > 1) {
            cout << "No\n";
        }
        else {
            cout << "Yes\n";
        }

    }

}

dsu on tree

#include <iostream>
#include<cstring>
#include<vector>
#include <algorithm>
#include<unordered_map>
#include<set>
using namespace std;
const int N = 5e5 + 5;
int h[N], e[N], nx[N];
int cnt1 = 1;
void add(int a, int b) {
    e[cnt1] = b, nx[cnt1] = h[a], h[a] = cnt1++;

}
int time1 = 0;
int c[N];
int L[N],R[N];
int Node[N];
int deep[N], big[N], son[N];
void dfs(int u, int d) {
    deep[u] = d;
    L[u] = ++time1;
    Node[time1] = u;
    son[u] = 1;
    for (int i = h[u]; i; i = nx[i]) {
        int t = e[i];
        dfs(t, d + 1);
        son[u] += son[t];
        if(!big[u] || son[big[u]] < son[t]){
            big[u] = t;
        }
    }
    R[u] = time1;
}
int cnt[N][26];
vector<pair<int,int>>qk[N];
vector<int>ans;
void dfs1(int u,bool keep){
    for(int i=h[u];i;i=nx[i]){
        int t=e[i];
        if(t!=big[u]){
            dfs1(t, false);
        }
    }
    if(big[u]){
        dfs1(big[u], true);
    }
    for(int i=h[u];i;i=nx[i]){
        int t=e[i];
        if(t!=big[u]){
            for(int j = L[t];j<=R[t];j++){
                cnt[deep[Node[j]]][c[Node[j]]]++;
            }
        }
    }
    cnt[deep[u]][c[u]]++;
    for(auto&[k,v]:qk[u]){
        int sum = 0;
        for(int i=0;i<26;i++){
            sum += cnt[v][i]&1;
        }
        ans[k] = sum;
    }
    if(!keep){
        for(int j = L[u];j<=R[u];j++){
            cnt[deep[Node[j]]][c[Node[j]]]--;
        }
    }
}
int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int n, q;
    cin >> n>>q;
    for (int i = 2; i <=n; i++) {
        int f;
        cin>>f;
        add(f, i);
    }
    string str;
    cin>>str;
    for(int i=1;i<=n;i++){
        c[i] = str[i-1]-'a';
    }
    dfs(1, 1);
    for(int i=0;i<q;i++) {
        int v, d;
        cin >> v >> d;
        qk[v].push_back({i,d});
    }
    ans.resize(q);
    dfs1(1,0);
    for(int i=0;i<q;i++){
        cout<<(ans[i] <=1 ? "Yes":"No")<<endl;
    }
}

E. Vasya and a Tree

dfs序+树状数组

#include <iostream>
#include<cstring>
#include<vector>
using namespace std;
const int N=3e5+5;
int h[N],e[N<<1], nx[N<<1];
int cnt=1;
long long tree[N];
long long ans[N];
int get_lowbit(int i){
    return i&(-i);
}
void add(int i,int j){
    while(i<N){
        tree[i] += j;
        i+=get_lowbit(i);
    }
}
long long ask(int i){
    long long ans=0;
    while(i){
        ans+=tree[i];
        i-=get_lowbit(i);
    }
    return ans;
}
void add_edge(int a,int b){
  e[cnt] = b, nx[cnt] = h[a], h[a] = cnt++;

}
vector<pair<int,int>> qt[N];
void dfs(int u,int f,int d){
    for(auto&[dt,x]:qt[u]){
        add(d, x);
        add(d+dt+1, -x);
    }
    ans[u] = ask(d);
    for(int i=h[u];i;i=nx[i]){
        int t=e[i];
        if(t!=f){
            dfs(t, u, d+1);
        }
    }
    for(auto&[dt,x]:qt[u]){
        add(d, -x);
        add(d+dt+1, x);
    }
    
}
int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int n;
    cin>>n;
    for(int i=0;i<n-1;i++){
        int a,b;
        cin>>a>>b;
        add_edge(a, b);
        add_edge(b, a);
    }
    int q;
    cin>>q;
    while(q--){
        int v,d,x;
        cin>>v>>d>>x;
        qt[v].push_back({d,x});
    }
    dfs(1, -1, 1);
    for(int i=1;i<=n;i++){
        cout<<ans[i]<<" ";
    }
}
qq_43983809
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
前端面试算法题1
08-03
它的基本思想是通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，然后分别对这两部分记录继续进行排序，以达到整个序列有序。 ```javascript function quickSort(arr) { ...
记录关于Codeforces, AtCoder, Luogu, Acwing等OJ上算法题的代码
07-03
记录关于Codeforces, AtCoder, Luogu, Acwing等OJ上算法题的代码
算法题总结 2741
08-08
11. **和为 s 的两个数字**：经典的哈希表应用，通过哈希表记录每个数字出现的次数，快速找到和为s的两个数。 12. **和为 s 的连续正数序列**：涉及滑动窗口的概念，找到和为s的最长连续正数序列。 13. **数组中...
2023美赛Z题记录.zip
02-03
Z题通常具有较高的难度和挑战性，可能涉及复杂的数据分析、算法设计、模拟实验等多个方面。因此，解压缩后的文件可能包括以下内容： 1. **论文文档**：参赛队伍撰写的论文，详细介绍了他们对Z题的理解、所采用的...
大数据常见算法题.txt
06-21
此题，在我之前的一篇文章算法里头有所提到，当时给出的方案是：IP的数目还是有限的，最多2^32个，所以可以考虑使用hash将ip直接存入内存，然后进行统计。 再详细介绍下此方案：首先是这一天，并且是访问百度的日志...
算法的学习笔记—连续子数组的最大和
业精于勤，荒于嬉
08-29 3696
通过上述的动态规划方法，我们能够有效地解决连续子数组的最大和问题。该方法简单易懂，并且具有较高的效率，适合在大多数情况下使用。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybits🤔欢迎大家加入我的社区尘觉社区文章到这里就结束了，如果有什么疑问的地方请指出，诸佬们一起来评论区一起讨论😁如果帮助到您不妨3连支持一下，创造不易您们的支持是我的动力🤞。
Leetcode42接雨水（单调栈）
AGNING的博客
08-28 459
维护一个栈，满足从栈底到栈顶元素大小递减。如果当前元素高于栈顶，且栈内有至少2个元素，则形成了一个凹槽，及一个图中横着的红色矩形，将它的面积累加即可，第一次写难在维护单调栈中计算面积和。求出前缀最大和后缀最大，用两者较小值减去当前高度，累加即可，这个思路容易想到，这里不赘述。
【算法】C++贪心算法解题（单调递增数字、坏了的计算器、合并区间）
卜及中的博客
09-03 371
【算法】贪心算法解析：基本概念、策略证明与代码例题演示。
LeetCode LCR088.使用最小花费爬楼梯
m0_63816268的博客
09-03 675
动态规划
第四讲：拟合算法
PGeorge6的博客
09-03 930
与插值问题不同，在拟合问题中不需要曲线一定经过给定的点。拟合问题的目标是寻求一个函数(曲线)使得该曲线在某种准则下与所有的数据点最为接近，即曲线拟合的最好(最小化损失函数)。插值算法中，得到的多项式f(x)要经过所有样本点。但是如果样本点太多，那么这个多项式次数过高，会造成龙格现象。尽管我们可以选择分段的方法避免这种现象，但是更多时候我们更倾向于得到-个确定的曲线，尽管这条曲线不能经过每一个样本点，但只要保证误差足够小即可，这就是拟合的思想。(拟合的结果是得到一个确定的曲线)
递归、搜索与回溯算法
无聊_人的博客
08-29 7799
所谓的递归其实就是函数自己调用自己的情况。
力扣（无重叠区间）
yyssas的博客
08-29 8557
先按照左侧数字排序，然后对于i位置和i+1位置，如果i位置右侧数字大于i+1位置左侧数字，则说明这两个区间有重叠，则需要移除更可能和后面重叠的那一个，因为排序是按照左边从小到大排序的，所以左边一定是小的，此时要关注的就是右边，也就是选择i和i+1右侧更小的那个，即右侧大的那个删除。一直到右侧小于k的左侧停止，此时剩下的一定是不会重叠的那个。需要移除区间的最小数量，使剩余区间互不重叠。
P7492 [传智杯 #3 决赛] 序列
最新发布
summ1ts的博客
09-03 180
的数组，表示区间内所有数的二进制表示下某一位是否为1，但这太难写，最后无奈去看官方题解，发现只要维护区间所有数的按位与和And，如果(And&k)==k的话那就不用修改了。那样的话这个题就很简单了，维护最大子段和可以见。一道类似势能线段树的题，区间按位或上k，不满足区间可合并的性质，只能暴力的单点修改。，如果我们能找到一个方法，能够判定区间里的数，或上k后是否有改变，就可以避免。至于时间复杂度用类似势能分析的方法分析一波就行了，时间复杂度。我一开始想的是线段树里维护一个。但是考虑按位或的性质，
57. 插入区间【 力扣(LeetCode) 】
yyh520025的博客
08-29 4568
给你一个 无重叠的 ，按照区间起始端点排序的区间列表 intervals，其中 intervals[i] = [starti, endi] 表示第 i 个区间的开始和结束，并且 intervals 按照 starti 升序排列。同样给定一个区间 newInterval = [start, end] 表示另一个区间的开始和结束。在 intervals 中插入区间 newInterval，使得 intervals 依然按照 starti 升序排列，且区间之间不重叠（如果有必要的话，可以合并区间）。
备战秋招60天算法挑战，Day30
溜达虎的博客
09-03 214
给你一个字符串 和一个字符串列表 作为字典。请你判断是否可以利用字典中出现的单词拼接出 。注意：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。举个例子： 视频题解 单词拆分 思路来源 思路来源 知识回顾 动态规划是一种通过将原问题分解为子问题来求解复杂问题的算法思想。它通常用于求解最优化问题，例如最长公共子序列、背包问题等。动态规划的核心思想是将原问题分解为若干个子问题，通过求解子问题的最优解推导出原问题的最优解。可以通过两点来判断一个问题能不能通过动态规划来解，一是该问题是否存在递
算法训练营|图论第8天 拓扑排序 dijkstra
qq_53125539的博客
09-02 368
拓扑排序。
精选算法编程题
A18937260063的博客
08-30 3713
数组编程
冒泡排序算法
m0_74051652的博客
08-28 1409
冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复进行的，直到没有再需要交换的元素为止，这意味着数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（或说是排序的开头位置），就如同水中的气泡一样上升到水面。冒泡排序的写法可以简单分为两种方式，分别是：前同后异、前异后同。
循环结构程序
BlueBachke的博客
09-03 344
循环结构的基础知识
数据结构与算法面试题解析
"数据结构与算法面试题目记录，包含了字节跳动和腾讯公司的面试题，涉及快速排序、二分查找、动态规划、单调队列、大数运算、归并排序、链表排序、完全平方数、动态规划优化、字符串处理、数组操作以及概率计算等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

qq_43983809

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值