iis服务器助手广告广告
返回顶部
首页 > 资讯 > 后端开发 > 其他教程 >C语言详解数据结构与算法中枚举和模拟及排序
  • 661
分享到

C语言详解数据结构与算法中枚举和模拟及排序

2024-04-02 19:04:59 661人浏览 八月长安
摘要

目录枚举连号区间数递增三元组二分双指针前缀和模拟特别数的和错误票据排序快速排序归并排序枚举 连号区间数 来源:第四届蓝桥杯省赛c++B组,第四届蓝桥杯省赛JAVAB组 小明这些天一直

枚举

连号区间数

来源:第四届蓝桥杯省赛c++B组,第四届蓝桥杯省赛JAVAB组

小明这些天一直在思考这样一个奇怪而有趣的问题:

在 1∼N 的某个排列中有多少个连号区间呢?

这里所说的连号区间的定义是:

如果区间 [L,R] 里的所有元素(即此排列的第 L 个到第 R 个元素)递增排序后能得到一个长度为 R−L+1 的“连续”数列,则称这个区间连号区间。

当 N 很小的时候,小明可以很快地算出答案,但是当 N 变大的时候,问题就不是那么简单了,现在小明需要你的帮助。

输入格式
第一行是一个正整数 N,表示排列的规模。

第二行是 N 个不同的数字 Pi,表示这 N 个数字的某一排列。

输出格式
输出一个整数,表示不同连号区间的数目。

数据范围
1≤N≤10000,
1≤Pi≤N

输入样例1:

4
3 2 4 1

输出样例1:

7

输入样例2:

5
3 4 2 5 1

输出样例2:

9

样例解释
第一个用例中,有 7 个连号区间分别是:[1,1],[1,2],[1,3],[1,4],[2,2],[3,3],[4,4]
第二个用例中,有 9 个连号区间分别是:[1,1],[1,2],[1,3],[1,4],[1,5],[2,2],[3,3],[4,4],[5,5]

先来看暴力做法

先两次for()循环,对给出的数排序,然后再对区间内的数做判断,如果连续的就res++。

#include <bits/stdc++.h>

using namespace std;

const int N=10010;

int a[N],bac[N];

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

    for(int i=1;i<=n;i++)
       for(int j=i;j<=n;j++){
            memcpy(bac,a,sizeof a); // 这里要把数组的初始状态存在bac数组中,因为每次sort排序后,数组的顺序会发生改变。
            sort(a+i,a+j+1);

            bool flag=true;
            for(int k=i;k<j;k++){ 
                if(a[k+1] - a[k] != 1){
                    flag=false;
                    break;
                }
            }

            if(flag) res++;
            memcpy(a,bac,sizeof a); // 还原数组a的初始状态
        }
    cout << res << endl;
    return 0;
}

但是这道题暴力做法在蓝桥杯中只能得60分,然后我们再来想一下怎么优化

这里设两层循环,一层i表示左端点,第二层j表示右端点。如果要保持连续性的话那么有一个思路:因为是连续的所以在所取的[l,r]范围中寻找最大值,最小值。然后相减,最后和r-l(区间长度)作比较即可。除此之外当l=r时也算作连续
即MAX-MIN==R-L

#include <bits/stdc++.h>

using namespace std;

const int N = 10010, INF = 100000000;

int n;
int a[N];

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

    int res = 0;
    for (int i = 0; i < n; i ++ )   // 枚举区间左端点
    {
        int minv = INF, maxv = -INF;
        for (int j = i; j < n; j ++ )   // 枚举区间右端点
        {
            minv = min(minv, a[j]);
            maxv = max(maxv, a[j]);
            if (maxv - minv == j - i) res ++ ;
        }
    }

    cout << res << endl;

    return 0;
}

递增三元组

来源:第九届蓝桥杯省赛C++B组,第九届蓝桥杯省赛JAVAB组

给定三个整数数组

A=[A1,A2,…AN],
B=[B1,B2,…BN],
C=[C1,C2,…CN],

请你统计有多少个三元组 (i,j,k) 满足:

1≤i,j,k≤N
Ai<Bj<Ck
输入格式
第一行包含一个整数 N。

第二行包含 N 个整数 A1,A2,…AN。

第三行包含 N 个整数 B1,B2,…BN。

第四行包含 N 个整数 C1,C2,…CN。

输出格式
一个整数表示答案。

数据范围
1≤N≤105,
0≤Ai,Bi,Ci≤105

输入样例:

3
1 1 1
2 2 2
3 3 3

输出样例:

27

首先考虑暴力做法,三个数组嵌套枚举,O(n3)的时间复杂度,n≤105一定会超时,这里提供代码,想试一下的可以试试

//暴力做法枚举(会超时)
#include <bits/stdc++.h>

using namespace std;


const int N=10000;

int n,a[N],b[N],c[N];
int cnt=0;
int main(){
    //输入
    cin>>n;
    for(int i=0;i<n;i++) cin>>a[i];
    for(int i=0;i<n;i++) cin>>b[i];
    for(int i=0;i<n;i++) cin>>c[i];
    //运算
    for(int i=0;i<n;i++)
    	for(int j=0;j<n;j++)
    		for(int k=0;k<n;k++)
        		if(a[i]<b[j]&&b[j]<c[k])
	            cnt++;
    cout<<cnt<<endl;
    return 0;
}

尝试通过枚举的次序进行优化本题,先枚举B数组,在A中寻找小于B[i]的数的个数cnt1,在C中寻找大于B[i]的数的个数cnt2,带有B[i]的合法选择数就是cnt1*cnt2。

用暴力查找时间总的时间复杂度为O(n2),还是会超时。

二分

既然是查找,那么可以考虑进行二分查找,查找前先通过排序预处理三个数组,排序时间复杂度O(nlog2n)O(nlog2n),枚举B的所有元素+查找A,C中的元素时间复杂度也是O(nlog2n)O(nlog2n),总的时间复杂度降为O(nlog2n)

//二分查找
#include <bits/stdc++.h>

using namespace std;

const int N=100000+6;

int n,a[N],b[N],c[N];
long long res=0;
int main(){
    cin>>n;//输入
    for(int i=0;i<n;i++) cin>>a[i];
    for(int i=0;i<n;i++) cin>>b[i];
    for(int i=0;i<n;i++) cin>>c[i];
    //排序
    sort(a,a+n);sort(b,b+n);sort(c,c+n);
    //查找
    for(int i=0;i<n;i++)
    {
        int low_a=0,right_a=n-1;
        while(low_a<right_a)    //找比b[i]小的最后一个数
        {
            int mid=(low_a+right_a+1)>>1;//加1之后改为向上取整
            if(a[mid]<b[i])  low_a=mid;
            else  right_a=mid-1;
        }
        if(a[low_a]>=b[i]) low_a=-1;//所有数都大于等于b[i]的时候,low_a=-1,这样最后(low_a+1)*(n-low_b)的时候为0

        int low_b=0,right_b=n-1;
        while(low_b<right_b)   //找比b[i]大的第一个数
        {
            int mid =(low_b+right_b)>>1;
            if(c[mid]>b[i]) right_b=mid;
            else low_b=mid+1;
        }
        if(c[low_b]<=b[i]) low_b=n;//所有数都小于等于b[i]的时候,low_b=n,这样最后(low_a+1)*(n-low_b)的时候为0
        //if(low_a!=0&&low_b!=n-1)//最开始的时候用这种方法判断,后来发现不行
         //如果只有一个数字可以的时候,这种情况无法判断,
         // 例如:
         //  1 4 5
         //  5 5 9
         //  4 6 7(10)  当b[i]=9的时候,c[i]=7和10的时候无法判断
        res+=(long long)(low_a+1)*(n-low_b);

    }
    cout<<res<<endl;

    return 0;
}

双指针

进一步对查找进行优化,对于排过序的数组A和B,寻找A中小于B[i]的元素的个数可以考虑双指针算法,因为每个指针最多移动n次,故查找的时间复杂度降到O(n),查找C与查找A同理,只是找第一个大于B的位置。

只需要将上述二分程序中的

//二分
for(int i = 1; i <= n; ++i) {
    int key = num[1][i];
    //A中二分查找第一个小于key的数的下标
    int pos1 = lower_bound(num[0]+1, num[0]+n+1, key)-num[0]-1;
    //C中二分查找第一个大于key的数的下标
    int pos2 = upper_bound(num[2]+1, num[2]+n+1, key)-num[2];
    if(pos1 >= 1 && pos2 <= n) {
        ans += (LL)pos1*(n-pos2+1);
    }
}

更改为

//双指针
int a = 1, c = 1;
for(int i = 1; i <= n; ++i) {
    int key = num[1][i];
    while(a<=n && num[0][a] < key) a++;
    while(c<=n && num[2][c] <= key) c++;

    ans += (LL)(a-1)*(n-c+1);
}

完整的双指针程序为:

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;

const int N = 1e5+10;

int num[3][N];

int main() {
    int n;
    scanf("%d", &n);
    for(int i = 0; i < 3; ++i) 
        for(int j = 1; j <= n; ++j) 
            scanf("%d", &num[i][j]);
    for(int i = 0; i < 3; ++i)
        sort(num[i]+1, num[i]+n+1);

    LL ans = 0;
    //枚举B,寻找A满足的个数以及C满足的个数相乘
    int a = 1, c = 1;
    for(int i = 1; i <= n; ++i) {
        int key = num[1][i];
        while(a<=n && num[0][a] < key) a++;
        while(c<=n && num[2][c] <= key) c++;

        ans += (LL)(a-1)*(n-c+1);

    }
    cout<<ans<<endl;
    return 0;
}

前缀和

之前的双指针算法时间复杂度的瓶颈为:排序O(nlog2n)O(nlog2n)

考虑是否可以不排序在O(n)的时间内解决此问题呢?

既然要排序实现快速的查找A中小于B[i]的数的个数,可以将数组A中所有元素出现的次数存入一个哈希表中,因为数组中元素的范围只有n5n5, 可以开一个大的数组cnta 作为哈希表。

在枚举B中元素时,我们需要快速查找找小于B[i]的所有元素的总数,只需要在枚举之前先将求出表中各数的前缀和即可。

查找C与查找A同理可得。

//前缀和
#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
const int N = 1e5+10;
int A[N], B[N], C[N];
int cnta[N], cntc[N], sa[N], sc[N];

int main() {
    int n;
    scanf("%d", &n);
    //获取数i在A中有cntc[i]个,并对cnt求前缀和sa
    for(int i = 1; i <= n; ++i) {
        scanf("%d", &A[i]);
        cnta[++A[i]]++;
    }
    sa[0] = cnta[0];
    for(int i = 1; i < N; ++i) sa[i] = sa[i-1]+cnta[i];
    //B只读取即可
    for(int i = 1; i <= n; ++i) scanf("%d", &B[i]), B[i]++;

    //获取数i在C中有cntc[i]个,并对cnt求前缀和sc
    for(int i = 1; i <= n; ++i) {
        scanf("%d", &C[i]);
        cntc[++C[i]]++;
    }
    sc[0] = cntc[0];
    for(int i = 1; i < N; ++i) sc[i] = sc[i-1]+cntc[i]; 

    //遍历B求解
    LL ans = 0;
    for(int i = 1; i <= n; ++i) {
        int b = B[i];
        ans += (LL)sa[b-1] * (sc[N-1] - sc[b]);
    }
    cout<<ans<<endl;
    return 0;
}

在这里插入图片描述

分别是暴力,前缀和,双指针,二分。

模拟

特别数的和

来源:第十届蓝桥杯省赛C++B组,第十届蓝桥杯省赛JAVAB组

小明对数位中含有 2、0、1、9 的数字很感兴趣(不包括前导 0),在 1 到 40 中这样的数包括 1、2、9、10 至 32、39 和 40,共 28 个,他们的和是 574。

请问,在 1 到 n 中,所有这样的数的和是多少?

输入格式
共一行,包含一个整数 n。

输出格式
共一行,包含一个整数,表示满足条件的数的和。

数据范围
1≤n≤10000

输入样例:

40

输出样例:

574

常用小技巧:关于取出x的每位数字 和 将字符数字转为数字

1.取出x的每位数字
int t = x % 10;
x /= 10;
2.将字符数字转为数字
int x = 0;
for (int i = 0; i < str.size(); i ++ )
    x = x * 10 + str[i] - '0';

下面请看你代码:

#include <bits/stdc++.h>

using namespace std;

int main()
{
    int n;
    cin >> n;

    int res = 0;
    for (int i = 1; i <= n; i ++ )
    {
        int x = i;
        while (x)
        {
            int t = x % 10; // 取出x的个位
            x /= 10;    // 删掉x的个位
            if (t == 2 || t == 0 || t == 1 || t == 9)
            {
                res += i;
                break;
            }
        }
    }

    cout << res << endl;

    return 0;
}

错误票据

来源:第四届蓝桥杯省赛C++A/B组,第四届蓝桥杯省赛JAVAA/B组

某涉密单位下发了某种票据,并要在年终全部收回。

每张票据有唯一的ID号。

全年所有票据的ID号是连续的,但ID的开始数码是随机选定的。

因为工作人员疏忽,在录入ID号的时候发生了一处错误,造成了某个ID断号,另外一个ID重号。

你的任务是通过编程,找出断号的ID和重号的ID。

假设断号不可能发生在最大和最小号。

输入格式
第一行包含整数 N,表示后面共有 N 行数据。

接下来 N 行,每行包含空格分开的若干个(不大于100个)正整数(不大于100000),每个整数代表一个ID号。

输出格式
要求程序输出1行,含两个整数 m,n,用空格分隔。

其中,m表示断号ID,n表示重号ID。

数据范围
1≤N≤100

输入样例:

2
5 6 8 11 9 
10 12 9

输出样例:

7 9

思路

找出最大和最小的数,同时再用一个数组记录每个数字的个数,最后遍历一遍即可

#include <bits/stdc++.h>

using namespace std;

const int N = 10010;

int n;
int a[N];

int main()
{
    int cnt;
    cin >> cnt;
    string line;

    getline(cin, line); // 忽略掉第一行的回车
    while (cnt -- )
    {
        getline(cin, line);
        stringstream ssin(line);

        while (ssin >> a[n]) n ++ ;
    }

    sort(a, a + n);

    int res1, res2;
    for (int i = 1; i < n; i ++ )
        if (a[i] == a[i - 1]) res2 = a[i];  // 重号
        else if (a[i] >= a[i - 1] + 2) res1 = a[i] - 1; // 断号

    cout << res1 << ' ' << res2 << endl;

    return 0;
}

排序

快速排序

给定你一个长度为 n 的整数数列。

请你使用快速排序对这个数列按照从小到大进行排序。

并将排好序的数列按顺序输出。

输入格式
输入共两行,第一行包含整数 n。

第二行包含 n 个整数(所有整数均在 1∼109 范围内),表示整个数列。

输出格式
输出共一行,包含 n 个整数,表示排好序的数列。

数据范围
1≤n≤100000

输入样例:

5
3 1 2 4 5

输出样例:

1 2 3 4 5

快排思路

1.有数组 q, 左端点 l, 右端点r

2.确定划分边界 x

3.将 q 分为 <=x 和 >=x 的两个小数组
        i 的含义: i 之前的元素都 ≤x, 即 q[l..i−1]q[l..i−1] ≤x
        j 的含义: j 之后的元素都 ≥x, 即 q[j+1..r]q[j+1..r] ≥x
        结论: while循环结束后, q[l..j] ≤x,q[j+1..r] ≥x
        简单不严谨证明:
        while 循环结束时, i≥j
        若 i>j , 显然成立
        若 i=ji=j
        ∵ 最后一轮循环中两个 do−whiledo−while 循环条件都不成立
        ∴ q[i]≥x,q[j]≤x
        ∴ q[i]=q[j]=x
        ∴ 结论成立

4.递归处理两个小数组

#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];
    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()
{
    int n;
    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 ", q[i]);

    return 0;
}

归并排序

归并的题和快排的题是一样的,这里就不写题目了。

归并思路

1.有数组 q, 左端点 l, 右端点 r

2.确定划分边界 mid

3.递归处理子问题 q[l..mid], q[mid+1..r]

4.合并子问题

    主体合并    
        至少有一个小数组添加到 tmp 数组中    
    收尾    
        可能存在的剩下的一个小数组的尾部直接添加到 tmp 数组中    
    复制回来    
        tmp 数组覆盖原数组

#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;

    int mid = l + r >> 1;

    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 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];
}

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

    merge_sort(a, 0, n - 1);

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

    return 0;
}

到此这篇关于C语言详解数据结构与算法中枚举和模拟及排序的文章就介绍到这了,更多相关C语言 枚举 模拟 排序内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网!

--结束END--

本文标题: C语言详解数据结构与算法中枚举和模拟及排序

本文链接: https://www.lsjlt.com/news/145744.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑,方便收藏和打印~

下载Word文档
猜你喜欢
  • C语言详解数据结构与算法中枚举和模拟及排序
    目录枚举连号区间数递增三元组二分双指针前缀和模拟特别数的和错误票据排序快速排序归并排序枚举 连号区间数 来源:第四届蓝桥杯省赛C++B组,第四届蓝桥杯省赛JAVAB组 小明这些天一直...
    99+
    2024-04-02
  • C语言数据结构与算法中枚举、模拟及排序的方法
    本篇内容主要讲解“C语言数据结构与算法中枚举、模拟及排序的方法”,感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷,实用性强。下面就让小编来带大家学习“C语言数据结构与算法中枚举、模拟及排序的方法”吧!枚举连号区间数来源:第四届蓝桥杯省赛...
    99+
    2023-06-30
  • C语言数据结构与算法之排序总结(一)
    目录一、前言二、基本概念1.排序2.排序方法的稳定性3.内部和外部排序三、插入类排序1.直接插入排序2.折半插入排序3.希尔排序四、交换类排序1.冒泡排序2.快速排序五、总结比较一、...
    99+
    2024-04-02
  • C语言数据结构与算法之排序总结(二)
    目录一、前言二、选择类排序1.简单选择排序2.树形选择排序3.堆选择排序三、归并排序四、分配类排序1.多关键字排序2.链式基数排序五、总结归纳一、前言 之前的排序总结(一)对插入类和...
    99+
    2024-04-02
  • C语言数据结构之堆排序详解
    目录1.堆的概念及结构2.堆的实现2.1 堆的向下调整算法2.2 堆的向上调整算法2.3 建堆(数组)2.4 堆排序2.5 堆排序的时间复杂度1.堆的概念及结构 如果有一个关键码的集...
    99+
    2024-04-02
  • 如何进行C语言数据结构与算法中的排序总结
    这篇文章将为大家详细讲解有关如何进行C语言数据结构与算法中的排序总结,文章内容质量较高,因此小编分享给大家做个参考,希望大家阅读完这篇文章后对相关知识有一定的了解。一、前言学习目标:排序和查找密不可分,将待处理的数据按关键值大小有序排列后,...
    99+
    2023-06-22
  • C语言数据结构与算法排序的方法有哪些
    这篇文章主要介绍“C语言数据结构与算法排序的方法有哪些”,在日常操作中,相信很多人在C语言数据结构与算法排序的方法有哪些问题上存在疑惑,小编查阅了各式资料,整理出简单好用的操作方法,希望对大家解答”C语言数据结构与算法排序的方法有哪些”的疑...
    99+
    2023-06-22
  • C语言自定义数据类型的结构体、枚举和联合详解
    结构体基础知识 首先结构体的出现是因为我们使用C语言的基本类型无法满足我们的需求,比如我们要描述一本书,就需要书名,作者,价格,出版社等等一系列的属性,无疑C语言的基本数据类型无法解...
    99+
    2024-04-02
  • C语言中的自定义类型之结构体与枚举和联合详解
    目录1.结构体1.1结构的基础知识1.2结构的声明1.3特殊的声明1.4结构的自引用1.5结构体变量的定义和初始化1.6结构体内存对齐1.7修改默认对齐数1.8结构体传参2.位段2....
    99+
    2024-04-02
  • C语言数据结构之堆排序的优化算法
    目录1.堆排序优化算法1.1建堆的时间复杂度1.1.1 向下调整建堆:O(N)1.1.2 向上调整建堆:O(N*logN)1.2堆排序的复杂度1.2.1原堆排序的时间复杂度...
    99+
    2024-04-02
  • C语言数据结构与算法之字符串详解
    目录串的定义串的比较 串的抽象数据类型串的初始化相关定义初始化定长类初始化串的堆式顺序存储结构(Heap)初始化堆字符串 赋值操作比较两个堆字符串的大小 串的定义...
    99+
    2024-04-02
  • java数据结构与算法之快速排序详解
    本文实例讲述了java数据结构与算法之快速排序。分享给大家供大家参考,具体如下:交换类排序的另一个方法,即快速排序。快速排序:改变了冒泡排序中一次交换仅能消除一个逆序的局限性,是冒泡排序的一种改进;实现了一次交换可消除多个逆序。通过一趟排序...
    99+
    2023-05-31
    java 数据结构 算法
  • java数据结构与算法之冒泡排序详解
    本文实例讲述了java数据结构与算法之冒泡排序。分享给大家供大家参考,具体如下:前面文章讲述的排序算法都是基于插入类的排序,这篇文章开始介绍交换类的排序算法,即:冒泡排序、快速排序(冒泡排序的改进)。交换类的算法:通过交换逆序元素进行排序的...
    99+
    2023-05-31
    java 数据结构 算法
  • C语言植物大战数据结构希尔排序算法
    目录前言一、插入排序1.排序思路2.单趟排序详细图解3.整体代码4.时间复杂度(1).最坏情况下(2).最好情况下(3).基本有序情况下(重点)5.算法特点二、希尔排序1.希尔从哪个...
    99+
    2024-04-02
  • C语言数据结构经典10大排序算法刨析
    1、冒泡排序 // 冒泡排序 #include <stdlib.h> #include <stdio.h> // 采用两层循环实现的方法。 // 参数a...
    99+
    2024-04-02
  • C语言数据结构之队列算法详解
    目录一、前言二、基本概念三、顺序队列四、链队列五、循环队列六、总结与提高一、前言 队列在程序设计中经常出现,如:操作系统中的排队问题。 这篇文章主要介绍了队列的...
    99+
    2024-04-02
  • C语言 数据结构之数组模拟实现顺序表流程详解
    目录线性表和顺序表线性表顺序表静态顺序表动态顺序表代码已经放在Gitee上,需要可以小伙伴可以去看看 用C语言数组模拟实现顺序表 Gitee 线性表和顺序表 线性表 线性表(line...
    99+
    2024-04-02
  • C语言数据结构与算法之队列的实现详解
    目录队列的概念及结构队列的实现Queue.hQueue.cTest.c队列的概念及结构 队列:只允许在一端进行插入数据操作,在另一端进行删除数据操作的特殊线性表,队列具有先进先出FI...
    99+
    2022-11-13
    C语言数据结构 队列 C语言 队列实现 C语言 队列
  • C语言中冒泡排序算法详解
    目录一、算法描述二、算法分析三、完整代码总结一、算法描述 比较相邻两个元素,如果第一个比第二个大则交换两个值。遍历所有的元素,每一次都会将未排序序列中最大的元素放在后面。假设数组有 ...
    99+
    2024-04-02
  • java数据结构与算法之桶排序实现方法详解
    本文实例讲述了java数据结构与算法之桶排序实现方法。分享给大家供大家参考,具体如下:基本思想:假定输入是由一个随机过程产生的[0, M)区间上均匀分布的实数。将区间[0, M)划分为n个大小相等的子区间(桶),将n个输入元素分配到这些桶中...
    99+
    2023-05-31
    java 数据结构 算法
软考高级职称资格查询
编程网,编程工程师的家园,是目前国内优秀的开源技术社区之一,形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容,为IT开发者提供了一个发现、使用、并交流开源技术的平台。
  • 官方手机版

  • 微信公众号

  • 商务合作