c语言经典小函数Word文档格式.docx
《c语言经典小函数Word文档格式.docx》由会员分享，可在线阅读，更多相关《c语言经典小函数Word文档格式.docx（14页珍藏版）》请在冰豆网上搜索。
（注意最终返回的为最后一个节点的地址）
（2）循环链表的倒序输出
next,*q=head,*head0=head;
while（p!
=head0）
p->
2链表的增序插入：
（1）单链表
答案1：
info*insert（info*s,info*head）
info*p=head,*q=head;
head）
head=s;
head->
next=NULL;
returns;
elseif（strcmp（s->
num,head->
num）<
0）
{s->
returnhead;
else
p=p->
{
if（strcmp（s->
num,p->
q->
next=s;
s->
next=p;
returnhead;
}q=p;
}
q->
答案2：
Node*Insert（Node*head,Node*s）
Node*p=head,*q=NULL;
//p用来遍历链表，q记住p的前续节点
=NULL&
&
strcmp（p->
num,s->
0）{//寻找s应该插入的位置
q=p;
p=p->
if（q==NULL）{//插在头结点前，也可以处理空链表的情况
s->
next=p;
returns;
//插入节点
next=s;
（2）循环链表
0）//作为头结点
{
info*search=head->
next,*sea=head,*head0=head;
while（search!
=head0）//寻找最后一个节点
sea=search;
search=search->
sea->
=head）
info*search=head->
while（search!
{
}
if（p==NULL）returns;
//空链表
if（strcmp（p->
num）>
=0）{//插在头节点前
while（q->
next!
=head）{//q指向尾节点
q=q->
//插入节点
q=p;
p=p->
=head&
3链表复制
单链表：
info*copy（info*head）
info*s=（info*）malloc（sizeof（info））,*head2=s,*q=s,*p=head;
s=（info*）malloc（sizeof（info））;
q=s;
strcpy（q->
num）;
strcpy（q->
name,p->
name）;
head2=head2->
returnhead2;
循环链表：
Node*Copy（Node*head）
Node*p=head,*head2=NULL,*q=NULL,*r=NULL;
//p用来遍历原链表，head2是新链表头指针，q用来生成新链表，r记住q的前续节点
if（p==NULL）returnNULL;
//复制头节点
q=（Node*）malloc（sizeof（Node））;
name,p->
num,p->
head2=q;
next=head2;
r=q;
=head）{
//建立新节点并拷贝
q=（Node*）malloc（sizeof（Node））;
r->
next=q;
r=q;
4结点递归计数
（1）单链表
intRcounter（node*head,intm）
node*p=head;
p）
return0;
m=1+Rcounter（p->
next,m）;
returnm;
（2）循环链表
intRcounter（node*head,node*head0）
intm=1;
if（head==NULL）
if（p->
next==head0）
return1;
next,head0）;
6顺序存储结构的排序
#include<
stdio.h>
#include<
string.h>
stdlib.h>
voiddirectselect（inta[],intn）;
voidbubbleselect（inta[],intn）;
intmain（）
inta[21]={0,10,21,52,12,40,2,58,95,21,753,259,15,147,210,222,102,135,201,109,65};
intb[21],d[21];
for（inti=0;
i<
21;
i++）
b[i]=d[i]=a[i];
directselect（b,20）;
bubbleselect（d,20）;
for（i=1;
printf（"
%4d"
a[i]）;
printf（"
\n"
）;
b[i]）;
d[i]）;
return0;
voiddirectselect（inta[],intn）//插入排序
for（inti=2;
n+1;
a[0]=a[i];
for（intj=i-1;
j>
0;
j--）
if（a[0]>
a[j]）
break;
a[j+1]=a[j];
a[j+1]=a[0];
voidbubbleselect（inta[],intn）//冒泡排序
intc;
for（inti=1;
for（intj=n;
i;
if（a[j]<
a[j-1]）
c=a[j];
a[j]=a[j-1];
a[j-1]=c;
voidbubsort（structnode*p,intn）//有序时可以返回原有序结构
structnodes;
for（inti=0;
n-1;
intflag=0;
for（intj=n-1;
j--）if（*（p+j）.key<
*（p+j-1）.key）
s=*（p+j）;
*（p+j）=*（p+j-1）;
*（p+j-1）=s;
flag=1;
if（flag==0）retrun;
voidselectsort（inta[],intn）//选择排序，注意a[i]即为最小值的情况
intmin,i,j,jmin;
for（i=0;
min=a[i];
intflag=0;
for（j=i+1;
j<
n;
j++）
if（min>
flag=1;
min=a[j];
jmin=j;
if（flag==1）
a[jmin]=a[i];
a[i]=min;
二维数组排序：
voidsort（inta[][5],intn）
intmin=a[0][0];
for（intj=0;
for（intk=n-1;
k>
=0;
k--）
for（intv=4;
v>
v--）
if（a[k][v]<
a[k][v-1]）
{
intt=a[k][v];
a[k][v]=a[k][v-1];
a[k][v-1]=t;
}
7：
链表保存至文件然后恢复链表：
boolSave（Node*head,char*filename）
FILE*fp;
Node*p=head;
if（（fp=fopen（filename,"
w"
））==NULL）returnfalse;
//filename在主函数中输入
=NULL）{
fwrite（p,sizeof（Node）,1,fp）;
fclose（fp）;
returntrue;
Node*Load（char*filename）
Node*head=NULL,*s=NULL;
r"
while（!
feof（fp））{
s=（Node*）malloc（sizeof（Node））;
if（fread（s,sizeof（Node）,1,fp）>
0）{
next=NULL;
head=Insert（head,s）;
//Insert函数见上面的链表排序函数
elsefree（s）;
8：
寻找一个以空格为间隔的字符串中中最长的单词：
#include<
charstr（chara[],charc[]）
inti,j,s,n;
intcount=0;
//这里!
这里!
charb[20][20]={NULL};
for（i=0,j=0,n=0;
a[i]!
='
\0'
;
if（a[i]!
'
）
{
b[j][n]=a[i];
n++;
s=1;
if（a[i]=='
s==1）
s=0;
j++;
n=0;
count=j;
//这里!
for（j=0;
count;
j++）//这里!
if（j==0）strcpy（c,b[j]）;
elseif（strlen（b[j]）>
strlen（c））//这里!
strcpy（c,b[j]）;
return1;
voidmain（）
staticchara[20],c[20];
puts（"
enterstring!
"
gets（a）;
str（a,c）;
puts（c）;
有关几个人中只有一人正确的问题可以用！
（即非）得反一性和零实现
如：
1==!
（count-1）+!
（count-2）+!
!
（count-3）
升级会员 