算法

最新推荐文章于 2025-07-26 21:13:40 发布
最新推荐文章于 2025-07-26 21:13:40 发布
阅读量766 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： 算法 文章标签： 算法 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;
intcount;
{
         registerintm,n;
         registerchars;
         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;
                            }
                   }
}
 
intmain(void)
{
         intcount;
         charstr[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
 
statica[8] = {MARK,25,4,36,1,60,10,58,};
intcount = 1;
voidheap(intn);
voidadjust(inti,intn);
 
intmain(void)
{
         inti;
         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;
}
 
voidheap(n)
intn;
{
         inti,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]);
         }
}
 
voidadjust(i,n)
inti,n;
{
         intj,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,intleft,intright);
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)
{
         inti;
         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,intleft,intright)
{
         long inti,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;
         inti;
         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
 
structData
{
         charname[20];
         charcity[20];
         charsex[10];
         charage[10];
         charjob[10];
};
 
structDataSDatas[NUM]=
{
         "Sun","Weifang","Male","24","student",
         "Tom","Beijing","Male","31","doctor",
         "Marry","Shanghai","Female","19","techer",
         "Willing","Tianjing","Female","21","worker"
};
 
voidqs_struct(items,left,right);
voidquick_struct(items,count);
intBinarySeach(items,name,n);
voidprint_data(point);
 
intmain(void)
{
         charname[30];
         inti;
         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;
}
 
 
voidquick_struct(items,count)
structData items[];
intcount;
{
         qs_struct(items,0,count-1);
}
 
voidqs_struct(items,left,right)
structData items[];
intleft;
intright;
{
         registerinti,j;
         char *x;
         structDatatemp;
         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);
}
 
intBinarySeach(items,name,n)
structData items[];
charname[];
intn;
{
         intlow,high,mid;
         low = 0;
         high = n-1;
         while(low<=high)
         {
                   mid = (low+high)/2;
                  if((strcmp(items[mid].name,name)==0))
                            returnmid;
                   elseif((strcmp(items[mid].name,name)<0))
                            low = mid+1;
                   elsehigh = mid-1;
         }
         return -1;
}
 
voidprint_data(point)
structData *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
 
structtree
{
         charname[20];
         charcity[20];
         charsex[10];
         charage[10];
         charjob[10];
         structtree *left;
         structtree *right;
};
 
structtreeDatas[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
};
 
structtree *construct(
         structtree *root,
         structtree *r,
         structtree *Data)
{
         if(!r)
         {
                   r = (structtree *)malloc(sizeof(structtree));
                   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)
                            returnr;
                  if(strcmp(Data->name,root->name)<0)
                            root->left = r;
                   else
                            root->right = r;
                   returnr;
         }
         if(strcmp(Data->name,r->name)<0)
                  construct(r,r->left,Data);
         else
                  construct(r,r->right,Data);
 
         returnroot;        
}
 
structtree *Search(root,name)
structtree *root;
charname[];
{
         structtree *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);
}
 
voidprint(structtree *r)
{
         if(!r)
                   return;
         print(r->left);
         printf("%s/n",r->name);
         print(r->right);
}
 
voidprint_currentData(structtree *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);
}
 
intmain(void)
{
         inti;
         charc[10];
         charswap[20];
         charname[20];
         structtree *root,*p;
         structtree *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 = (structtree *)malloc(sizeof(structtree));
                            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;
}
 
计算机视觉图像分割入门：阈值、区域生长与分水岭算法
CSDN博客专家，系统架构师，有合作、疑惑请私信博主。
04-14 12万+
计算机视觉图像分割入门：阈值、区域生长与分水岭算法，人工智能，AI，图像分割，机器视觉在当今数字化的时代，计算机视觉技术正以前所未有的速度改变着我们的生活。从智能手机中的人脸识别解锁，到自动驾驶汽车的环境感知，再到医学影像分析中的疾病诊断，计算机视觉无处不在。而在这众多令人惊叹的应用背后，图像分割技术无疑是其中的关键基石之一。
国密算法SM3 C语言 摘要算法
03-06
通过C语言实现国密SM3算法，可实现对内容的摘要计算
Retinex 算法
热门推荐
chaiky的博客
05-08 2万+
1、Retinex 理论及数学模型 2、Retinex 算法发展历程 2.1 基于迭代的 Retinex 算法 2.1.1 Frankle-McCann Retinex 算法 2.1.2 McCann99 Retinex 算法 2.2基于中心环绕的 Retinex 算法 2.2.1SSR算法（单尺度） 2.2.2MSR算法（多尺度） 2.2.3MSRCR算法 2.3Retinex算法的频域处理............
算法设计与分析期末复习
m0_62784756的博客
05-20 4458
算法设计与分析复习
算法的时间复杂度（详解）
2301_78724721的博客
05-29 4815
时间复杂度是衡量算法执行效率的重要指标，它表示算法随输入数据规模增长时执行时间的变化趋势。优化时间复杂度可以节省计算资源、提高系统性能、满足实时性要求，并提升用户体验。在设计算法时，应充分考虑时间复杂度的优化，以实现高效、稳定的性能表现。
软考-常见算法题
weixin_43512504的博客
05-04 5059
相关概念 算法是由基本运算及规定的运算顺序所构成的完整的解题步骤。 算法应该具有以下五个重要的特征： 1、有穷性（Finiteness）：指算法必须能在执行有限个步骤之后终止； 2、确定性(Definiteness)：算法的每一条指令必须有确切的含义； 3、输入(Input)：一个算法有0个或多个输入； 4、输出(Output)：一个算法有1个或多个输出； 5、可行性(Effectiveness)：算法的每个步骤都能有效执行并能得到确定的结果 （也称有效性）。 算法类型 软考中...
算法——枚举法
Krisit的博客
08-11 2036
对于枚举算法，应尽量用在数据量较小的地方，优化方案应从加强约束条件，缩小枚举范围为主要方向。
物体识别相关的算法
xie__jin__cheng的博客
07-29 2411
物体识别相关的算法
SIFT算法
weixin_44493841的博客
06-26 2603
SIFT算法转自：https://cloud.tencent.com/developer/news/149140 介绍了这么久的SIFT相关的一些理论基础和方法，今天就给大家介绍一下这个传说中的算法（千呼万唤始出来。。。），因为该算法包含好几个步骤，我们之间介绍的都是最开始的步骤，也是最难理解的步骤，有了这些基础，SIFT算法理解起来就不会那么复杂了，所以我们今天直接把算法从头到尾介绍...
雪花算法
yudiipp的博客
04-26 1414
一种特殊的算法可以计算得到一个唯一标识。
普里姆算法
qq_47897078的博客
06-02 1万+
普里姆算法（Prim’s algorithm）是图中的一种算法，可在加权连通图中搜索最小生成树。该算法的作用就是根据图中权值找到连接所有顶点的最短路径，也就是连接所有顶点的最小权值之和，也是这个加权图中的最小生成树。1.选取权值最小边的其中一个顶点作为起始点。 2.找到离当前顶点权值最小的边，并记录该顶点为已选择。 3.重复第二步，直到找到所有顶点，就找到了图的最小生成树。假如我们有 V 表示图中的顶点个数，E 表示图中的边个数。通过邻接矩阵图表示的简易实现中，找到所有最小权边共需 [外链图片转存失败,源
PID算法相关资料数字PID控制算法C语言实现PID算法等源码及技术文档资料合集.zip
04-10
PID算法相关资料数字PID控制算法C语言实现PID算法等源码及技术文档资料合集: 51单片机PID算法程序_三_增量式PID控制算法.pdf AN_SPMC75_0012 ARDUINO C语言PID算法.pdf C语言实现PID算法-27.pdf C语言实现PID算法-28...
GS算法MATLAB全息图生成.zip
11-10
GS算法MATLAB全息图生成 多层传播 GS算法MATLAB全息图生成 多层传播 GS算法MATLAB全息图生成 多层传播 GS算法MATLAB全息图生成 多层传播 GS算法MATLAB全息图生成 多层传播 GS算法MATLAB全息图生成 多层传播 GS算法...
数学建模常用的30个常用算法(Python代码).zip
08-06
数学建模常用的30个常用算法(Python代码)数学建模常用的30个常用算法(Python代码)数学建模常用的30个常用算法(Python代码)数学建模常用的30个常用算法(Python代码)数学建模常用的30个常用算法(Python代码)数学建模...
基于遗传算法任务调度算法
05-07
【基于遗传算法任务调度算法】是一种优化方法，用于解决复杂问题中的任务分配和调度问题。在本项目中，这个算法是用MATLAB编程语言实现的，特别针对工件设计过程的任务调度。MATLAB是一种强大的计算环境，适合进行...
枚举右，维护左基础篇
m0_68367618的博客
07-23 378
本文总结了力扣题单中基于双变量问题的通用解法模板。核心思路是：通过维护已遍历区间（使用哈希表、集合或滑动窗口），枚举未遍历区间来优化双变量问题。
php算法-- 关联数组使用，优化sip账号去重
qq_43538607的博客
07-25 272
php-关联数组使用，优化sip账号去重
力扣-416.分割等和子集
weixin_46878941的博客
07-25 194
小结：01背包问题，先遍历物品，再遍历背包，逆序遍历背包，确保每个数组只用一次。
【算法】前缀和经典例题
最新发布
关注学习C++领域，感谢陪伴，共同进步！
07-26 713
1.预处理出来一个前缀和数组⽤ dp[i] 表⽰： [1, i] 区间内所有元素的和，那么 dp[i - 1] ⾥⾯存的就是 [1,i - 1] 区间内所有元素的和，那么：可得递推公式： dp[i] = dp[i - 1] + arr[i]；2.使用前缀和数组当询问的区间是 [l, r] 时：区间内所有元素的和为： dp[r] - dp[l - 1]细节问题:为什么下标要从1开始计数?
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值