第一章 基于c语言的简单算法

已于 2024-01-06 22:06:48 修改
阅读量451 收藏 12
点赞数 10
文章标签： 算法 数据结构 c语言
于 2024-01-04 22:49:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_79995889/article/details/135397405
版权

1-1   递推关系式

例题1   递推关系式（nCr的计算）

⭐️背景：

从n个不同元素种取出r个元素的所有不同组合的个数，用符号  {}_n \mathrm{C}_r = \frac{n!}{r!(n-r)!}  表示。

由于计算n！存在溢出风险，于是本算法使用递推关系式计算。

我们可得知：

（1）r=0的时候，{}_n C_0=1

（2）r>0的时候，{}_n C _r =\frac{n-r+1}{r}{}_n C _ {r-1}​​​​​​​

⭐️运行：

#include <stdio.h>
/*构建nCr的函数*/
long combi(int n , int r)
{
    int i;
    long p = 1;
    for(i=1;i<=r;i++){
        p=p*(n-i+1)/i;
    }
    return p;
}
/*计算0C0到5C5的所有结果*/
int main()
{
    int n , r;
    for(n=0;n<=5;n++){
        for(r=0;r<=n;r++){
            printf("%dC%d=%ld  ",n,r,combi(n,r));
        }
        printf("\n");
    }
    return 0;
}

运行结果如下：

0C0=1  
1C0=1  1C1=1  
2C0=1  2C1=2  2C2=1  
3C0=1  3C1=3  3C2=3  3C3=1  
4C0=1  4C1=4  4C2=6  4C3=4  4C4=1  
5C0=1  5C1=5  5C2=10  5C3=10  5C4=5  5C5=1

 ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:* ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:*

练习1-1   多项式计算的Honer方法

⭐️背景：

多项式f(x)=a_nx^n+a_{n-1}x^{n-1}+...+a_1x+a_0的计算量为\frac{n(n+1)}{2}+2，它也可以写成

f(x)=(...(a_nx+a_{n-1})x+a_{n-2})x+a_{n-3})x...a_1)x+a_0。

我们这里考虑让

f_0=a_n ，

f_1=f_0x+a_{n-1} ，

f_2=f_1x+f_{n-2} ，... ，依次递推，那么可得一般式：

f_i=f_{i-1}x+a_{n-i}  ,  f_0=a_n 。

⭐️运行：

#include <stdio.h>
/*构建fn函数*/
double fn(double x , double a[] , int n)
{
    double p;
    int i;
    p = a[n];
    for(i=n-1;i>=0;i--){
        p=p*x+a[i];
    }
    return p;
}
/*目标：f(x)=5x^4+4x^3+3x^2+2x+1,输出x=1~5的结果*/
int main()
{
    double a[]={1,2,3,4,5};
    double x;
    for(x=1;x<=5;x++){
        printf("fn(%f)=%f\n",x,fn(x,a,4));
    }
    return 0;
}

运行结果如下：

fn(1.000000)=15.000000
fn(2.000000)=129.000000
fn(3.000000)=547.000000
fn(4.000000)=1593.000000
fn(5.000000)=3711.000000

 ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:* ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:*

练习1-2   Pascal三角形

⭐️背景：

Pascal三角形，又称杨辉三角形，是二项式系数的一种写法，形似三角形。回顾例题1中求nCr的算法，我们可以写出Pascal三角形。

⭐️运行：

#include <stdio.h>
#define N 12
/*构建nCr的函数*/
long combi(int n ,int r)
{
    int i;
    long p = 1;
    for(i=1;i<=r;i++){
        p=p*(n-i+1)/i;
    }
    return p;
}
/*构建0C0到12C0共13行的Pascal三角形*/
int main()
{
    int n , r , t;
    for(n=0;n<=N;n++){
        for(t=0;t<(N-n)*3;t++) {
            printf(" ");
        }
        for(r=0;r<=n;r++)
        {
            printf("%6ld",combi(n,r));
        }
        printf("\n");
    }
    return 0;
}

运行结果如下：

                                        1
                                      1     1
                                   1     2     1
                                1     3     3     1
                             1     4     6     4     1
                          1     5    10    10     5     1
                       1     6    15    20    15     6     1
                    1     7    21    35    35    21     7     1
                 1     8    28    56    70    56    28     8     1
              1     9    36    84   126   126    84    36     9     1
           1    10    45   120   210   252   210   120    45    10     1
        1    11    55   165   330   462   462   330   165    55    11     1
     1    12    66   220   495   792   924   792   495   220    66    12     1

 ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:* ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:*

1-2   映射

例题2   直方图(Histogram)

⭐️背景：

考虑0~100分的分数可以切分为（0~9 , 10~19 , ... , 90~99 , 100）11个级别，求每个级别的度数分布。也就是说，我们准备排序histo[0]~histo[10]，求histo[0]里0~9分的个数，histo[1]里10~19分的个数...。

⭐️运行：

#include <stdio.h>
#define Num 20
int main()
{
    int a[]={35,25,56,78,43,66,71,73,80,90,0,73,35,65,100,78,80,85,35,50};
    int i , rank , histo[11];
    /*令histo[11]清零*/
    for(i=0;i<11;i++){
        histo[i]=0;
    }
    /*逐个分配级别，级别个数加1*/
    for(i=0;i<Num;i++){
        rank=a[i]/10;
        if(0<=rank&&rank<=10){
            histo[rank]++;
        }
    }
    for(i=0;i<=10;i++){
        printf("%3d~%3d  : %3d\n",i*10,i*10+9,histo[i]);
    }
    return 0;
}

运行结果如下：

  0~  9  :   1
 10~ 19  :   0
 20~ 29  :   1
 30~ 39  :   3
 40~ 49  :   1
 50~ 59  :   2
 60~ 69  :   2
 70~ 79  :   5
 80~ 89  :   3
 90~ 99  :   1
100~109  :   1

 ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:* ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:*

练习2   密码的加密

⭐️背景：

将字母'A'~‘Z'在某种字母表上进行偏移后，可以被替换成密文。使用时，加密者需要先查找明文字母表中需要加密的消息中的每一个字母所在位置，并且写下密文字母表中对应的字母。需要解密的人则根据事先已知的密钥反过来操作，得到原来的明文。这样说有点绕，我们可以举个加密的简单的例子。

先准备一个文字母表，char table[]=''QWERTYUIOPASDFGHJKLZXCVBNM?''，那么'A'解读为'Q'，'B'解读为'W'，...，'Z'解读为'M'，'A'~'Z'以外的字母解读为'?'。

同时需要理解：'A'-'A'=0;'B'-'A'=1;'C'-'A'=2;'Z'-'A'=25。

⭐️运行：

#include <stdio.h>
int main()
{
    char table[]="QWERTYUIOPASDFGHJKLZXCVBNM?";
    const char* ango = "KSOIDHEPZ";
    int index;
    while(*ango!='\0'){
        if('A'<=*ango&&*ango<='Z'){
            index = *ango - 'A';
        }
        else
            index=26;
        putchar(table[index]);
        ango++;      
    }
    return 0;
}

运行结果如下：

ALGORITHM

 ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:* ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:*

1-3   排名

⭐️背景：

根据分数排名的算法本小节介绍2种方法（纯粹的方法以及改良版本），另外介绍当数据中包含负分时的算法。

例题3   纯粹的方法

⭐️运行：

#include <stdio.h>
#define Num 10
/*遍历数组逐次将当前数字与其他数字比大小*/
int main()
{
    int a[]={56,25,67,88,100,61,55,67,76,56};
    int juni[Num];
    int i , j ;
    for(i=0;i<Num;i++){
        juni[i]=1;
        for(j=0;j<Num;j++){
            if(a[j]>a[i]){
                juni[i]++;
            }
        }
    }
    printf("    分数 排名  \n");
    for(i=0;i<Num;i++){
        printf("%6d%6d\n",a[i],juni[i]);
    }
    return 0;
}

运行结果如下：

    分数 排名  
    56     7
    25    10
    67     4
    88     2
   100     1
    61     6
    55     9
    67     4
    76     3
    56     7

 ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:* ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:*

练习3-1   改良版

⭐️背景：

由于例题3的计算量为n^2，数据一旦增多处理时间会很长，所以考虑改良版以此减少计算量。

1. 我们假设分数范围为0~100，准备排序juni[0]~juni[100]，另备一个多余的juni[101]，内容清零。

2. 将各分数分别对应进排序所对应的位置，并令内容+1。例如分数56对应juni[56]，juni[56]++。

3. 令juni[101]的初始值为1（表示排名1）。从juni[100]开始到jun[0]为止，让每个要素加上右面的要素的内容。那么junn[100]，juni[99]，...，juni[89]的要素为2，juni[88]的要素为3。我们可得知100分的排名是101的位置，88分的排名实际是89的位置。

⭐️运行：

#include <stdio.h>
#define Num 10
#define Max 100
#define Min 0
int main()
{
    int a[]={56,25,67,88,100,61,55,67,76,56};
    int i , juni[Max+2];
    /*清零*/
    for(i=0;i<=Max;i++){
        juni[i]=0;
    }
    /*令分数所对应的位置内容+1*/
    for(i=0;i<Num;i++){
        juni[a[i]]++;
    }
    /*加上右边的要素*/
    juni[Max+1]=1;
    for(i=Max;i>=0;i--){
        juni[i]=juni[i]+juni[i+1];
    }
    printf("    分数 排名  \n");
    for(i=0;i<Num;i++){
        printf("%6d%6d\n",a[i],juni[a[i]+1]);
    }
    return 0;
}

运行结果如下：

    分数 排名  
    56     7
    25    10
    67     4
    88     2
   100     1
    61     6
    55     9
    67     4
    76     3
    56     7

 ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:* ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:*

练习3-2   负数数据版本

⭐️背景：

高尔夫的分数范围在-20~+36，分数越小排名越高。由于C语言中不能使用负数作为下标，因此我们对小标进行整体偏移（+21）。juni[0]的初始值为0，令juni[1]~juni[57]依次加上左边的要素。

⭐️运行：

#include <stdio.h>
#define Num 10
#define Max 36
#define Min -20
#define Bias 1-(Min)
int main()
{
    int a[]={-3,2,3,-1,-2,-6,2,-1,1,5};
    int i , juni[Max+Bias+1];
    /*清零*/
    for(i=0;i<=Max+Bias;i++){
        juni[i]=0;
    }
    /*令分数所对应的位置内容+1*/
    for(i=0;i<Num;i++){
        juni[a[i]+Bias]++;
    }
    /*加上左边的要素*/
    juni[0]=1;
    for(i=1;i<=Max+Bias;i++){
        juni[i]=juni[i]+juni[i-1];
    }
    printf("    分数 排名  \n");
    for(i=0;i<Num;i++){
        printf("%6d%6d\n",a[i],juni[a[i]+Bias-1]);
    }
    return 0;
}

运行结果如下：

 分数 排名  
    -3     2
     2     7
     3     9
    -1     4
    -2     3
    -6     1
     2     7
    -1     4
     1     6
     5    10

 ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:* ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:*

1-4   随机排序

例题4   随机排序（效率低版）

⭐️背景：

1~N随机排序，其中效率比较低的方法计算量达到了N^2。方法如下：

1. 1~N随机得到一个数字，作为排序的第一个数据。

2. 反复从1~N中随机数字存入排序中，反复N-1次。但若数字已在排序中存在则重新操作此步骤。

⭐️运行：

#include <stdio.h>
#include<stdlib.h>
#define N 20
/*得到一个1~n的随机数*/
int irnd(int n)
{
    return (int)(rand()/(RAND_MAX+0.1)*n+1);
}
int main()
{
    int i , j , flag , a[N+1];
    a[1]=irnd(N);
    for(i=2;i<=N;i++){
        do{
            a[i]=irnd(N);flag=0;//随机数字，不插旗子
            for(j=1;j<i;j++){//检查是否与前面有重复
                if(a[i]==a[j]){
                    flag=1;break;//若重复，插旗子->循环
                }
            }
        }while(flag==1);//循环条件->插旗子
    }
    for(i=1;i<=N;i++){
        printf("%3d",a[i]);
    }
    return 0;
}

运行结果如下：

  1  3 16 10 11  5 14 19  8 17  2  9 12 15  6  7 13 20 18  4

 ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:* ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:*

练习4   随机排序（改良版）

⭐️背景：

刚才例题4的算法是先随机19个数字，再一个个去比对是否重复，重复还得重来，效率比较低下。改良版中，我们可以排序a[1]，...，a[N]，交换a[N]和a[j]（j<N)，a[N-1]和a[j](j<N-2)，直到a[2]和a[1]。

⭐️运行：

#include <stdio.h>
#include<stdlib.h>
#define N 20
/*得到一个1~n的随机数*/
int irnd(int n)
{
    return (int)(rand()/(RAND_MAX+0.1)*n+1);
}
int main()
{
    int i , j , d , a[N+1];
    /*构建1~20的数组*/
    for(i=1;i<=N;i++){
        a[i]=i;
    }
    /*交换a[i]和a[j]*/
    for(i=N;i>1;i--){
        j=irnd(N-1);
        d=a[i];a[i]=a[j];a[j]=d;
    }
    for(i=1;i<=N;i++){
        printf("%3d",a[i]);
    }
    return 0;
}

运行结果如下：

 19 11  7 12 15  2 14  6  8 17 18 13  4 20  5 10  9 16  3  1

 ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:* ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:*

1-5   Monte Carlo method

⭐️背景：

蒙特卡罗是摩纳哥的著名赌城，该法为表明其随机抽样的本质而命名。故适用于对离散系统进行计算仿真试验。在计算仿真中，通过构造一个和系统性能相近似的概率模型，并在数字计算机上进行随机试验，可以模拟系统的随机特性。

例题5   用蒙特卡罗法求π

⭐️背景：

我们以半径为1的四分之一圆为例。四分之一圆的面积：正方形的面积=四分之一圆内的点的个数a：正方形内的点的个数n。因此：

\frac{\pi}{4}:1=a:n

\pi=\frac{4a}{n}

⭐️运行：

#include <stdio.h>
#include<stdlib.h>
#define Num 1000
/*得到一个0~1的随机数*/
double rnd()
{
    return (double)(rand()/(RAND_MAX+0.1));
}
int main()
{
    double x , y , pai;
    int i , in=0;
    for(i=0;i<Num;i++){
        x=rnd();y=rnd();
        if(x*x+y*y<=1){
            in++;
        }
    }
    pai=(double)4*in/Num;
    printf("π的值=%f\n",pai);
    return 0;
}

运行结果如下：

π的值=3.168000

 ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:* ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:*

练习5   用蒙特卡罗法求椭圆面积

⭐️背景：

已知，椭圆的关系式为\frac{x^2}{4}+y^2=1，求椭圆的面积。四分之一椭圆的面积：长方形的面积=四分之一椭圆内的点的个数a：长方形内的点的个数n。因此：

s:2=a:n

s=\frac{2a}{n}​​​​​​​

S=4s=\frac{8a}{n}

⭐️运行：

#include <stdio.h>
#include<stdlib.h>
#define Num 1000
/*得到一个0~1的随机数*/
double rnd()
{
    return (double)(rand()/(RAND_MAX+0.1));
}
int main()
{
    double x , y , s;
    int i , in=0;
    for(i=0;i<Num;i++){
        x=2*rnd();y=rnd();
        if(x*x/4+y*y<=1){
            in++;
        }
    }
    s=8.00*in/Num;
    printf("椭圆的面积=%f\n",s);
    return 0;
}

运行结果如下：

椭圆的面积=6.336000

 ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:* ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:*

1-6   Euclidean Algorithm

例题6   辗转相除法(1)

⭐️运行：

#include <stdio.h>
int main()
{
    int a , b , m , n;
    printf("请输入两个整数\n");
    scanf("%d %d",&a,&b);
    m=a;n=b;
    while(m!=n){
        if(m>n){
            m=m-n;
        }
        else if(m<n){
            n=n-m;
        }
    }
    printf("%d和%d的最大公约数为%d\n",a,b,m);
    return 0;
}

运行结果如下：

请输入两个整数
128
72
128和72的最大公约数为8

 ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:* ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:*

习题6   辗转相除法(2)

#include <stdio.h>
int main()
{
    int a , b , m , n , k;
    printf("请输入两个整数\n");
    scanf("%d %d",&a,&b);
    m=a;n=b;
    do{
        k=m%n;
        m=n;n=k;
    }while(k!=0);
    printf("%d和%d的最大公约数为%d\n",a,b,m);
    return 0;
}

运行结果如下：

请输入两个整数
128
72
128和72的最大公约数为8

 ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:* ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:*

1-7   埃拉托斯特尼筛法

⭐️背景：

埃拉托斯特尼筛法是一种用来生成素数的筛法，得名于古希腊数学家埃拉托斯特尼。其基本步骤是从最小的素数2开始，将该素数的所有倍数标记成合数，而下一个尚未被标记的最小自然数3即是下一个素数。如此重复这一过程，将各个素数的倍数标记为合数并找出下一个素数，最终便可找出一定范围内所有素数。不过，在实际使用此筛法寻找一个范围内的素数时，不需要检查范围内所有整数，也不需要对每个素数都标记其所有的倍数。

例题7   判断n是否为素数

⭐️背景：

逐次除以\sqrt{n}以下的整数，若是能整除则不为素数。

⭐️运行：

#include <stdio.h>
#include <math.h>
int main()
{
    int i , n , Limit;
    while(printf("data? "),scanf("%d",&n)!=EOF){
        if(n>=2){
            Limit=(int)sqrt((double)n);
            for(i=Limit;i>1;i--){
                if(n%i==0)
                break;
            }
        }
        if(i==1)
            printf("素数\n");
        else
            printf("不是素数\n");
    }
    return 0;
}

运行结果如下：

data? 991
素数

 ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:* ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:*

练习7-1   筛选2~N中的所有素数

⭐️背景：

逐次判断每个数字是否为素数再筛选。

⭐️运行：

#include <stdio.h>
#include <math.h>
#define NUM 1000
int main()
{
    int prime[NUM/2+1];//存储素数的数组
    int i , n , m=0 , Limit;
    for(n=2;n<=NUM;n++){
        Limit=(int)sqrt((double)n);
        for(i=Limit;i>1;i--){
            if(n%i==0)
                break;
        }
        if(i==1)
            prime[m++]=n;
    }
    printf("素数有\n");
    for(i=0;i<m;i++)
        printf("%5d",prime[i]);
        printf("\n");
    return 0;
}

运行结果如下：

素数有
    2    3    5    7   11   13   17   19   23   29   31   37   41   43   47   53   59   61   67   71   73   79   83   89   97  101  103  107  109  113  127  131  137  139  149  151  157  163  167  173  179  181  191  193  197  199  211  223  227  229  233  239  241  251  257  263  269  271  277  281  283  293  307  311  313  317  331  337  347  349  353  359  367  373  379  383  389  397  401  409  419  421  431  433  439  443  449  457  461  463  467  479  487  491  499  503  509  521  523  541  547  557  563  569  571  577  587  593  599  601  607  613  617  619  631  641  643  647  653  659  661  673  677  683  691  701  709  719  727  733  739  743  751  757  761  769  773  787  797  809  811  821  823  827  829  839  853  857  859  863  877  881  883  887  907  911  919  929  937  941  947  953  967  971  977  983  991  997 

☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:* ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:*

练习7-2  埃拉托斯特尼筛法

⭐️背景：

练习7-1的算法，计算量为n\sqrt{n}/2。有一种算法更为效率一些，那就是埃拉托斯特尼筛法。要得到自然数n以内的全部素数，必须把\sqrt{n}以下的所有素数的倍数剔除，剩下的就是素数。

标记某一素数 p p的倍数时，不需要每次皆从 2 p , 3 p , … 开始，而可直接从p^2开始标记。 证明：所有较p^2更小的 p的倍数必然拥有一个更小的素数为其因数，故在标记之前的素数的倍数时它们已经被标记过了。

⭐️运行：

#include <stdio.h>
#include <math.h>
#define NUM 1000
int main()
{
    int prime[NUM+1];//准备筛子
    int i , j , Limit;
    for(i=2;i<=NUM;i++)
        prime[i]=1;
    Limit=(int)sqrt((double)NUM);
    for(i=2;i<=Limit;i++){
        if(prime[i]==1){
            for(j=i*i;j<=NUM;j++){
                if(j%i==0)
                    prime[j]=0;
            }
        }
    }
    printf("素数有\n");
    for(i=2;i<=NUM;i++){
        if(prime[i]==1)
            printf("%5d",i);
    }
    printf("\n");
    return 0;
}

运行结果如下：

素数有
    2    3    5    7   11   13   17   19   23   29   31   37   41   43   47   53   59   61   67   71   73   79   83   89   97  101  103  107  109  113  127  131  137  139  149  151  157  163  167  173  179  181  191  193  197  199  211  223  227  229  233  239  241  251  257  263  269  271  277  281  283  293  307  311  313  317  331  337  347  349  353  359  367  373  379  383  389  397  401  409  419  421  431  433  439  443  449  457  461  463  467  479  487  491  499  503  509  521  523  541  547  557  563  569  571  577  587  593  599  601  607  613  617  619  631  641  643  647  653  659  661  673  677  683  691  701  709  719  727  733  739  743  751  757  761  769  773  787  797  809  811  821  823  827  829  839  853  857  859  863  877  881  883  887  907  911  919  929  937  941  947  953  967  971  977  983  991  997 

☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:* ☆.。.:*・°☆.。.:*・°☆.。.:*・°☆.。.:*

练习7-3   因数分解

⭐️背景：

把整数因数分解的过程可以理解为，先不断除以2，再尝试除以3,5...等素数。当整数大于等于被除数的平方时，说明还能继续重复。但如果最后整数等于被除数了，那么就结束了。

18/2=9 ; 9/3=3;

⭐️运行：

#include <stdio.h>
#include <math.h>
#define NUM 1000
int main()
{
    int a , n;
    while(printf("Number ?"),scanf("%d",&n)!=EOF){
        a = 2;
        while(n>=a*a){
            if(n%a==0){
                printf("%d*",a);
                n=n/a;
            }
            else
                a++;
        }
        printf("%d\n",n);
    }
    return 0;
}

运行结果如下：

Number ?126
2*3*3*7
Number ?1200
2*2*2*2*3*5*5
Number ?991
991

麦子葡萄糖
关注
  • 10
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于C语言实现的两种常见页面置换算法（OPT，LRU）
04-02
针对一个虚拟存储区和内存工作区,编程序演示下述算法的具体实现过程，并计算访问命中率。要求设计主界面以灵活选择某算法，且以下算法都要实现 (1)最佳淘汰算法（OPT） (2)最近最少访问页面算法（LRU） 2.要有体现...
分布式学习笔记 (1) 一致性
LanceJerry的博客
12-07 790
一致性学习笔记 常见的一致性词语：CAP理论的 consistency， ACID 中的 consistency， cache一致性协议的 coherence， Raft/Paxos 中的 consensus。 1.coherence coherence 只出现在Cache Coherence 一词中，称为”缓存一致性”，研究多核场景，即怎么保证多个核上的CPU 缓存数据是一致的，一般是单机维度的，不算分布式领域。 2.consensus consensus准确的翻译是共识，即多个提议者达成共识的过程，例如
计算机国家二级C语言教程第一二章ppt课件.ppt
11-12
本资源摘要信息是基于计算机国家二级C语言教程第一二章ppt课件.ppt文件所生成的知识点。 算法 * 算法是指使用计算机完成一个任务所采取的方法和执行的步骤。 * 算法的特性： + 有穷性：执行若干个操作步骤之后，...
c语言学习课件第05章完整.pptx
11-14
即使第一次条件不满足，do-while循环也会至少执行一次。在案例5.4中，do-while被用来做同样的累计和计算，但无论条件如何，循环体都会先执行一次。 break和continue语句是控制循环流程的工具。break语句用于立即...
C语言程序设计：第5章 常用数值计算算法及其程序设计
05-08
C语言程序设计：第5章 常用数值计算算法及其程序设计 本章主要介绍了五种常用的数值计算算法及其程序设计，分别是素数判断...本章的算法和程序设计都是基于C语言的实现，对于初学者来说可以作为一个学习和实践的参考。
《C语言》课件教案PPT第04章C语言的流程控制共90页
10-30
在第04章的课件中，通常会涵盖以下知识点： 1. **条件语句**：这是程序根据特定条件执行不同分支的能力。在C语言中，主要包括`if`语句和`switch`语句。`if`语句允许基于布尔表达式的值来决定代码块是否执行，而`...
算法-KMP字符串匹配
xx_xb的博客
07-23 174
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 394
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 648
AtCoder Beginner Contest 363 ABCDE
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
最新发布
danaaaa的博客
07-24 746
二叉搜索树向左或向右指明方向，不用遍历整个树。
2024.7.19 刷题总结
TheJustice_的博客
07-19 309
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
插入和选择排序
c23856的博客
07-20 538
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
Python鲁汶意外莱顿复杂图拓扑分解算法
跨学科知识视角展现
07-24 750
:dart:算法池化和最佳分区搜索：:pen:网格搜索 | :pen:发现算法池 | :pen:返回指定图的最佳划分 | :pen:返回指定图的最佳分区 | :dart:适应度和聚类比较功能：:pen:图的划分 | :pen:节点度 | :pen:给定算法检测到社群总数 | :pen:图密度 | :pen:社群顶点的度数之和 | :pen:解之间的预期一致 | :pen:联合熵 | :pen:平均内部度、所有可能的节点对的平均路径长度 | :pen:节点指向社群外的边平均比例 | :pen:现有边距离社群比
【常微分方程】
qq_74285286的博客
07-24 250
常微分方程笔记
python实现图像缩放算法
qq_42568323的博客
07-20 403
它通过选择离目标像素最近的原始像素的颜色值来确定目标像素的颜色值。它通过考虑目标像素周围16个像素的颜色值，使用双三次插值公式计算出目标像素的颜色值。相较于双线性插值，双三次插值能生成更平滑、更细腻的图像效果。它通过考虑目标像素周围四个像素的颜色值，使用双线性插值公式计算出目标像素的颜色值。尽管最近邻插值在某些应用场景中足够使用，但在需要更高质量图像的场景中，通常会选择更加复杂的插值方法，如双线性插值或双三次插值。双三次插值是图像缩放中高质量的方法之一，适合需要高质量图像处理的应用场景。
LeetCode977 有序数组的平方
daishabby2486的博客
07-24 593
LeetCode977 有序数组的平方的解题记录。
算法力扣刷题记录 五十六【501.二叉搜索树中的众数】
danaaaa的博客
07-21 899
求众数方法
【刷题汇总 -- 压缩字符串(一)、chika和蜜柑、 01背包】
m0_69455439的博客
07-19 1165
今日刷题汇总day018 -- 压缩字符串(一)、chika和蜜柑、 01背包
算法第十一天：leetcode707.设计链表
m0_75068978的博客
07-19 1487
的链接如下表所示，您可直接复制下面网址进入力扣学习，在观看下面的内容之前一定要先做一遍哦，这样才能印象深刻！题目描述：你可以选择使用单链表或者双链表，设计并实现自己的链表。val和next。val是当前节点的值，next是指向下一个节点的指针/引用。如果是双向链表，则还需要属性prev以指示链表中的上一个节点。假设链表中的所有节点下标从开始。实现index-1valvalvalindexindexindexindex// 链表变为 1->2->3// 返回 2。
C语言版算法与数据结构详解：从逻辑到存储
《算法与数据结构C语言版》的第一章介绍了数据的基础概念，后续章节将深入探讨这些概念如何在C语言中具体应用，通过实例和练习帮助读者掌握这些核心概念，并在实践中提高编程技能。学习这本书对于理解计算机科学中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值