c语言fist函数 c语言上fib函数

求狼羊白菜过河的C语言编程题详解。希望不要用数组解决。

按照你的要求，不使用数组。

创新互联服务紧随时代发展步伐，进行技术革新和技术进步，经过10多年的发展和积累，已经汇集了一批资深网站策划师、设计师、专业的网站实施团队以及高素质售后服务人员，并且完全形成了一套成熟的业务流程，能够完全依照客户要求对网站进行做网站、网站设计、建设、维护、更新和改版，实现客户网站对外宣传展示的首要目的，并为客户企业品牌互联网化提供全面的解决方案。

我的思路，起点货物狼、羊、白菜，人一直在开船，通过递归函数，每次靠岸尝试装卸货方案，直到找满足条件的方案。将可行方案存放在结构链表中形成操作流水打印。

人狼羊菜存储方式模拟4位2进制，用1111表示，每位表示一个单位，1存在，0不存在。

#includestdio.h

#includemalloc.h

typedef enum{false,true}bool;

typedef struct opRecord//用结构链表记录操作流水

{

int p1_take;//p1载货值

int p1_goAd;//p1卸货值

int p2_take;//p2载货值

int p2_goAd;//p2卸货值

int cen;//递归层号

struct opRecord *next;

}OPR;

OPR *oprHead;

OPR *oprTail;

char *getName(int b);//获取对应名称

int beEaten(int p1,int p2);//检查是否发生被吃事件，发生返回1，未发生返回0

int toShip(int *p1,int *p2,int *ship,bool f);//递归函数：上船人及任意一组合，返回状态，1：方案可行；0：方案不可行

int getFist(int pn);//获取物品组合中第一个

void addLog(int p1_take,int p1_goAd,int p2_take,int p2_goAd,int cen);//将有效操作添加进日志,cen相同，将视为修改覆盖

void printfLog();//打印操作流水

OPR *findLogBycen(int cen);//通过cen查找流水。 有返回节点指针。无返回NULL

int count=1;

int flag=0;//标识变量=1成立；  =0不成立

int cen=0;

int main()

{

int p1=111,ship=1000,p2=0000;//p1,p2分别表示两岸，4位数每一位分别表示人狼羊菜，位数值1表示存在，0表示不存在

oprHead=(OPR *)malloc(sizeof(OPR));

oprHead-next=NULL;

oprTail=NULL;

printf("河岸有人、狼、羊、白菜要过河,船每次载人及一物，为避免人上船后狼吃羊或羊吃菜\n开始生成方案:\n\n");

if(toShip(p1,p2,ship,0))

{

printf("\n开始生成结果报告：\n");

printfLog();

}

else

printf("无可行方案！！\n");

return 0;

}

void addLog(int p1_take,int p1_goAd,int p2_take,int p2_goAd,int cen)//将有效操作添加进日志,cen相同，将视为修改覆盖,

{

OPR *oprNew=findLogBycen(cen);

if(oprNew==NULL)//通过查找。确认无记录，新增记录

{

oprNew=(OPR *)malloc(sizeof(OPR));

oprNew-p1_take=p1_take;

oprNew-p1_goAd=p1_goAd;

oprNew-p2_take=p2_take;

oprNew-p2_goAd=p2_goAd;

oprNew-cen=cen;

oprNew-next=NULL;

if(oprHead-next==NULL)

oprHead-next=oprNew;

else

oprTail-next=oprNew;

oprTail=oprNew;

}

else//查找发现已有记录，修改

{

oprNew-p1_take=p1_take;

oprNew-p1_goAd=p1_goAd;

oprNew-p2_take=p2_take;

oprNew-p2_goAd=p2_goAd;

}

}

OPR *findLogBycen(int cen)//通过cen查找流水。 有返回节点指针。无返回NULL

{

OPR *headSave=oprHead;

while(headSave-next!=NULL)

{

if(headSave-next-cen==cen)

return headSave-next;

headSave=headSave-next;

}

return NULL;

}

void printfLog()//打印操作流水

{

OPR *headSave=oprHead;

int p1_take,p1_goAd,p2_take,p2_goAd,cen,p1TOp2,p2TOp1;

while(headSave-next!=NULL)

{

p1_take=headSave-next-p1_take;

p1_goAd=headSave-next-p1_goAd;

p2_take=headSave-next-p2_take;

p2_goAd=headSave-next-p2_goAd;

cen=headSave-next-cen;

if(p1_take0 || p1_goAd0)

p1TOp2=1;

else

p1TOp2=0;

if(p2_take0 || p2_goAd0)

p2TOp1=1;

else

p2TOp1=0;

printf("操作流水%2d:",cen);

printf("%s%s",p1TOp20?"从p1":"",p2TOp10?"从p2":"");

printf("%s%s",p1_goAd0?getName(p1_goAd):"",p1_goAd0?"下船":"");

printf("%s%s",p1_take0?getName(p1_take):"",p1_take0?"上船":"");

printf("%s%s",p2_goAd0?getName(p2_goAd):"",p2_goAd0?"下船":"");

printf("%s%s",p2_take0?getName(p2_take):"",p2_take0?"上船":"");

if(headSave-next-next!=NULL)

printf("。之后行驶方向：%s%s\n",p1TOp20?"p1-p2":"",p2TOp10?"p1-p2":"");

else

printf("\n");

headSave=headSave-next;

}

}

char *getName(int b)//获取对应名称

{

if(b==1000)

return "人";

else if(b==100)

return "狼";

else if(b==10)

return "羊";

else if(b==1)

return "菜";

return "";

}

int toShip(int *p1,int *p2,int *ship,bool f)//递归函数：上船人及任意一组合；lastTake:上一次承载物体，首次调用传0；f=0：p1-p2方向;1:反向。返回状态，1：方案可行；0：方案不可行;

{

int take=-1,goAd,gdflag=1,cenSave;//take:上船物体。  goAd：下船物体。gdflag:标识变量，p2判断能否直接下船,1能0不能

cenSave=++cen;

while(1)

{

goAd=*ship-1000;

if(f==0)//准备p1往p2

{

if(take==-1)

take=getFist(*p1);

*p1-=take;

*p1+=goAd;

gdflag=1;//标识置1，等到p2首先尝试直接卸货

}

else//准备p2往p1

{

if(take==-1  gdflag==0)

{

take=getFist(*p2);

printf("开始尝试替换货物：\n");

}

if(gdflag==1)//如果p2可以直接卸货

*p2+=goAd;

else//如果不能直接卸货，尝试带走一个同时卸货

{

*p2-=take;

*p2+=goAd;

}

}

printf("递归层级%d：假设%s从%s上船。%s下船，%s方向行驶。\n",cenSave,take0?getName(take):"无货物",f==0?"p1":"p2",goAd!=0?getName(goAd):"无货物",f==0?"p1往p2":"p2往p1");

if(beEaten(*p1,*p2))//如果发生被吃，假设失败，还原数据，选择下一假设

{

if(f==0)

{

*p1+=take;

*p1-=goAd;

}

else

{

if(gdflag==1)//p2点确定不能直接卸货，还原数据，标识置0

{

printf("----不能直接卸货，货物%s回到船上。",getName(goAd));

*p2-=goAd;

gdflag=0;

continue;

}

else//不能直接卸货并尝试替换货物失败，选择下一个货物替换

{

*p2+=take;

*p2-=goAd;

}

}

if(take==1)

{

printf("本次靠岸无可行的装卸方案，返回层级%d！\n",cenSave-1);

return 0;

}

take=take/10;//尝试选择下一个货物

continue;

}

else

{

if(f==1  gdflag==1)//p2直接卸货假设成立船清空

*ship=1000;

else

*ship=1000+take;//换货假设成立货物装船

if(*p1==0)//如果已经完全转移

{

printf("所有货物过河成功！！\n");

return 1;

}

if(f==0)

addLog(take,goAd,0,0,cenSave);//生成流水日志

else

addLog(0,0,take,goAd,cenSave);//生成流水日志

if(toShip(p1,p2,ship,f==0?1:0))

{

return 1;

}

else//由于下级失败，本回合重新选择

{

gdflag=0;

continue;

}

}

}

}

int getFist(int pn)//获取物品组合中第一个

{

int i,count=0;

while(1)//上船物体从岸上第一个物体开始选择

{

if(pn=1)

break;

pn=pn/10;

count++;

}

for(i=0;icount;i++)

pn=pn*10;

return pn;

}

int beEaten(int p1,int p2)//检查是否发生被吃事件，发生返回1，未发生返回0

{

int ren=0;

if(p1==110  ++ren==1)

printf("----河岸p1狼把羊吃了！重新选择\n");

if(p2==110  ++ren==1)

printf("----河岸p2狼把羊吃了！重新选择\n");

if(p1==11  ++ren==1)

printf("----河岸p1羊把菜吃了！重新选择\n");

if(p2==11  ++ren==1)

printf("----河岸p2羊把菜吃了！重新选择\n");

return ren;

}

c语言编程二分查找

好久不写了

写一个程序，建立N元整型数组，然后输入查找的整数x，查找x是否包含在数组中，查找用函数实现，若查找成功，返回x在数组中的第一次出现的下标，查找失败，返回－1

源程序：

#include"stdio.h"

#define N 10

int locate(int a[N],int x)

{int h,r,m;

h=0;r=N-1;m=(h+r)/2;

while(h=rx!=a[m])

if(xa[m]) {r=m-1;m=(h+r)/2;}

else {h=m+1;m=(h+r)/2;}

if(hr) return -1; /*查找失败，返回－1*/

return m; /*查找成功，返回有效下标m */

}

void upinsert(int a[],int i) /*插入排序 （升序）*/

{int x,j;

x=a[i];j=i-1;

while(j=0a[j]x) {a[j+1]=a[j];j--;}

a[j+1]=x;

}

void main()

{int a[N],x,k,n;

printf("input %d integers:\n",N);

for(k=0;kN;k++) {scanf("%d",a+k);upinsert(a,k);}

printf("input x=") ;scanf("%d",x);

n=locate(a,x);

for(k=0;kN;k++) printf("%4d",a[k]);

printf("\n fist position=%d\n",n);

}

没有错误，我试过了

C语言 指针问题

这个程序没错，我在VC上可以运行。这个程序实际上就是将一个字符串中指定位置上的字符删除掉。下面解释两个语句的意思。

假如输入：

abcdefg

4

输出：

abcefg

p+=position-1; 相当于 p = p + (position-1); 也就是将指针 p 从字符串首部移动到 (position - 1）个位置。一开始 p 指向 'a'，现在 p 指向 'd'。

while((*p++=*(p+1))!='\0'); 相当于

while(p!='\0'){ *p=*(p+1); p++;} 也就是不断地将后一个元素取代前一个元素，'d'被'e'取代，'e'被‘f'取代，如此直到字符串末尾。

C语言如何给指针分配内存？

1, 找到VS的cl.exe所在目录,把这目录复制下来:

我的VS2008的CL.EXE目录是在E:\Program Files\Microsoft Visual Studio 9.0\VC\bin,

VS2010可以类似的找到..

在'我的电脑'上点右键,

选右键菜单'属性'-'高级'-'环境变量',

在弹出的环境变量设置框里找"PATH"这个变量, (在用户变量或系统变量里都可以)

然后在"PATH"的值后面,用分号分隔,

把将才找到的路径串复制进去,选确定.

2, 重新运行CMD开启新的命令窗.

3, 输入cl回车检查PATH路径是否生效.

//以上步聚是设置环境变量,只需设一次以后就好用了.以后每次要命令行下编译C++程序,就从下面第4步开始.

4, 输入vcvars32 ,运行cl.exe同一路径下的vcvars32.bat,设置其它环境变量.

5, 写一个helloworld程序,保存成hello.cpp, cl hello.cpp回车试试编译正常不. 如果成功,则生成hello.exe文件.

//-----------------------------------------------------------

C/C++ 编译器选项

-优化-

/O1 最小化空间 /Op[-] 改善浮点数一致性

/O2 最大化速度 /Os 优选代码空间

/Oa 假设没有别名 /Ot 优选代码速度

/Obn 内联展开(默认 n=0) /Ow 假设交叉函数别名

/Od 禁用优化(默认值) /Ox 最大化选项。(/Ogityb2 /Gs)

/Og 启用全局优化 /Oy[-] 启用框架指针省略

/Oi 启用内部函数

-代码生成-

/G3 为 80386 进行优化 /Gh 启用 _penter 函数调用

/G4 为 80486 进行优化 /GH 启用 _pexit 函数调用

/G5 为 Pentium 进行优化 /GR[-] 启用 C++ RTTI

/G6 对 PPro、P-II、P-III 进行优化 /GX[-] 启用 C++ EH (与 /EHsc 相同)

/G7 对 Pentium 4 或 Athlon 进行优化 /EHs 启用 C++ EH (没有 SEH 异常)

/GB 为混合模型进行优化(默认) /EHa 启用 C++ EH(w/ SEH 异常)

/Gd __cdecl 调用约定 /EHc extern "C" 默认为 nothrow

/Gr __fastcall 调用约定 /GT 生成纤维安全 TLS 访问

/Gz __stdcall 调用约定 /Gm[-] 启用最小重新生成

/GA 为 Windows 应用程序进行优化 /GL[-] 启用链接时代码生成

/Gf 启用字符串池 /QIfdiv[-] 启用 Pentium FDIV 修复

/GF 启用只读字符串池 /QI0f[-] 启用 Pentium 0x0f 修复

/Gy 分隔链接器函数 /QIfist[-] 使用 FIST 而不是 ftol()

/GZ 启用堆栈检查(/RTCs) /RTC1 启用快速检查(/RTCsu)

/Ge 对所有函数强制堆栈检查 /RTCc 转换为较小的类型检查

/Gs[num] 控制堆栈检查调用 /RTCs 堆栈帧运行时检查

/GS 启用安全检查 /RTCu 未初始化的本地用法检查

/clr[:noAssembly] 为公共语言运行库编译

noAssembly - 不产生程序集

/arch:SSE|SSE2 CPU 结构的最低要求，以下内容之一:

SSE - 启用支持 SSE 的 CPU 可用的指令

SSE2 - 启用支持 SSE2 的 CPU 可用的指令

-输出文件-

/Fa[file] 命名程序集列表文件 /Fofile 命名对象文件

/FA[sc] 配置程序集列表 /Fpfile 命名预编译头文件

/Fd[file] 命名 .PDB 文件 /Fr[file] 命名源浏览器文件

/Fefile 命名可执行文件 /FR[file] 命名扩展 .SBR 文件

/Fm[file] 命名映射文件

-预处理器-

/AIdir 添加到程序集搜索路径 /Fx 将插入的代码合并到文件

/FUfile 强制使用程序集/模块 /FIfile 命名强制包含文件

/C 不抽出注释 /Uname 移除预定义宏

/Dnametext 定义宏 /u 移除所有预定义宏

/E 预处理到 stdout /Idir 添加到包含搜索路径

/EP 预处理到 stdout，没有 #line /X 忽略“标准位置”

/P 预处理到文件

-语言-

/Zi 启用调试信息 /Ze 启用扩展(默认)

/ZI 启用“编辑并继续”调试信息 /Zl 省略 .OBJ 中的默认库名

/Z7 启用旧式调试信息 /Zg 生成函数原型

/Zd 仅有行号调试信息 /Zs 只进行语法检查

/Zp[n] 在 n 字节边界上包装结构 /vd 禁用/启用 vtordisp

/Za 禁用扩展(暗指 /Op) /vmx 指向成员的指针类型

/Zc:arg1[,arg2] C++ 语言一致性，这里的参数可以是:

forScope - 对范围规则强制使用标准 C++

wchar_t - wchar_t 是本机类型，不是 typedef

- 杂项 -

@file 选项响应文件 /won 发出一次警告 n

/?, /help 打印此帮助消息 /wln 为 n 设置警告等级 1-4

/c 只编译，不链接 /Wn 设置警告等级(默认 n=1)

/Hnum 最大外部名称长度 /Wall 启用所有警告

/J 默认 char 类型是 unsigned /Wp64 启用 64 位端口定位警告

/nologo 取消显示版权消息 /WX 将警告视为错误

/showIncludes 显示包含文件名 /WL 启用单行诊断

/Tcsource file 将文件编译为 .c /Yc[file] 创建 .PCH 文件

/Tpsource file 将文件编译为 .cpp /Yd 将调试信息放在每个 .OBJ 中

/TC 将所有文件编译为 .c /Yl[sym] 为调试库插入 .PCH 引用

/TP 将所有文件编译为 .cpp /Yu[file] 使用 .PCH 文件

/Vstring 设置版本字符串 /YX[file] 自动 .PCH

/w 禁用所有警告 /Y- 禁用所有 PCH 选项

/wdn 禁用警告 n /Zmn 最大内存分配(默认为 %)

/wen 将警告 n 视为错误

-链接-

/MD 与 MSVCRT.LIB 链接 /MDd 与 MSVCRTD.LIB 调试库链接

/ML 与 LIBC.LIB 链接 /MLd 与 LIBCD.LIB 调试库链接

/MT 与 LIBCMT.LIB 链接 /MTd 与 LIBCMTD.LIB 调试库链接

/LD 创建 .DLL /Fnum 设置堆栈大小

/LDd 创建 .DLL 调试库 /link [链接器选项和库]

如果对您有帮助，请记得采纳为满意答案，谢谢！祝您生活愉快！

最坏适应算法 c语言

/**------------------------------------------------------

进入程序后可以根据菜单选项进入不同的模块

1.使用首次适应算法分配空间

2.使用最佳适应算法分配空间

3.释放一块空间

4.显示内存分配情况

5.退出系统

----------------------------------------------------------**/

#include stdio.h

#include stdlib.h

#include string.h

#include conio.h

#define MEMSIZE 100 /*定义内存大小为100*/

#define MINSIZE 2 /*如果小于此值 将不再分割内存*/

typedef struct _MemoryInfomation{/* 内存空间分区表 结构*/

int start; /*起始地址*/

int size; /*大小*/

char info; /*状态 F:空闲(Free) U:占用(Used) E 结束(end)*/

}MEMINFO;

MEMINFO MemList[MEMSIZE]; //内存空间信息表

void Display();

/*--------------------------------------------------------

函数名:InitALL()

功 能:初始化所有变量

--------------------------------------------------------*/

void InitAll(){

int i;

MEMINFO temp={0,0,'e'};

for(i=0;iMEMSIZE;i++) //初始化空间信息表

MemList[i]=temp;

MemList[0].start=0; //起始地址为0

MemList[0].size=MEMSIZE;//空间初始为最大的

MemList[0].info='f'; //状态为空闲

}

/*--------------------------------------------------------

函数名:FirstFit_new()

功 能:首次适应算法分配内存

--------------------------------------------------------*/

void FirstFit_new(){

int i,j,size;

char temp[10];

printf("FirstFit_new:How many MEMORY requir?");

gets(temp);

size=atoi(temp); //将字符串转化为整数

for(i=0; i MEMSIZE-1 MemList[i].info != 'e';i++) //到了空间尾且没有空间分配

{

if(MemList[i].size = size MemList[i].info=='f') //满足所需要的大小，且是空闲空间

{

if(MemList[i].size - size = MINSIZE) //如果小于规定的最小差则将整个空间分配出去

MemList[i].info='u'; //标志为使用

else

{

for(j = MEMSIZE-2; j i; j--) //将i后的信息表元素后移

{

MemList[j+1]=MemList[j];

}

//将i分成两部分，使用低地址部分

MemList[i+1].start= MemList[i].start+size;

MemList[i+1].size = MemList[i].size-size;

MemList[i+1].info='f';

MemList[i].size=size;

MemList[i].info='u';

}

break;

}

}

if(i == MEMSIZE-1 || MemList[i].info=='e') //没有找到符合分配的空间

{

printf("Not Enough Memory!!\n");

getchar();

}

Display();

}

/*--------------------------------------------------------

函数名:BestFit_new()

功 能:最佳适应算法分配内存

--------------------------------------------------------*/

void BestFit_new()

{

int i,j,k,flag,size;

char temp[10];

printf("BestFit_new How many MEMORY requir?");

gets(temp);

size=atoi(temp); //将字符串转化为整数

j=0;

flag=0; //标志是否有合适的空间分配，0无，1有

k=MEMSIZE; //用来保存满足要求的最小空间

for(i=0;iMEMSIZE-1 MemList[i].info!='e';i++)

{

if(MemList[i].size = size MemList[i].info == 'f') //符合要求

{

flag=1;

if(MemList[i].size k) //比符合要求的最小空间小，则交换

{

k=MemList[i].size;

j=i;

}

}

}

i=j;

if(flag == 0) //没找到

{

printf("Not Enough Memory!\n");

getch();

j=i;

}

else if(MemList[i].size - size = MINSIZE) //小于规定的最小差，将整个空间分配

MemList[i].info='u';

else

{

for(j = MEMSIZE-2; j i; j--) //后移

MemList[j+1]=MemList[j];

MemList[i+1].start=MemList[i].start+size;

MemList[i+1].size=MemList[i].size-size;

MemList[i+1].info='f';

MemList[i].size=size;

MemList[i].info='u';

}

Display();

}

/*--------------------------------------------------------

最坏适应算法

*/

void BadFit_new()

{

int i,j,k,flag,size;

char temp[10];

printf("BadFit_new How many MEMORY requir?");

gets(temp);

size=atoi(temp);

j=0;

flag=0;

k=0; //保存满足要求的最大空间

for(i=0;iMEMSIZE-1MemList[i].info!='e';i++)

{

if(MemList[i].size=sizeMemList[i].info=='f')

{

flag=1;

if(MemList[i].sizek)

{

k=MemList[i].size;

j=i;

}

}

}

i=j;

if(flag=0)

{

printf("Not Enough Memory!\n");

getch();

j=i;

}

else if(MemList[i].size-size=MINSIZE)

MemList[i].info='u';

else

{

for(j=MEMSIZE-2;ji;j--)

MemList[j+1]=MemList[j];

MemList[i+1].start=MemList[i].start+size;

MemList[i+1].size=MemList[i].size-size;

MemList[i+1].info='f';

MemList[i].size=size;

MemList[i].info='u';

}

Display();

}

/*--------------------------------------------------------

函数名:del()

功 能:释放一块内存

--------------------------------------------------------*/

void del()

{

int i,number;

char temp[10];

printf("\nplease input the NUMBER you want stop:");

gets(temp);

number=atoi(temp);

if(MemList[number].info == 'u') //输入的空间是使用的

{

MemList[number].info = 'f'; //标志为空闲

if(MemList[number+1].info == 'f') //右空间为空则合并

{

MemList[number].size+=MemList[number+1].size; //大小合并

for(i=number+1;i MEMSIZE-1 MemList[i].info !='e';i++)/* i后的空间信息表元素前移 */

if(i0)

MemList[i]=MemList[i+1];

}

if(number 0 MemList[number-1].info=='f') //左空间空闲则合并

{

MemList[number-1].size+=MemList[number].size;

for(i=number;iMEMSIZE-1MemList[i].info!='e';i++)

MemList[i]=MemList[i+1];

}

}

else

{

printf("Thist Number is Not exist or is Not used!\n ");

getchar();

}

Display();

}

/*--------------------------------------------------------

函数名:Display()

功 能:显示内存状态

--------------------------------------------------------*/

void Display(){

int i,

used=0; //记录可以使用的总空间量

/* clrscr();*/

printf("\n----------------------------------------------\n");

printf("%5s%15s%15s","Number","start","size","Info");

printf("\n----------------------------------------------\n");

for(i=0;i MEMSIZE MemList[i].info != 'e';i++)

{

if(MemList[i].info == 'u')

used+=MemList[i].size;

printf("%5d%15d%15d%15s\n",i,MemList[i].start,MemList[i].size,MemList[i].info=='u'?"USED":"FREE");

}

printf("\n----------------------------------------------\n");

printf("Totalsize:%-10d Used:%-10d Free:%-10d\n",MEMSIZE,used,MEMSIZE-used);

printf("\n\n Press Any Key to return...");

getch();

}

/*--------------------------------------------------------

函数名:main()

功 能:主函数

--------------------------------------------------------*/

void main(){

char ch;

InitAll();

while(1){

printf("========================================================\n");

printf(" 1.Get a block use the FISTFIT method\n");

printf(" 2.Get a block use the BESTFIT method\n");

printf(" 3.Get a block use the BadFIT method\n");

printf(" 4.Free a block\n");

printf(" 5.Display Mem info \n");

printf(" 6.Exit \n");

printf("========================================================\n");

ch=getch();

switch(ch){

case '1':FirstFit_new();break; //首次适应算法

case '2':BestFit_new();break; //最佳适应算法

case '3':BadFit_new();break; //最坏适应算法

case '4':del();break; //删除已经使用完毕的空间

case '5':Display();break; //显示内存分配情况

case '6':exit(0);

}

}

}

在C语言中用指针将表中元素的次序反转。

取个例子,L是一条链子,刚开始L-first是链头,你反转链子的过程就是把一节链环拆下来,再接在L的头部

q=p-next就是把q拆下来,;p-next=q-next就是把被拆成两部分的链子连在一起;q-next=L-first把q接在L的头部,L-fist=q就是把L的头部改为q