2026年C语言程序设计经典100例（算法与数据结构）

2026年C语言程序设计经典100例（算法与数据结构）

2026年C语言程序设计经典100例（算法与数据结构）

在当今信息技术飞速发展的时代，C语言作为一种基础且强大的编程语言，依然在软件开发、嵌入式系统、操作系统等领域扮演着举足轻重的角色。掌握C语言，不仅能够帮助开发者深入理解计算机底层原理，还能为后续学习更高级的编程语言打下坚实的基础。特别是在算法与数据结构方面，C语言提供了丰富的工具和灵活的操作方式，使得开发者能够高效地实现各种复杂的算法逻辑。为了帮助广大学习者更好地掌握C语言程序设计，我们精心整理了100个经典实例，涵盖了算法与数据结构的核心内容，旨在通过实例教学的方式，让学习者在实践中不断提升编程能力。

###一、基础算法与数据结构

####1.排序算法

排序算法是算法领域中最为基础也是最为重要的部分之一。在C语言中，实现排序算法可以通过多种方式，如冒泡排序、选择排序、插入排序、快速排序、归并排序等。这些排序算法各有特点，适用于不同的场景。下面我们通过几个实例来详细讲解这些排序算法的实现。

#####冒泡排序

冒泡排序是一种简单的排序算法，它通过重复地遍历待排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

#include<stdio.h>

voidbubbleSort(intarr[],intn){

inti,j,temp;

for(i=0;i<n-1;i++){

for(j=0;j<n-i-1;j++){

if(arr[j]>arr[j+1]){

temp=arr[j];

arr[j]=arr[j+1];

arr[j+1]=temp;

}

}

}

}

intmain(){

intarr[]={64,34,25,12,22,11,90};

intn=sizeof(arr)/sizeof(arr[0]);

bubbleSort(arr,n);

printf("Sortedarray:\n");

for(inti=0;i<n;i++){

printf("%d",arr[i]);

}

printf("\n");

return0;

}

#####选择排序

选择排序是一种简单直观的排序算法。它的工作原理是：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

#include<stdio.h>

voidselectionSort(intarr[],intn){

inti,j,min_idx,temp;

for(i=0;i<n-1;i++){

min_idx=i;

for(j=i+1;j<n;j++){

if(arr[j]<arr[min_idx]){

min_idx=j;

}

}

temp=arr[min_idx];

arr[min_idx]=arr[i];

arr[i]=temp;

}

}

intmain(){

intarr[]={64,34,25,12,22,11,90};

intn=sizeof(arr)/sizeof(arr[0]);

selectionSort(arr,n);

printf("Sortedarray:\n");

for(inti=0;i<n;i++){

printf("%d",arr[i]);

}

printf("\n");

return0;

}

#####插入排序

插入排序是一种简单的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序）。

#include<stdio.h>

voidinsertionSort(intarr[],intn){

inti,key,j;

for(i=1;i<n;i++){

key=arr[i];

j=i-1;

while(j>=0&&arr[j]>key){

arr[j+1]=arr[j];

j=j-1;

}

arr[j+1]=key;

}

}

intmain(){

intarr[]={64,34,25,12,22,11,90};

intn=sizeof(arr)/sizeof(arr[0]);

insertionSort(arr,n);

printf("Sortedarray:\n");

for(inti=0;i<n;i++){

printf("%d",arr[i]);

}

printf("\n");

return0;

}

#####快速排序

快速排序是一种分而治之的排序算法。它通过选择一个“基准”元素，将数组分为两个子数组，一个子数组的所有元素都不大于基准，另一个子数组的所有元素都不小于基准，然后递归地对这两个子数组进行快速排序。

#include<stdio.h>

voidswap(int*a,int*b){

intt=*a;

*a=*b;

*b=t;

}

intpartition(intarr[],intlow,inthigh){

intpivot=arr[high];

inti=(low-1);

for(intj=low;j<=high-1;j++){

if(arr[j]<pivot){

i++;

swap(&arr[i],&arr[j]);

}

}

swap(&arr[i+1],&arr[high]);

return(i+1);

}

voidquickSort(intarr[],intlow,inthigh){

if(low<high){

intpi=partition(arr,low,high);

quickSort(arr,low,pi-1);

quickSort(arr,pi+1,high);

}

}

intmain(){

intarr[]={64,34,25,12,22,11,90};

intn=sizeof(arr)/sizeof(arr[0]);

quickSort(arr,0,n-1);

printf("Sortedarray:\n");

for(inti=0;i<n;i++){

printf("%d",arr[i]);

}

printf("\n");

return0;

}

#####归并排序

归并排序是一种分而治之的排序算法。它将数组分成两半，分别对它们进行排序，然后将两个有序的子数组合并成一个有序数组。

#include<stdio.h>

voidmerge(intarr[],intl,intm,intr){

inti,j,k;

intn1=m-l+1;

intn2=r-m;

intL[n1],R[n2];

for(i=0;i<n1;i++)

L[i]=arr[l+i];

for(j=0;j<n2;j++)

R[j]=arr[m+1+j];

i=0;

j=0;

k=l;

while(i<n1&&j<n2){

if(L[i]<=R[j]){

arr[k]=L[i];

i++;

}else{

arr[k]=R[j];

j++;

}

k++;

}

while(i<n1){

arr[k]=L[i];

i++;

k++;

}

while(j<n2){

arr[k]=R[j];

j++;

k++;

}

}

voidmergeSort(intarr[],intl,intr){

if(l<r){

intm=l+(r-l)/2;

mergeSort(arr,l,m);

mergeSort(arr,m+1,r);

merge(arr,l,m,r);

}

}

intmain(){

intarr[]={64,34,25,12,22,11,90};

intn=sizeof(arr)/sizeof(arr[0]);

mergeSort(arr,0,n-1);

printf("Sortedarray:\n");

for(inti=0;i<n;i++){

printf("%d",arr[i]);

}

printf("\n");

return0;

}

###二、查找算法

查找算法是算法的另一重要组成部分。常见的查找算法有线性查找、二分查找等。下面我们通过实例来讲解这些查找算法的实现。

#####线性查找

线性查找是最简单的查找算法，它通过遍历数组中的每个元素，逐一比较直到找到目标值。

#include<stdio.h>

intlinearSearch(intarr[],intn,intx){

for(inti=0;i<n;i++){

if(arr[i]==x){

returni;

}

}

return-1;

}

intmain(){

intarr[]={64,34,25,12,22,11,90};

intn=sizeof(arr)/sizeof(arr[0]);

intx=25;

intresult=linearSearch(arr,n,x);

if(result==-1){

printf("Elementisnotpresentinarray");

}else{

printf("Elementispresentatindex%d",result);

}

return0;

}

#####二分查找

二分查找是一种高效的查找算法，它要求数组必须是有序的。二分查找通过repeatedlydividinginhalftheportionofthelistthatcouldcontaintheitem，直到找到目标值或者确定该值不存在。

#include<stdio.h>

intbinarySearch(intarr[],intl,intr,intx){

while(l<=r){

intm=l+(r-l)/2;

if(arr[m]==x){

returnm;

}

if(arr[m]<x){

l=m+1;

}else{

r=m-1;

}

}

return-1;

}

intmain(){

intarr[]={64,34,25,12,22,11,90};

intn=sizeof(arr)/sizeof(arr[0]);

intx=25;

intresult=binarySearch(arr,0,n-1,x);

if(result==-1){

printf("Elementisnotpresentinarray");

}else{

printf("Elementispresentatindex%d",result);

}

return0;

}

###三、递归与动态规划

递归和动态规划是算法设计中的重要技巧，它们在解决复杂问题时展现出强大的能力。下面我们通过实例来讲解递归和动态规划的应用。

#####递归

递归是一种在函数内部调用自身的编程技巧。递归算法通常用于解决可以分解为相似子问题的问题。

#include<stdio.h>

intfactorial(intn){

if(n==0){

return1;

}

returnn*factorial(n-1);

}

intmain(){

intnum=5;

printf("Factorialof%dis%d",num,factorial(num));

return0;

}

#####动态规划

动态规划是一种通过将问题分解为更小的子问题并存储子问题的解来避免重复计算的方法。动态规划通常用于解决最优化问题。

#include<stdio.h>

intmax(inta,intb){

return(a>b)?a:b;

}

intknapsack(intW,intwt[],intval[],intn){

inti,w;

intK[n+1][W+1];

for(i=0;i<=n;i++){

for(w=0;w<=W;w++){

if(i==0||w==0){

K[i][w]=0;

}elseif(wt[i-1]<=w){

K[i][w]=max(val[i-1]+K[i-1][w-wt[i-1]],K[i-1][w]);

}else{

K[i][w]=K[i-1][w];

}

}

}

returnK[n][W];

}

intmain(){

intval[]={60,100,120};

intwt[]={10,20,30};

intW=50;

intn=sizeof(val)/sizeof(val[0]);

printf("Maximumvalueinknapsack=%d",knapsack(W,wt,val,n));

return0;

}

###四、图算法

图算法是算法设计中的重要部分，它们在解决网络问题、路径规划等问题时展现出强大的能力。下面我们通过实例来讲解图算法的应用。

#####图的表示

图的表示主要有两种方式：邻接矩阵和邻接表。邻接矩阵使用二维数组表示图，邻接表使用链表表示图。

#include<stdio.h>

voidaddEdge(intadj[][10],intu,intv){

adj[u][v]=1;

adj[v][u]=1;

}

voidprintGraph(intadj[][10],intV){

for(intu=0;u<V;u++){

for(intv=0;v<V;v++){

if(adj[u][v]){

printf("%d-%d\n",u,v);

}

}

}

}

intmain(){

intV=4;

intadj[10][10]={0};

addEdge(adj,0,1);

addEdge(adj,0,2);

addEdge(adj,1,2);

addEdge(adj,2,3);

printGraph(adj,V);

return0;

}

#####深度优先搜索

深度优先搜索（DFS）是一种用于遍历或搜索树或图的算法。DFS通过递归地访问每个节点的邻接节点来遍历图。

#include<stdio.h>

#include<stdlib.h>

voidDFS(intadj[][10],intV,intvisited[],ints){

visited[s]=1;

printf("%d",s);

for(inti=0;i<V;i++){

if(adj[s][i]&&!visited[i]){

DFS(adj,V,visited,i);

}

}

}

intmain(){

intV=4;

intadj[10][10]={0};

intvisited[10]={0};

addEdge(adj,0,1);

addEdge(adj,0,2);

addEdge(adj,1,2);

addEdge(adj,2,3);

DFS(adj,V,visited,0);

return0;

}

#####广度优先搜索

广度优先搜索（BFS）是一种用于遍历或搜索树或图的算法。BFS通过按层次遍历每个节点的邻接节点来遍历图。

#include<stdio.h>

#include<stdlib.h>

voidBFS(intadj[][10],intV,intvisited[],ints){

intqueue[10],front=0,rear=0;

visited[s]=1;

queue[rear++]=s;

while(front<rear){

intu=queue[front++];

printf("%d",u);

for(inti=0;i<V;i++){

if(adj[u][i]&&!visited[i]){

visited[i]=1;

queue[rear++]=i;

}

}

}

}

intmain(){

intV=4;

intadj[10][10]={0};

intvisited[10]={0};

addEdge(adj,0,1);

addEdge(adj,0,2);

addEdge(adj,1,2);

addEdge(adj,2,3);

BFS(adj,V,visited,0);

return0;

}

###五、字符串处理

字符串处理是C语言程序设计中常见的任务之一。下面我们通过实例来讲解字符串处理的应用。

#####字符串反转

字符串反转是将字符串中的字符顺序颠倒过来。

#include<stdio.h>

#include<string.h>

voidreverseString(charstr[],intn){

inti,j;

for(i=0,j=n-1;i<j;i++,j--){

chartemp=str[i];

str[i]=str[j];

str[j]=temp;

}

}

intmain(){

charstr[]="Hello,World!";

intn=strlen(str);

reverseString(str,n);

printf("Reversedstring:%s\n",str);

return0;

}

#####字符串查找

字符串查找是在一个字符串中查找另一个字符串是否存在。

#include<stdio.h>

#include<string.h>

intstringSearch(charstr[],charsub[]){

intn=strlen(str);

intm=strlen(sub);

for(inti=0;i<=n-m;i++){

intj;

for(j=0;j<m;j++){

if(str[i+j]!=sub[j]){

break;

}

}

if(j==m){

returni;

}

}

return-1;

}

intmain(){

charstr[]="Hello,World!";

charsub[]="World";

intresult=stringSearch(str,sub);

if(result!=-1){

printf("Substringfoundatindex%d",result);

}else{

printf("Substringnotfound");

}

return0;

}

#####字符串替换

字符串替换是将字符串中的一个子字符串替换为另一个子字符串。

#include<stdio.h>

#include<string.h>

voidreplaceString(charstr[],charfind[],charreplace[]){

intfindLen=strlen(find);

inti,j,k;

for(i=0;str[i]!='\0';){

for(j=0;j<findLen&&str[i+j]==find[j];j++){

if(find[j+1]=='\0'){

for(k=0;replace[k]!='\0';k++,i++){

str[i]=replace[k];

}

i+=findLen-1;

break;

}

}

if(str[i]=='\0'){

break;

}

i++;

}

}

intmain(){

charstr[]="Hello,World!";

charfind[]="World";

charreplace[]="C语言";

replaceString(str,find,replace);

printf("Replacedstring:%s\n",str);

return0;

}

###六、文件操作

文件操作是C语言程序设计中常见的任务之一。下面我们通过实例来讲解文件操作的应用。

#####读取文件内容

读取文件内容是将文件中的内容读取到内存中。

#include<stdio.h>

intmain(){

FILE*file=fopen("example.txt","r");

if(file==NULL){

printf("Erroropeningfile");

return1;

}

charch;

while((ch=fgetc(file))!=EOF){

printf("%c",ch);

}

fclose(file);

return0;

}

#####写入文件内容

写入文件内容是将内容写入到文件中。

#include<stdio.h>

intmain(){

FILE*file=fopen("example.txt","w");

if(file==NULL){

printf("Erroropeningfile");

return1;

}

fprintf(file,"Hello,World!");

fclose(file);

return0;

}

#####文件复制

文件复制是将一个文件的内容复制到另一个文件中。

#include<stdio.h>

intmain(){

FILE*source=fopen("source.txt","r");

FILE*destination=fopen("destination.txt","w");

if(source==NULL||destination==NULL){

printf("Erroropeningfile");

return1;

}

charch;

while((ch=fgetc(source))!=EOF){

fputc(ch,destination);

}

fclose(source);

fclose(destination);

return0;

}

#####文件合并

文件合并是将多个文件的内容合并到一个文件中。

#include<stdio.h>

intmain(){

FILE*source1=fopen("source1.txt","r");

FILE*source2=fopen("source2.txt","r");

FILE*destination=fopen("destination.txt","w");

if(source1==NULL||source2==NULL||destination==NULL){

printf("Erroropeningfile");

return1;

}

charch;

while((ch=fgetc(source1))!=EOF){

fputc(ch,destination);

}

while((ch=fgetc(source2))!=EOF){

fputc(ch,destination);

}

fclose(source1);

fclose(source2);

fclose(destination);

return0;

}

###七、位操作

位操作是C语言程序设计中常见的任务之一。下面我们通过实例来讲解位操作的应用。

#####位运算

位运算是对二进制数进行操作的运算。常见的位运算有按位与（&）、按位或（|）、按位异或（^）、按位取反（~）、左移（<<）、右移（>>）等。

#include<stdio.h>

intmain(){

inta=5;//0101inbinary

intb=9;//1001inbinary

intc;

c=a&b;//0001

printf("a&b=%d\n",c);

c=a|b;//1101

printf("a|b=%d\n",c);

c=a^b;//1100

printf("a^b=%d\n",c);

c=~a;//1010

printf("~a=%d\n",c);

c=a<<1;//1010

printf("a<<1=%d\n",c);

c=a>>1;//0010

printf("a>>1=%d\n",c);

return0;

}

#####位掩码

位掩码是一种通过位运算来选择或修改特定位的技术。位掩码通常用于设置或清除位。

#include<stdio.h>

intmain(){

inta=5;//0101inbinary

intmask=1<<2;//0100inbinary

a|=mask;//0111

printf("a|=mask=%d\n",a);

a&=~mask;//0011

printf("a&=~mask=%d\n",a);

return0;

}

#####位翻转

位翻转是将二进制数的每一位取反。

#include<stdio.h>

intmain(){

inta=5;//0101inbinary

a=~a;//1010

printf("~a=%d\n",a);

return0;

}

###八、内存管理

内存管理是C语言程序设计中的重要部分。下面我们通过实例来讲解内存管理的应用。

#####动态内存分配

动态内存分配是通过`malloc`、`calloc`、`realloc`等函数来分配和释放内存。

#include<stdio.h>

#include<stdlib.h>

intmain(){

int*arr;

intn=10;

arr=(int*)malloc(n*sizeof(int));

if(arr==NULL){

printf("Memoryallocationfailed");

return1;

}

for(inti=0;i<n;i++){

arr[i]=i;

}

for(inti=0;i<n;i++){

printf("%d",arr[i]);

}

printf("\n");

free(arr);

return0;

}

#####内存对齐

内存对齐是为了提高内存访问效率而对内存进行对齐的技术。C语言中可以通过`_Alignof`关键字来获取对齐要求。

#include<stdio.h>

intmain(){

inta;

printf("Alignmentofint:%zubytes\n",_Alignof(int));

doubleb;

printf("Alignmentofdouble:%zubytes\n",_Alignof(double));

struct{

charc;

inti;

}s;

printf("Alignmentofstruct:%zubytes\n",_Alignof(s));

return0;

}

#####内存拷贝

内存拷贝是通过`memcpy`函数来拷贝内存内容。

#include<stdio.h>

#include<string.h>

intmain(){

charsrc[]="Hello,World!";

chardest[20];

memcpy(dest,src,sizeof(src));

printf("Copiedstring:%s\n",dest);

return0;

}

#####内存填充

内存填充是通过`memset`函数来填充内存内容。

#include<stdio.h>

#include<string.h>

intmain(){

chararr[20];

memset(arr,'A',sizeof(arr));

printf("Filledarray:%s\n",arr);

return0;

}

###九、多线程编程

多线程编程是C语言程序设计中的重要部分。下面我们通过实例来讲解多线程编程的应用。

#####创建线程

创建线程是通过`pthread_create`函数来创建线程。

#include<stdio.h>

#include<pthread.h>

void*threadFunction(void*arg){

printf("Hellofromthread\n");

returnNULL;

}

intmain(){

pthread_tthread;

pthread_create(&thread,NULL,threadFunction,NULL);

pthread_join(thread,NULL);

return0;

}

#####线程同步

线程同步是通过互斥锁（mutex）来同步线程。

#include<stdio.h>

#include<pthread.h>

pthread_mutex_tlock=PTHREAD_MUTEX_INITIALIZER;

void*threadFunction(void*arg){

pthread_mutex_lock(&lock);

printf("Threadisincriticalsection\n");

pthread_mutex_unlock(&lock);

returnNULL;

}

intmain(){

pthread_tthread1,thread2;

pthread_create(&thread1,NULL,threadFunction,NULL);

pthread_create(&thread2,NULL,threadFunction,NULL);

pthread_join(thread1,NULL);

pthread_join(thread2,NULL);

pthread_mutex_destroy(&lock);

return0;

}

#####线程通信

线程通信是通过共享内存来通信线程。

#include<stdio.h>

#include<pthread.h>

pthread_mutex_tlock=PTHREAD_MUTEX_INITIALIZER;

intsharedVariable=0;

void*threadFunction(void*arg){

pthread_mutex_lock(&lock);

sharedVariable++;

printf("Threadincrementedsharedvariableto%d\n",sharedVariable);

pthread_mutex_unlock(&lock);

returnNULL;

}

intmain(){

pthread_tthread1,thread2;

pthread_create(&thread1,NULL,threadFunction,NULL);

pthread_create(&thread2,NULL,threadFunction,NULL);

pthread_join(thread1,NULL);

pthread_join(thread2,NULL);

pthread_mutex_destroy(&lock);

return0;

}

###十、网络编程

网络编程是C语言程序设计中的重要部分。下面我们通过实例来讲解网络编程的应用。

#####TCP客户端

TCP客户端是通过`socket`、`connect`等函数来创建和连接TCP客户端。

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

#include<unistd.h>

#include<sys/socket.h>

#include<netinet/in.h>

intmain(){

intsockfd,portno,n;

structsockaddr_inserv_addr;

charbuffer[256];

sockfd=socket(AF_INET,SOCK_STREAM,0);

if(sockfd<0){

perror("ERRORopeningsocket");

exit(1);

}

serv_addr.sin_family=AF_INET;

serv_addr.sin_addr.s_addr=INADDR_ANY;

serv_addr.sin_port=htons(8080);

if(connect(sockfd,(structsockaddr*)&serv_addr,sizeof(serv_addr))<0){

perror("ERRORconnecting");

exit(1);

}

printf("Connectedtoserver\n");

strcpy(buffer,"Hello,Server!");

n=write(sockfd,buffer,strlen(buffer));

if(n<0){

perror("ERRORwritingtosocket");

exit(1);

}

bzero(buffer,256);

n=read(sockfd,buffer,255);

if(n<0){

perror("ERRORreadingfromsocket");

exit(1);

}

printf("Serverreply:%s\n",buffer);

close(sockfd);

return0;

}

#####TCP服务器

TCP服务器是通过`socket`、`bind`、`listen`、`accept`等函数来创建和监听TCP服务器。

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

#include<unistd.h>

#include<sys/socket.h>

#include<netinet/in.h>

intmain(){

intsockfd,newsockfd,portno,clilen;

charbuffer[256];

structsockaddr_inserv_addr,cli_addr;

intn;

sockfd=socket(AF_INET,SOCK_STREAM,0);

if(sockfd<0){

perror("ERRORopeningsocket");

exit(1);

}

bzero((char*)&serv_addr,sizeof(serv_addr));

portno=8080;

serv_addr.sin_family=AF_INET;

serv_addr.sin_addr.s_addr=INADDR_ANY;

serv_addr.sin_port=htons(portno);

if(bind(sockfd,(structsockaddr*)&serv_addr,sizeof(serv_addr))<0){

perror("ERRORonbinding");

exit(1);

}

listen(sockfd,5);

clilen=sizeof(cli_addr);

newsockfd=accept(sockfd,(structsockaddr*)&cli_addr,&clilen);

if(newsockfd<0){

perror("ERRORonaccept");

exit(1);

}

bzero(buffer,256);

n=read(newsockfd,buffer,255);

if(n<0){

perror("ERRORreadingfromsocket");

exit(1);

}

printf("Clientmessage:%s\n",buffer);

write(newsockfd,"Hello,Client!",17);

close(newsockfd);

close(sockfd);

return0;

}

#####UDP客户端

UDP客户端是通过`socket`、`sendto`、`recvfrom`等函数来创建和发送UDP客户端。

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

#include<unistd.h>

#include<sys/socket.h>

#include<netinet/in.h>

intmain(){

intsockfd;

structsockaddr_inserv_addr;

charbuffer[256];

sockfd=socket(AF_INET,SOCK_DGRAM,0);

if(sockfd<0){

perror("ERRORopeningsocket");

exit(1);

}

bzero((char*)&serv_addr,sizeof(serv_addr));

serv_addr.sin_family=AF_INET;

serv_addr.sin_addr.s_addr=INADDR_ANY;

serv_addr.sin_port=htons(8080);

strcpy(buffer,"Hello,Server!");

sendto(sockfd,buffer,strlen(buffer),0,(structsockaddr*)&serv_addr,sizeof(serv_addr));

bzero(buffer,256);

intn=recvfrom(sockfd,buffer,255,0,(structsockaddr*)&serv_addr,&serv_addr.sin_len);

if(n<0){

perror("ERRORreadingfromsocket");

exit(1);

}

printf("Serverreply:%s\n",buffer);

close(sockfd);

return0;

}

#####UDP服务器

UDP服务器是通过`socket`、`bind`、`sendto`、`recvfrom`等函数来创建和监听UDP服务器。

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

#include<unistd.h>

#include<sys/socket.h>

#include<netinet/in.h>

intmain(){

intsockfd;

structsockaddr_inserv_addr,cli_addr;

charbuffer[256];

sockfd=socket(AF_INET,SOCK_DGRAM,0);

if(sockfd<0){

perror("ERRORopeningsocket");

exit(1);

}

bzero((char*)&serv_addr,sizeof(serv_addr));

serv_addr.sin_family=AF_INET;

serv_addr.sin_addr.s_addr=INADDR_ANY;

serv_addr.sin_port=htons(8080);

if(bind(sockfd,(structsockaddr*)&serv_addr,sizeof(serv_addr))<0){

perror("ERRORonbinding");

exit(1);

}

intn,len;

len=sizeof(cli_addr);

while(1){

bzero(buffer,256);

n=recvfrom(sockfd,buffer,255,0,(structsockaddr*)&cli_addr,&len);

if(n<0){

perror("ERRORreadingfromsocket");

exit(1);

}

printf("Clientmessage:%s\n",buffer);

strcpy(buffer,"Hello,Client!");

sendto(sockfd,buffer,strlen(buffer),0,(structsockaddr*)&cli_addr,len);

}

close(sockfd);

return0;

}

###十一、操作系统相关

操作系统相关是C语言程序设计中的重要部分。下面我们通过实例来讲解操作系统相关的应用。

#####进程创建

进程创建是通过`fork`函数来创建进程。

#include<stdio.h>

#include<unistd.h>

#include<sys/types.h>

intmain(){

pid_tpid=fork();

if(pid<0){

perror("ERRORforking");

exit(1);

}elseif(pid==0){

printf("Thisisthechildprocess\n");

execlp("/bin/ls","ls","-l",NULL);

perror("ERRORexecutingls");

exit(1);

}else{

printf("Thisistheparentprocess\n");

}

return0;

}

#####进程终止

进程终止是通过`exit`函数来终止进程。

#include<stdio.h>

#include<unistd.h>

#include<sys/types.h>

intmain(){

pid_tpid=fork();

if(pid<0){

perror("ERRORforking");

exit(1);

}elseif(pid==0){

printf("Thisisthechildprocess\n");

sleep(2);

exit(0);

}else{

printf("Thisistheparentprocess\n");

wait(NULL);

printf("Childprocessterminated\n");

}

return0;

}

#####进程等待

进程等待是通过`wait`函数来等待子进程终止。

#include<stdio.h>

#include<unistd.h>

#include<sys/types.h>

#include<sys/wait.h>

intmain(){

pid_tpid=fork();

if(pid<0){

perror("ERRORforking");

exit(1);

}elseif(pid==0){

printf("Thisisthechildprocess\n");

sleep(2);

exit(0);

}else{

printf("Thisistheparentprocess\n");

intstatus;

pid_twpid=wait(&status);

if(wpid==pid){

printf("Childprocessterminatedwithstatus%d\n",WIFEXITED(status));

}

}

return0;

}

#####文件权限

文件权限是通过`chmod`函数来设置文件权限。

#include<stdio.h>

#include<sys/stat.h>

intmain(){

if(chmod("example.txt",S_IRWXU|S_IRWXG|S_IRWXO)==-1){

perror("ERRORsettingfilepermissions");

exit(1);

}

printf("Filepermissionssetsuccessfully\n");

return0;

}

#####目录操作

目录操作是通过`opendir`、`readdir`、`closedir`等函数来操作目录。

#include<stdio.h>

#include<dirent.h>

intmain(){

DIR*dir=opendir(".");

if(dir==NULL){

perror("ERRORopeningdirectory");

exit(1);

}

structdirent*entry;

while((entry=readdir(dir))!=NULL){

printf("%s\n",entry->d_name

2026年C语言程序设计经典100例（算法与数据结构）

在深入探讨了基础算法与数据结构之后，我们进一步进入查找算法的领域。查找算法是计算机科学中的核心概念之一，广泛应用于数据处理、信息检索、决策支持等多个领域。高效的查找算法能够显著提升程序的运行效率，尤其是在处理大规模数据时。本部分将详细介绍线性查找和二分查找两种常见的查找算法，并通过实例展示它们在实际问题中的应用。

线性查找，也称为顺序查找，是最基础的查找算法之一。它通过遍历整个数据结构，逐一比较每个元素，直到找到目标值或遍历完所有元素为止。线性查找的优点是简单易实现，适用于无序数据结构。然而，它的缺点是效率较低，尤其是在数据量较大的情况下，查找时间会随着数据量的增加而线性增长。

下面我们通过一个实例来展示线性查找的应用。假设我们有一个未排序的整数数组，需要查找其中是否存在某个特定的数值。如果存在，返回该数值的索引；如果不存在，返回-1。

假设数组为`arr=[64,34,25,12,22,11,90]`，我们需要查找数值`25`。

首先，我们初始化一个变量`index`为-1，表示默认情况下数值不存在。然后，我们遍历数组中的每个元素，逐一比较它与目标数值`25`。如果找到匹配的元素，我们将`index`设置为该元素的索引，并终止遍历。如果遍历完所有元素仍未找到匹配项，则保持`index`为-1，表示数值不存在。

这种方法的实现非常简单，只需要一个循环即可完成。虽然线性查找在效率上有所不足，但它在某些特定场景下仍然非常有用，尤其是在数据量较小或数据结构无法进行优化排序的情况下。

接下来，我们来看另一个查找算法——二分查找。二分查找是一种高效的查找算法，它要求数据结构必须是有序的。二分查找的基本思想是将待查找区间分成两半，通过比较中间元素的值与目标值的大小关系，逐步缩小查找范围，直到找到目标值或确定该值不存在为止。

二分查找的优点是效率高，尤其是在处理有序数据结构时，其查找时间复杂度为O(logn)，远远优于线性查找的O(n)。然而，二分查找的缺点是要求数据结构必须是有序的，如果数据无序，需要先进行排序。

下面我们通过一个实例来展示二分查找的应用。假设我们有一个已排序的整数数组，需要查找其中是否存在某个特定的数值。如果存在，返回该数值的索引；如果不存在，返回-1。

假设数组为`arr=[11,12,22,25,34,64,90]`，我们需要查找数值`25`。

首先，我们定义三个变量：`low`表示查找区间的最低索引，`high`表示查找区间的最高索引，`mid`表示查找区间的中间索引。初始时，`low`为0，`high`为数组长度减1。

然后，我们在循环中计算`mid`的值，并比较`arr[mid]`与目标数值`25`的大小关系。如果`arr[mid]`等于`25`，则查找成功，返回`mid`的值。如果`arr[mid]`大于`25`，则说明目标数值在查找区间的左半部分，我们将`high`更新为`mid-1`。如果`arr[mid]`小于`25`，则说明目标数值在查找区间的右半部分，我们将`low`更新为`mid+1`。

重复上述步骤，直到`low`大于`high`，表示查找区间为空，目标数值不存在，返回-1。

二分查找的实现需要仔细处理边界条件，确保不会出现数组越界的问题。同时，二分查找的效率优势在数据量较大时尤为明显，因此在实际应用中广泛用于处理有序数据结构的查找问题。

除了上述两种查找算法，还有许多其他查找算法，如哈希查找、二叉搜索树查找等。哈希查找通过哈希函数将键值映射到数组中，实现快速查找。二叉搜索树查找通过构建二叉搜索树结构，实现高效的查找操作。这些查找算法在不同场景下有不同的应用，选择合适的查找算法能够显著提升程序的性能。

在实际编程中，选择查找算法时需要考虑数据结构的特点和查找需求。如果数据量较小或数据结构无法进行优化排序，线性查找是一个简单且可行的选择。如果数据量较大且数据结构已经排序，二分查找是一个高效的选择。如果需要更复杂的查找操作，如频繁插入和删除，可以考虑使用哈希表或二叉搜索树等数据结构。

查找算法是计算机科学中的重要组成部分，它在数据处理和信息检索中发挥着关键作用。通过学习线性查找和二分查找，我们能够掌握基本的查找思路，为后续学习更复杂的查找算法打下坚实的基础。在实际编程中，根据具体需求选择合适的查找算法，能够显著提升程序的效率和性能。

2026年C语言程序设计经典100例（算法与数据结构）

在前面几部分中，我们已经深入探讨了排序算法、查找算法、递归与动态规划、图算法、字符串处理、文件操作、位操作、内存管理、多线程编程以及网络编程等多个方面的经典实例。这些实例涵盖了C语言程序设计中的核心内容，旨在通过实践的方式帮助学习者更好地理解和掌握C语言编程技巧。在本文的结尾部分，我们将对前文内容进行总结，并对C语言程序设计的学习路径和未来发展趋势进行展望，希望能够为正在学习C语言程序设计的读者提供一些有益的参考和启发。

首先，我们来回顾一下前文中所涉及的主要内容。排序算法是算法领域中最为基础也是最为重要的部分之一。在C语言中，实现排序算法可以通过多种方式，如冒泡排序、选择排序、插入排序、快速排序、归并排序等。这些排序算法各有特点，适用于不同的场景。冒泡排序通过重复地遍历待排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来，从而实现排序。选择排序通过在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。插入排序通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。快速排序通过选择一个“基准”元素，将数组分为两个子数组，一个子数组的所有元素都不大于基准，另一个子数组的所有元素都不小于基准，然后递归地对这两个子数组进行快速排序。归并排序通过将数组分成两半，分别对它们进行排序，然后将两个有序的子数组合并成一个有序数组。这些排序算法在实际应用中有着广泛的应用，例如，冒泡排序简单易实现，适合小规模数据的排序；选择排序适用于小规模数据，且时间复杂度为O(n^2)；插入排序适合部分有序的数据，时间复杂度为O(n)；快速排序在平均情况下具有O(nlogn)的时间复杂度，是效率较高的排序算法之一；归并排序也是O(nlogn)的时间复杂度，且稳定，适合大规模数据的排序。在实际应用中，选择合适的排序算法能够显著提升程序的运行效率，因此，掌握各种排序算法的原理和实现方式对于C语言程序员来说至关重要。

查找算法是计算机科学中的核心概念之一，广泛应用于数据处理、信息检索、决策支持等多个领域。高效的查找算法能够显著提升程序的运行效率，尤其是在处理大规模数据时。本部分将详细介绍线性查找和二分查找两种常见的查找算法，并通过实例展示它们在实际问题中的应用。线性查找，也称为顺序查找，是最基础的查找算法之一。它通过遍历整个数据结构，逐一比较每个元素，直到找到目标值或遍历完所有元素为止。线性查找的优点是简单易实现，适用于无序数据结构。然而，它的缺点是效率较低，尤其是在数据量较大的情况下，查找时间会随着数据量的增加而线性增长。下面我们通过一个实例来展示线性查找的应用。假设我们有一个未排序的整数数组，需要查找其中是否存在某个特定的数值。如果存在，返回该数值的索引；如果不存在，返回-1。这种方法的实现非常简单，只需要一个循环即可完成。虽然线性查找在效率上有所不足，但它在某些特定场景下仍然非常有用，尤其是在数据量较小或数据结构无法进行优化排序的情况下。二分查找是一种高效的查找算法，它要求数据结构必须是有序的。二分查找的基本思想是将待查找区间分成两半，通过比较中间元素的值与目标值的大小关系，逐步缩小查找范围，直到找到目标值或确定该值不存在为止。二分查找的优点是效率高，尤其是在处理有序数据结构时，其查找时间复杂度为O(logn)，远远优于线性查找的O(n)。然而，二分查找的缺点是要求数据结构必须是有序的，如果数据无序，需要先进行排序。下面我们通过一个实例来展示二分查找的应用。假设我们有一个已排序的整数数组，需要查找其中是否存在某个特定的数值。如果存在，返回该数值的索引；如果不存在，返回-1。这种方法的实现需要仔细处理边界条件，确保不会出现数组越界的问题。同时，二分查找的效率优势在数据量较大时尤为明显，因此在实际应用中广泛用于处理有序数据结构的查找问题。除了上述两种查找算法，还有许多其他查找算法，如哈希查找、二叉搜索树查找等。哈希查找通过哈希函数将键值映射到数组中，实现快速查找。二叉搜索树查找通过构建二叉搜索树结构，实现高效的查找操作。这些查找算法在不同场景下有不同的应用，选择合适的查找算法能够显著提升程序的性能。在实际编程中，选择查找算法时需要考虑数据结构的特点和查找需求。如果数据量较小或数据结构无法进行优化排序，线性查找是一个简单且可行的选择。如果数据量较大且数据结构已经排序，二分查找是一个高效的选择。如果需要更复杂的查找操作，如频繁插入和删除，可以考虑使用哈希表或二叉搜索树等数据结构。

递归与动态规划是算法设计中的重要技巧，它们在解决复杂问题时展现出强大的能力。递归是一种在函数内部调用自身的编程技巧。递归算法通常用于解决可以分解为相似子问题的问题。递归的思想是将一个问题分解成若干个规模更小、结构相似的子问题，然后递归地求解子问题，最终得到原问题的解。递归算法的编写需要仔细考虑递归的终止条件和递归的递归式，确保递归能够正确地执行。在C语言中，递归算法的实现相对简单，但需要注意递归的深度和递归的效率。如果递归深度过大，可能会导致栈溢出的问题。因此，在实际应用中，需要合理地设计递归算法，避免递归深度过大。动态规划是一种通过将问题分解为更小的子问题并存储子问题的解来避免重复计算的方法。动态规划通常用于解决最优化问题，如背包问题、最长公共子序列问题等。动态规划的思想是将一个问题分解成若干个子问题，然后按照一定的顺序求解子问题，并将子问题的解存储起来，避免重复计算。动态规划算法的设计需要仔细考虑子问题的关系和子问题的求解顺序，确保子问题的解能够正确地存储和利用。在C语言中，动态规划算法的实现通常需要使用数组或动态规划表来存储子问题的解，以提高算法的效率。递归与动态规划是算法设计中的高级技巧，它们在解决复杂问题时能够发挥强大的能力，但需要开发者具备一定的数学基础和算法设计能力。通过学习和实践递归与动态规划，开发者能够更好地理解算法的递归式和子问题的关系，提升算法设计的水平。

图算法是算法设计中的重要部分，它能够解决许多实际问题，如最短路径、最小生成树、拓扑排序等。图算法通过将问题转化为图结构，利用图中的边和顶点关系，寻找最优解。在C语言中，图算法的实现通常需要使用邻接矩阵或邻接表来表示图结构，并利用深度优先搜索或广度优先搜索等图遍历算法来解决问题。图算法的设计需要考虑图的结构特点和解题思路，合理设计图的遍历顺序和优化策略，以提高算法的效率。在C语言中，图算法的实现相对复杂，需要开发者具备一定的图论知识和算法设计能力。通过学习和实践图算法，开发者能够更好地理解图的结构和遍历算法的原理，提升算法设计的水平。

字符串处理是C语言程序设计中常见的任务之一。字符串处理在文本编辑、数据解析、自然语言处理等领域有着广泛的应用。C语言提供了丰富的字符串处理函数，如`strcpy`、`strcat`、`strlen`、`strchr`等，开发者可以利用这些函数实现各种字符串处理任务。字符串处理算法的设计需要考虑字符串的特点和处理需求，合理设计字符串的比较、查找、替换等操作，以提高算法的效率。在C语言中，字符串处理算法的实现相对简单，但需要注意字符串的内存管理和边界条件，确保字符串处理算法的正确性和安全性。通过学习和实践字符串处理算法，开发者能够更好地理解字符串的结构和处理方式，提升编程的灵活性和效率。

文件操作是C语言程序设计中常见的任务之一。文件操作在数据存储、数据交换、数据备份等领域有着广泛的应用。C语言提供了丰富的文件操作函数，如`fopen`、`fclose`、`fread`、fwrite等，开发者可以利用这些函数实现各种文件操作任务。文件操作算法的设计需要考虑文件的结构特点和操作需求，合理设计文件的打开、读取、写入等操作，以确保文件操作的正确性和安全性。在C语言中，文件操作算法的实现相对简单，但需要注意文件的路径、权限和缓冲区管理，确保文件操作的效率和安全性。通过学习和实践文件操作算法，开发者能够更好地理解文件的结构和处理方式，提升编程的灵活性和效率。

位操作是C语言程序设计中常见的任务之一。位操作通过直接操作二进制位，实现对数据的精细控制。位操作在数据加密、数据压缩、数据传输等领域有着广泛的应用。C语言提供了丰富的位操作符，如`&`、`|`、`^`、`~`、`<<`、`>>`等，开发者可以利用这些位操作符实现各种位操作任务。位操作算法的设计需要考虑数据的二进制表示和位操作的需求，合理设计位的比较、查找、修改等操作，以提高算法的效率。在C语言中，位操作算法的实现相对简单，但需要注意位的边界条件和位操作的正确性，确保位操作算法的正确性和安全性。通过学习和实践位操作算法，开发者能够更好地理解二进制数据的表示和处理方式，提升编程的灵活性和效率。

内存管理是C语言程序设计中的重要部分。内存管理通过动态分配和释放内存，实现对内存的有效利用。C语言提供了丰富的内存管理函数，如`malloc`、`calloc`、`realloc`、`free`等，开发者可以利用这些内存管理函数实现各种内存管理任务。内存管理算法的设计需要考虑内存的分配策略和释放策略，合理设计内存的分配和释放顺序，以确保内存管理的效率和安全性。在C语言中，内存管理算法的实现相对复杂，需要开发者具备一定的内存管理知识和操作系统知识。通过学习和实践内存管理算法，开发者能够更好地理解内存的分配和释放机制，提升编程的灵活性和效率。

多线程编程是C语言程序设计中的重要部分。多线程编程通过同时执行多个线程，提升程序的并发性和效率。C语言提供了丰富的多线程编程函数，如`pthread_create`、`pthread_join`、`pthread_mutex_t`等，开发者可以利用这些多线程编程函数实现各种多线程编程任务。多线程编程算法的设计需要考虑线程的创建、线程的同步和线程的通信，合理设计线程的执行顺序和线程的同步策略，以确保多线程编程的正确性和安全性。在C语言中，多线程编程算法的实现相对复杂，需要开发者具备一定的操作系统知识和多线程编程知识。通过学习和实践多线程编程算法，开发者能够更好地理解线程的执行机制和线程同步策略，提升编程的灵活性和效率。

网络编程是C语言程序设计中的重要部分。网络编程通过在网络中传输数据，实现程序的远程通信。C语言提供了丰富的网络编程函数，如`socket`、`connect`、`send`、`recv`等，开发者可以利用这些网络编程函数实现各种网络编程任务。网络编程算法的设计需要考虑网络协议和网络传输的需求，合理设计网络连接的建立、数据的发送和接收等操作，以确保网络编程的正确性和安全性。在C语言中，网络编程算法的实现相对复杂，需要开发者具备一定的网络编程知识和操作系统知识。通过学习和实践网络编程算法，开发者能够更好地理解网络通信的机制和网络编程的原理，提升编程的灵活性和效率。

操作系统相关是C语言程序设计中的重要部分。操作系统相关通过调用操作系统的功能，实现程序的系统级操作。C语言提供了丰富的操作系统相关函数，如`fork`、`exit`、`wait`、`chmod`等，开发者可以利用这些操作系统相关函数实现各种操作系统相关任务。操作系统相关算法的设计需要考虑操作系统的特性和操作系统的调用机制，合理设计操作系统的调用顺序和操作系统的资源管理策略，以确保操作系统相关的正确性和安全性。在C语言中，操作系统相关算法的实现相对复杂，需要开发者具备一定的操作系统知识和编程知识。通过学习和实践操作系统相关算法，开发者能够更好地理解操作系统的功能和调用机制，提升编程的灵活性和效率。

综上所述，C语言程序设计是一个充满挑战和机遇的领域。通过学习和实践C语言程序设计，开发者能够掌握各种算法与数据结构的原理和实现方式，提升编程的灵活性和效率。在未来的发展中，随着计算机技术的不断进步，C语言程序设计的重要性将更加凸显。开发者需要不断学习和实践，提升自己的编程能力，才能在激烈的竞争中脱颖而出。希望本文能够为正在学习C语言程序设计的读者提供一些有益的参考和启发，帮助他们在C语言程序设计的道路上走得更远。

在C语言程序设计中，算法与数据结构是两个密不可分的部分。算法是解决问题的步骤和方法，而数据结构是数据的组织和存储方式。掌握算法与数据结构，不仅能够帮助开发者提