算法

最新推荐文章于 2024-09-25 10:36:42 发布
最新推荐文章于 2024-09-25 10:36:42 发布
阅读量735 收藏 1
点赞数
分类专栏： 算法 文章标签： 算法 struct fp null tree file
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuhongwei/article/details/1492619
版权
冒泡：
#include < stdio .h>
#include < string .h>
 
bubble( strings , count )
char * strings ;
int count ;
{
         register int m , n ;
         register char s ;
         for ( m = 1; m < count ; m ++)
                   for ( n = count -1; n >= m ;-- n )
                   {
                            if ( strings [ n -1]> strings [ n ])
                            {
                                     s = strings [ n -1];
                                     strings [ n -1] = strings [ n ];
                                     strings [ n ] = s ;
                            }
                   }
}
 
int main ( void )
{
         int count ;
         char str [200];
         printf ( " 请输入字符串： /n" );
         gets ( str );
         count = strlen ( str );
         bubble( str , count );
         printf ( " 排序之后的字符串是： /n" );
         printf ( "%s./n" , str );
 
         return 0;
}
堆排序：
#include < stdio .h>
#define MARK 0
 
static a [8] = { MARK ,25,4,36,1,60,10,58,};
int count = 1;
void heap ( int n );
void adjust ( int i , int n );
 
int main ( void )
{
         int i ;
         printf ( " 源数据为： " );
         for ( i = 1; i <8; i ++)
                  printf ( "%5d" , a [ i ]);
         heap (7);
         printf ( "/n 排序后的数据为： " );
         for ( i = 1; i <8; i ++)
                  printf ( "%5d" , a [ i ]);
         printf ( "/n" );
         return 0;
}
 
void heap ( n )
int n ;
{
         int i , j , t ;
         for ( i = n /2; i >0; i --)
                  adjust ( i , n );
         printf ( "/n 初始化成堆 ===>   " );
         for ( i = 1; i < 8; i ++)
                  printf ( "%5d" , a [ i ]);
         for ( i = n -1; i >0; i --)
         {
                   t = a [ i +1];
                   a [ i +1] = a [1];
                   a [1] = t ;
                  adjust (1, i );
                  printf ( "/n 第 %2d 步操作结果 ===>" , count ++);
                   for ( j = 1; j <8; j ++)
                            printf ( "%5d" , a [ j ]);
         }
}
 
void adjust ( i , n )
int i , n ;
{
         int j , k , r , done =0;
         k = r = a [ i ];
         j = 2* i ;
         while (( j <= n )&&( done ==0))
         {
                   if ( j < n )
                   {
                            if ( a [ j ]< a [ j +1])
                                     j ++;
                   }
                  if ( k >= a [ j ])
                            done = 1;
                   else
                   {
                            a [ j /2] = a [ j ];
                            j = 2*  j ;
                   }
         }
         a [ j /2] = r ;
}


文件排序：
#include < stdio .h>
#include <stdlib.h>
#include < string .h>
 
#define NUM 4
 
struct data
{
         char name [20];
         char school[20];
         char city[20];
         char province[20];
}info;
 
struct data addrs[NUM]=
{
         "WenHai" , "BIT" , "JiLin" , "JiLin" ,
         "TongWei" , "BIT" , "ZhengJiang" , "JiangSu" ,
         "SunYou" , "BIT" , "WeiFang" , "ShangDong" ,
         "XiaoMing" , "PKU" , "TaiYuan" , "ShanXi"
 
};
/* 对后面要用到的函数进行声明 */
void quick_disk( FILE *fp, int count);
void qs_disk( FILE *fp, int left , int right );
void exchangedata( FILE *fp,long i , long j);
char *get_name( FILE *fp, long rec);
void print_data(struct data * p );
struct data *get_data( FILE *fp,long rec);
 
int main(void)
{
         int i ;
         FILE *fp;                                      /* 文件指针 */
         /* 以读写方式生成文本文件 fp*/
         if((fp = fopen ( "datalist.txt" , "w+" )) == NULL )
         {
                   printf ( " 打开文件失败 /n" );
                   exit (1);
         }
         printf ( " 将未排序的数据写入文件 /n" );
         /* 将数组 Sdata[NUM] 写入文件中 */
         fwrite (addrs,sizeof(addrs),1,fp);
         /* 将文件中的数组 Sdata[NUM] 依次取出并打印 */
         for( i =0; i <NUM; i ++)
         {
                   struct data * p ;
                   p = get_data(fp, i );            /* 得到 Sdata[i] 的指针 */
                  print_data( p );                         /* 将结构体 Sdata[i] 各个成员变量打印出 */
                  printf ( "/n" );
         }
 
         fclose (fp);                                               /* 关闭文件指针 */
         /* 以二进制方式再次打开文件 datalist.txt*/
         if((fp= fopen ( "datalist.txt" , "rb+" ))== NULL )
         {
                   printf ( " 不能以读写方式打开文件 /n" );
                   exit (1);
         }
 
         printf ( " 将文件数据排序 /n" );
         /* 调用字符串排序函数将文本中的字符串结构体排序 */
         quick_disk(fp,NUM);                    
 
         printf ( " 排序结束 /n" );
         /* 将排序结束后的数组数据打印出来 */
         for( i =0; i <4; i ++)
         {
                   struct data * p ;
                   p = get_data(fp, i );
                  print_data( p );
                  printf ( "/n" );
         }
         fclose (fp);
 
         return 0;
}
/* 应用快速排序方法对字符串进行排序 */
void quick_disk( FILE *fp, int count)
{
         qs_disk(fp,0,count-1);
}
/* 排序函数 */
void qs_disk( FILE *fp, int left , int right )
{
         long int i ,j;
         char x [30];
         i = left ;
         j = right ;
         /* 比较字符串 x 为 Sdata 数组中间一个结构变量的 name 成员变量 */
         strcpy ( x ,get_name(fp,(long)( i +j)/2));
         do
         {       /* 比较当前结构变量的 name 成员变量于比较字符串 x 的大小 */
                  while(( strcmp (get_name(fp, i ), x )<0)&&( i < right ))
                            i ++;
                  while(( strcmp (get_name(fp,j), x )>0)&&(j> left ))
                            j--;
                   if( i <=j)
                   {
                            exchangedata(fp, i ,j);              /* 交换 i 和 j 对应的数据 */
                            i ++;
                            j--;
                   }
         }while( i <j);
 
         if( left <j)                                          /* 反复调用此排序函数，直到 j 达到数据的最左端 */
                  qs_disk(fp, left ,( int )j);
         if( i < right )                                      /* 反复调用此排序函数，直到 i 达到数据的最右端 */
                  qs_disk(fp,( int ) i , right );
}
/* 交换 i 和 j 在文件中对应的数据 */
void exchangedata( FILE *fp,long i ,long j)
{
         char a [sizeof(info)],b[sizeof(info)];
         fseek (fp,sizeof(info)* i , SEEK_SET );                  /* 找到 i 在文件中对应的数据位置 */
         fread ( a ,sizeof(info),1,fp);                                   /* 将该位置数据读到字符串数组 a 中 */
 
         fseek (fp,sizeof(info)*j, SEEK_SET );                  /* 找到 j 在文件中对应的数据位置 */
         fread (b,sizeof(info),1,fp);                                   /* 将该位置数据读到字符串数组 b 中 */
 
         fseek (fp,sizeof(info)*j, SEEK_SET );                  /* 找到 j 在文件中对应的数据位置 */
         fwrite ( a ,sizeof(info),1,fp);                       /* 将刚才读入 a 中的数据写入到该位置 */
         fseek (fp,sizeof(info)* i , SEEK_SET );                  /* 找到 i 在文件中对应的数据位置 */
         fwrite (b,sizeof(info),1,fp);                       /* 将刚才读入 b 中的数据写入到该位置 */
         /* 完成文件中 i 和 j 处对应数据的交换 */
}
/* 得到文件 fp 中变量 rec 对应的结构体变量的 name 成员变量 */
char *get_name( FILE *fp,long rec)
{
         struct data * p ;
         p = &info;
         rewind (fp);
         /* 找到该结构体变量得的位置 */
         fseek (fp,rec*sizeof(struct data ), SEEK_SET );
         /* 将其读到指针 p*/
         fread ( p ,sizeof(struct data ),1L,fp);
         return p -> name ;                    /* 返回该结构体变量的 name 成员变量 */
}
/* 得到文件 fp 中变量 rec 对应的结构体变量的指针 */
struct data *get_data( FILE *fp,long rec)
{
         struct data * p ;
         p = &info;
         rewind (fp);
         /* 找到该结构体变量得的位置 */
         fseek (fp,rec*sizeof(info), SEEK_SET );
         /* 将其读到指针 p*/
         fread ( p ,sizeof(info),1,fp);
         return p ;                               /* 返回该结构体指针 */
}
/* 将指针 p 对应的结构体的各个成员变量打印出来 */
void print_data(struct data * p )
{
         printf ( " 姓名： %s/n" , p -> name );
         printf ( " 学校： %s/n" , p ->school);
         printf ( " 城市： %s/n" , p ->city);
         printf ( " 省   ： %s/n" , p ->province);
}
链表搜索：
#include < stdio .h>
#include <stdlib.h>
#include < string .h>
#define NUM 4
 
struct chain
{
         char name [20];
         char city[20];
         char sex[10];
         char age[10];
         char job[10];
         struct chain *next;
};
 
struct chain *create();
struct chain *SequelSeach(head, name );
void print_data(point);
 
struct chain Datas[NUM]=
{
         "Sun" , "Weifang" , "Male" , "24" , "student" , NULL ,
         "Tom" , "Beijing" , "Male" , "31" , "doctor" , NULL ,
         "Marry" , "Shanghai" , "Female" , "19" , "techer" , NULL ,
         "Willing" , "Tianjing" , "Female" , "21" , "worker" , NULL
};
 
int main(void)
{
         struct chain *head;
         struct chain * p ;
         char name [30];
         head = create();
         printf ( " 请输入要查找的人名 /n" );
         scanf ( "%s" , name );
         p = SequelSeach(head, name );
         print_data( p );
         return 0;
}
 
struct chain *create()
{
         struct chain *head, *tail, * p ;
         int i ;
         head = tail = NULL ;
         printf ( " 将名单数据输入到链表中 :/n" );
         for( i = 0; i < NUM; i ++)
         {      
                   p = (struct chain *) malloc (sizeof (struct chain));
                  strcpy ( p -> name , Datas[ i ]. name );
                  strcpy ( p ->city,Datas[ i ].city);
                  strcpy ( p ->sex,Datas[ i ].sex);
                  strcpy ( p ->age,Datas[ i ].age);
                  strcpy ( p ->job,Datas[ i ].job);
                   p ->next = NULL ;
                   if(head == NULL )
                            head = tail = p ;
                   else
                            tail = tail ->next;
                            tail ->next = p ;
         }
         return head;
}
 
struct chain *SequelSeach(head, name )
struct chain *head;
char name [];
{
         struct chain *temp;
         temp = head;
         for(temp=head;temp!= NULL ;)
         {
                  if( strcmp (temp-> name , name ) == 0)
                   break;
                   else
                            temp = temp->next;
         }
         if(temp == NULL )
                   printf ( " 没有查找到该人资料 /n" );
         return temp;
}
 
void print_data(point)
struct chain *point;
{
         if(point == NULL )
                   return;
         printf ( " 查找结果： /n" );
         printf ( "         姓名： %s/n" ,point-> name );
         printf ( "         城市： %s/n" ,point->city);
         printf ( "         性别： %s/n" ,point->sex);
         printf ( "         年龄： %s/n" ,point->age);
         printf ( "         工作： %s/n" ,point->job);
}
二分法查找：
#include < stdio .h>
#include <stdlib.h>
#include < string .h>
#define NUM 4
 
struct Data
{
         char name [20];
         char city [20];
         char sex [10];
         char age [10];
         char job [10];
};
 
struct Data SDatas [ NUM ]=
{
         "Sun" , "Weifang" , "Male" , "24" , "student" ,
         "Tom" , "Beijing" , "Male" , "31" , "doctor" ,
         "Marry" , "Shanghai" , "Female" , "19" , "techer" ,
         "Willing" , "Tianjing" , "Female" , "21" , "worker"
};
 
void qs_struct (items, left , right );
void quick_struct (items, count );
int BinarySeach (items, name , n );
void print_data (point);
 
int main ( void )
{
         char name [30];
         int i ;
         printf ( " 将原始数据排序 /n" );
         quick_struct ( SDatas , NUM );
         printf ( " 请输入要查找人的名字： /n" );
         scanf ( "%s" , name );
         i = BinarySeach ( SDatas , name , NUM );
         if ( i == -1)
         {
                   printf ( " 没有查找到该人信息 /n" );
                   return 0;
         }
         printf ( " 查找结果： /n" );
         print_data (& SDatas [ i ]);
         return 1;
}
 
 
void quick_struct (items, count )
struct Data items[];
int count ;
{
         qs_struct (items,0, count -1);
}
 
void qs_struct (items, left , right )
struct Data items[];
int left ;
int right ;
{
         register int i , j ;
         char * x ;
         struct Data temp ;
         i = left ;
         j = right ;
         x = items[( left + right /2)]. name ;
         do
         {
                  while (( strcmp (items[ i ]. name , x )<0)&&( i < right ))
                            i ++;
                  while (( strcmp (items[ j ]. name , x )>0)&&( j > left ))
                            j --;
                   if ( i <= j )
                   {
                            temp = items[ i ];
                            items[ i ] = items[ j ];
                            items[ j ] = temp ;
                            i ++;
                            j --;
                   }
         } while ( i <= j );
         if ( left < j )
                  qs_struct (items, left , j );
         if ( i < right )
                  qs_struct (items, i , right );
}
 
int BinarySeach (items, name , n )
struct Data items[];
char name [];
int n ;
{
         int low , high , mid ;
         low = 0;
         high = n -1;
         while ( low <= high )
         {
                   mid = ( low + high )/2;
                  if (( strcmp (items[ mid ]. name , name )==0))
                            return mid ;
                   else if (( strcmp (items[ mid ]. name , name )<0))
                            low = mid +1;
                   else high = mid -1;
         }
         return -1;
}
 
void print_data (point)
struct Data *point;
{
         if (point == NULL )
                   return ;
         printf ( "         姓名： %s/n" ,point-> name );
         printf ( "         城市： %s/n" ,point-> city );
         printf ( "         性别： %s/n" ,point-> sex );
         printf ( "         年龄： %s/n" ,point-> age );
         printf ( "         工作： %s/n" ,point-> job );
}
树查找：
#include < stdio .h>
#include <stdlib.h>
#include < string .h>
#define NUM 4
 
struct tree
{
         char name [20];
         char city [20];
         char sex [10];
         char age [10];
         char job [10];
         struct tree * left ;
         struct tree * right ;
};
 
struct tree Datas [ NUM ]=
{
         "Willing" , "Tianjing" , "Female" , "21" , "worker" , NULL , NULL ,
         "Tom" , "Beijing" , "Male" , "31" , "doctor" , NULL , NULL ,
         "Sun" , "Weifang" , "Male" , "24" , "student" , NULL , NULL ,
         "Marry" , "Shanghai" , "Female" , "19" , "techer" , NULL , NULL
};
 
struct tree * construct (
         struct tree * root ,
         struct tree * r ,
         struct tree * Data )
{
         if (! r )
         {
                   r = ( struct tree *) malloc ( sizeof ( struct tree ));
                   if (! r )
                   {
                            printf ( " 内存分配失败！ " );
                            exit (0);
                   }
                   r -> left = NULL ;
                   r -> right = NULL ;
                  strcpy ( r -> name , Data -> name );
                  strcpy ( r -> city , Data -> city );
                  strcpy ( r -> sex , Data -> sex );
                  strcpy ( r -> age , Data -> age );
                  strcpy ( r -> job , Data -> job );
                  if (! root )
                            return r ;
                  if ( strcmp ( Data -> name , root -> name )<0)
                            root -> left = r ;
                   else
                            root -> right = r ;
                   return r ;
         }
         if ( strcmp ( Data -> name , r -> name )<0)
                  construct ( r , r -> left , Data );
         else
                  construct ( r , r -> right , Data );
 
         return root ;        
}
 
struct tree * Search ( root , name )
struct tree * root ;
char name [];
{
         struct tree * p ;
         if ( root == NULL )
                   printf ( " 该树为空 /n" );
         p = root ;
         while ( strcmp ( p -> name , name )!=0)
         {
                  if ( strcmp ( p -> name , name )>0)
                            p = p -> left ;
                   else
                            p = p -> right ;
                   if ( p == NULL )
                            break ;
         }
         return ( p );
}
 
void print ( struct tree * r )
{
         if (! r )
                   return ;
         print ( r -> left );
         printf ( "%s/n" , r -> name );
         print ( r -> right );
}
 
void print_currentData ( struct tree * point )
{
         if ( point == NULL )
                   return ;
         printf ( "         姓名： %s/n" , point -> name );
         printf ( "         城市： %s/n" , point -> city );
         printf ( "         性别： %s/n" , point -> sex );
         printf ( "         年龄： %s/n" , point -> age );
         printf ( "         工作： %s/n" , point -> job );
}
 
int main ( void )
{
         int i ;
         char c [10];
         char swap [20];
         char name [20];
         struct tree * root ,* p ;
         struct tree * temp ;
         p = NULL ;
         temp = NULL ;
         root = NULL ;
         for ( i = 0; i < NUM ; i ++)
                   root = construct ( root , root ,& Datas [ i ]);
         printf ( " 现有人员资料： /n" );
         print ( root );
         printf ( " 请输入要查找的人的名字 /n" );
         scanf ( "%s" , name );
         p = Search ( root , name );
         if ( p == NULL )
         {
                   printf ( " 没有该人资料 /n" );
                   printf ( " 是否要插入该人资料 [y/n]/n" );
                  scanf ( "%s" , c );
                  if ( strcmp ( c , "y" )==0)
                   {
                            temp = ( struct tree *) malloc ( sizeof ( struct tree ));
                            if (! temp )
                            {
                                     printf ( " 内存分配失败！ " );
                                     exit (0);
                            }
                            printf ( " 请输入该人姓名： /n" );
                            scanf ( "%s" , swap );
                            strcpy ( temp -> name , swap );
                            printf ( " 请输入该人所在城市： /n" );
                            scanf ( "%s" , swap );
                            strcpy ( temp -> city , swap );
                            printf ( " 请输入该人性别 [Male/Female] ： /n" );
                            scanf ( "%s" , swap );
                            strcpy ( temp -> sex , swap );
                            printf ( " 请输入该人年龄： /n" );
                            scanf ( "%s" , swap );
                            strcpy ( temp -> age , swap );
                            printf ( " 请输入该人工作： /n" );
                            scanf ( "%s" , swap );
                            strcpy ( temp -> job , swap );
                            temp -> left = NULL ;
                            temp -> right = NULL ;
                            root = construct ( root , root , temp );
                            print_currentData ( temp );
                            printf ( " 现有人员资料： /n" );
                            root = root ;
                            print ( root );
                   }
                   else
                            return 0;
         }
         print_currentData ( p );
         return 1;
}
 
yuhongwei
关注
专栏目录
漫画算法2：小灰的算法进阶.pptx
10-13
漫画算法2：小灰的算法进阶 《漫画算法2：小灰的算法进阶》是一本以漫画形式生动展现算法进阶知识的图书。本书以小灰的视角，通过一系列有趣的场景和生动的漫画，深入浅出地讲解了算法的高级概念和技术，包括图算法...
Hello 算法.pdf
11-13
"Hello 算法.pdf" 该书籍主要介绍了数据结构与算法的入门知识，旨在帮助读者从零开始学习算法。作者靳宇栋（Krahets）通过结合实践经验，提供了一份详细的学习指南，涵盖了算法学习的基础知识、数据结构、算法设计...
背包算法简介
sigd的博客
06-07 1万+
一、概述 背包算法是最常见的一种DP算法。它的核心要素有三个：背包容量，物品重量，物品价值。 在不同的题目中这三要素可能表现为多种形式，比如背包容量是时间（P1048 采药），体力（P1510 精卫填海），数值（P1734 最大约数和）。物品重量和背包容量在同一题目中的概念是一致的。在物品价值方面，如果题目给了价值或者价值计算方法（P1060 开心的金明），那么我们写dp方程时按题目要求添加即可。如果没有给物品价值，只是让我们求能填充的最大容量或者求方案数，我们可以将dp数组的0号单元置1，dp[0]=1
凸包算法详解
m0_54123999的博客
06-04 4445
一些废话：写这篇博客是因为在听算法网课老师讲分治的时候提到过分治法求凸包的问题，当时没怎么听懂也没太在意这个（因为老师只是提了一嘴，没有细讲），结果好巧不巧，第二天力扣的每日一题就是凸包问题，题目在这：力扣 然后就想着好好学一下凸包算法，但因为我比较懒。。。立了计划后给这篇博客起了个头就没管了，直到几乎20天后，力扣的每日一题又又又有一题可以用凸包做，题目：力扣 所以我特意抽出一个下午好好看了一下各种凸包算法，写下了这篇博客。 注：一下算法均围绕力扣题目 587.安装栅栏 来讨论 前置知识： 设平
常见十四种的Java算法
心有谦谦结
04-17 4万+
一、简单列出常见的Java中14种算法 序号 简称 英文名称 简介 1 二分查找 Binary Search 二分查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。 2 冒泡排序 Bubble Sort 3 插入排序 4 快速排序 5 希尔排序 6 归并排序 7 桶排序 8 基数排序
AES算法详解
qq_44717657的博客
05-06 1万+
AES算法详解，包括由来，优缺点和算法过程 以及在Java中简单使用AES算法加解密
BF，KMP算法（万字图文详解）
热门推荐
weixin_64067830的博客
06-11 6万+
BF，KMP算法（万字图文详解）
ADMM算法学习
weixin_44655342的博客
12-13 3万+
ADMM算法学习ADMM定义ADMM方法问题模型增广拉格朗日函数算法流程算法测试参考资料 ADMM定义 交替向乘子法（Alternating Direction Method of Multipliers, ADMM）是一种求解具有可分离的凸优化问题的重要方法，由于处理速度快，收敛性能好，ADMM算法在统计学习、机器学习等领域有着广泛应用。 ADMM方法 问题模型 交替方向乘子法（ADMM）通常用于解决存在两个优化变量的等式约束优化类问题，其一般形式为：min⁡x,zf(x)+g(z) &nbsp
遗传算法
mrdonghe的博客
12-25 3697
一.遗传算法 遗传算法是从代表问题可能潜在的解集的一个种群（population）开始的，而一个种群则由经过基因（gene）编码的一定数目的个体(individual)组成。每个个体实际上是染色体(chromosome)带有特征的实体。 染色体作为遗传物质的主要载体，即多个基因的集合，其内部表现（即基因型）是某种基因组合，它决定了个体的形状的外部表现，如黑头发的特征是由染色体中控制这一特征的某...
操作系统———磁盘调度算法模拟
weixin_62659979的博客
12-09 1995
【代码】操作系统———磁盘调度算法模拟。
免疫算法（IA）
太可惹的博客
07-21 2427
是机体的一种生理反应，当病原体（即抗原）进入人体时，这些抗原将刺激免疫细胞（淋巴B细胞、T细胞）产生一种抵抗该病原生物的特殊蛋白质——抗体。抗体能将该病原生物消灭，并在将病原生物消灭之后，仍存留在人体内。
限流算法及接口实现
青衫烟雨客的专栏
02-01 7352
限流是一种通过控制请求的速率或数量来保护系统免受过载的技术。流控的精髓是限制单位时间内的请求量，最大程度保障系统的可靠性及可用性。固定窗口限流算法（Fixed Window Rate Limiting Algorithm）是一种最简单的限流算法，其原理是在固定时间窗口(单位时间)内限制请求的数量。为了解决临界突变问题，可以引入滑动窗口。即：把大的时间窗口拆分成若干粒度更细的子窗口，每个子窗口独立统计，按子窗口时间滑动，统一限流。
代码 基于遗传算法的Bp神经网络优化算法代码
06-04
代码 基于遗传算法的Bp神经网络优化算法代码代码 基于遗传算法的Bp神经网络优化算法代码代码 基于遗传算法的Bp神经网络优化算法代码代码 基于遗传算法的Bp神经网络优化算法代码代码 基于遗传算法的Bp神经网络优化...
落实算法安全主体责任基本情况（模板）
08-18
在当前的数字化时代，算法已成为企业运营的核心组成部分，特别是在互联网信息服务领域。算法安全的重要性日益凸显，因为不安全的算法可能导致信息泄露、用户隐私侵犯、甚至社会秩序混乱等问题。因此，落实算法安全的...
国密算法(国家商用密码算法简介).pdf
05-10
国密算法是中国的国家商用密码算法的简称，它包含了一系列的加密技术标准和规范，这些算法和规范被用于商业和政府信息系统的加密通讯以及数据保护。在中国，国密算法是推动信息安全、保障信息传输安全、防止信息泄露...
atcoder abc372 启发式合并， dp
2201_75845839的博客
09-22 463
现在考虑如何存数据。可以用并查集合并两个集合，并且在合并的时候一定要将小的集合合并到大的集合中去，因为小集合合并到大集合中，最后的集合一定大于小集合元素数量的两倍，因此合并的时间复杂度不会超过logn。思路：判断当前变化的位置对结果是否会产生影响，在询问前先计算有多少ABC, 每次变换位置x前后扫描一下[x - 2, x + 2]范围内是否有ABC，变换前有让cnt --， 变换后有让cnt ++思路：三进制转换，可以参考二进制，先把当前可以加入的最大的3的幂次加入,这样一定可以凑出答案。
C++初阶：STL详解（四）——vector迭代器失效问题
Zhihuiguoz的博客
09-19 812
STL详解（四）——引起迭代器失效的场景及其解决方案（浅显易懂，轻松上手；一键拿捏，小白也能看懂）
189. 轮转数组（C++）
最新发布
weixin_45813121的博客
09-25 338
给定一个整数数组nums，将数组中的元素向右轮转k个位置，其中k是非负数。
C语言题目之单身狗2
something for nothing的博客
09-22 468
c语言题目之找单身狗2：在一堆数中找到两个只出现过一次数的数
labuladong算法刷题攻略
"labuladong算法秘籍" 这篇资源主要围绕labuladong的算法学习方法和刷题策略，涵盖了广泛的算法与数据结构知识。它分为几个篇章，旨在帮助读者系统性地掌握算法思维和实战技巧。 无剑篇——刷题心法与基础数据结构...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值