填空题【说明】
函数fun1 (int bb[])的功能是：在3位整数(100～999)中寻找符合条件的整数并依次从小到大存入数组中；它既是完全平方数，两位数字又相同，例如144、676等。
【函数2.11】
fun1 (int bb[])
{
int i, j, k=0, g, s, b;
for (i=100; i＜=999; i++)
{
g=i%10;
{{U}}(1) {{/U}}
b=i/100;
if ((i== (int) sqrt (i) * (int) sqrt (i))
}
【函数2.2说明】
函数void fun2()的功能是：数组a中有300个四位数，求出数组a千位数上的数减百位数上的数减十位数上的数减个位数上的数大于零的个数CNT，再把所有满足此条件的四位数依次存入数组bb中，然后对数组bb的四位数按小到大的顺序进行排序。例如：9123，9-1-2-3＞0，则该数满足条件存入数组bb中，且个数CNT=CNT+1，9812，9-8-1-2＜0，则该数不满足条件，忽略。
【函数2.2】
void fun2 ( )
{
int q,b,s,g,i,j;
for (i=0;i＜300;i++)
{q=a[i]/1000;
b=a[i]/100%10;
s=a[i]/10%10;
g=a[i]%10;
if (q-b-s-g＞0)
{{U}}(3) {{/U}}
}
for ( i=0;i＜cnt-1;i++ )
for ( j=i+1;j＜cnt;j++ )
if ( bb[i]＞bb[j] )
{{{U}} (4) {{/U}}
bb[i]=bb[j];
{{U}}(5) {{/U}}
}
}
填空题阅读以下说明和C++程序，将应填入 (n) 处的字句写在对应栏内。 [说明] 下面程序是为汽车市场编制的一个程序的一部分。其中automobile是基类。 [C++程序] //Auto.h #ifndef AUTO_H #define AUTO_H class automobile (1): int miles_per_gallon; //汽车每加仑行驶公里数 float fuel_capacity； //油箱容积 public: void initialize(int in_mpg,int in_fuel); int get_mpg(void); float get_fuel(void); float travel_distance(void); #endif //Auto.cpp #include"auto.h" void automobile::initialize(int in_mpg,float in fuel) miles_per_gallon=in_mpg; fuel_capacity=in_fuel; ) int automobile::get_mpg() //提供一辆特定汽车每加仑公里数 return miles per_gallon; float automobile::get_fuel() //提供油箱容积 return fuel_capacity; float automobile::travel_distance() return (2) //car.h #ifndef CAR_H #define CAR_H #include"auto.h" class car: (3) int Total_doors; public: void initialize(int in_mpg,float in_fuel,int doors=4); int doors(void); ; #endif //car.cpp #include"car.h" void car::initialize(int in_mpg,float in_fuel,int door) Total_doors=door; miles_per_galion=in_mpg; fuel_capacity=in_fuel; int car::doors(void) return Total doors; //Allauto.cpp #include #include"auto.h" #include"car.h" int main() car sedan; sedan.initialize(24，20.0，4); tout＜＜"The sedan can travel"＜＜ (4) ＜＜"miles./n"; cout＜＜"The sedan has"＜＜ (5) ＜＜"doors./n"; return 0;
填空题[说明]某绘图系统存在Point、Line和Square3种图元，它们具有Shape接口，图元的类图关系如图8-6所示。现要将Circle图元加入此绘图系统以实现功能扩充。已知某第三方库已经提供了XCircle类，且完全满足系统新增的Circle图元所需的功能，但XCircle不是由Shape派生而来的，它提供的接口不被系统直接使用。[Java代码1]既使用了XCircle又遵循了Shape规定的接口，既避免了从头开发一个新的Circle类，又可以不修改绘图系统中已经定义的接口。[Java代码2]根据用户指定的参数生成特定的图元实例，并对其进行显示操作。该绘图系统定义的接口与XCircle提供的显示接口及其功能如表8-3所示。[Java代码1]classCircle(1)private(2)pxc;publicCircle()pxc=new(3);publicvoiddisplay()pxc.(4);[Java代码2]publicclassFactorypublic(5)getShapeInstance(inttype)//生成特定类实例Switch(type)case0:returnnewPoint();case1:returnnewRectangle();case2:returnnewLine();case3:returnnewCircle();default:returnnull;;publicclassApppublicstaticvoidmain(Stringargv[])if(argv.length!=1)System.out.println("errorparameters!");return;inttype=(newInteger(argv[0])).intValue();Factoryfactory=newFactory();Shaps;s=factory.(6)if(s==null)System.out.println("Errorgetinstance!");Return;s.display();return;
填空题1】 假设以带头结点的单循环链表作非递减有序线性表的存储结构。函数deleteklist(LinkList head)的功能是删除表中所有数值相同的多余元素，并释放结点空间。 例如：链表初始元素为： (7, 10，10，21，30，42，42，42，51，70) 经算法操作后变为： (7，10，21，30，42，51，70) 【函数3.1】 void deleteklist(LinkList head) LinkNode * p, * q; p=head-＞next; while(p!=head) q=p-＞next; while( (1) ) (2) ; free(q); q=p-＞next; p=p-＞next; 【说明3.2】 已知一棵完全二叉树存放于一个一维数组T[n]中，T[n]中存放的是各结点的值。下面的程序的功能是：从T[0]开始顺序读出各结点的值，建立该二叉树的二叉链表表示。 【函数3.2】 #include＜istream.h＞ typedef struct node int data; stuct node leftChild, rightchild; BintreeNode; typedef BintreeNode * BinaryTree; void ConstrncTree(int T[], int n, int i, BintreeNode * /*置根指针为空*/ else ptr=-(BTNode * )malloc(sizeof(BTNode) ) ptr-＞data=T[i]; ConstrucTree(T,n,2, i+1, (4) ); ConstrucTree(T,n, (5) ,ptr-＞rightchild); main(void) /*根据顺序存储结构建立二叉链表*/ Binarytree bitree;int n; printf("please enter the number of node: /n%s" ;n); int* A = (int *) malloc(n * sizeof(int)); for(int i=0;i＜n;i++)scanf(" %d,A+i); /*从键盘输入结点值*/ for(int i=0;i＜n;i++)printf(" %d",A[i]); ConstructTree(A, n,0, bitree);
填空题【说明】
为了减少直接插入排序关键字的比较次数，本算法使用了二分(折半)插入法对一个无序数组R[1.n]进行排序。排序思想是对一个待插入元素，先通过二分法(折半)找到插入位置，后移元素后将该元素插入到恰当位置(假设R[]中的元素互不相同)。
【算法】
1．变量声明
X：DataType
i，j，low，high，mid，R[0..n])
2．每循环一次插入一个R[i]
循环：i以1为步长，从2到n，反复执行
①准备
X＜-R[i]；{{U}} (1) {{/U}}；high＜-i-1;
②找插入位置
循环：当{{U}} (2) {{/U}}时，反复执行
{{U}} (3) {{/U}};
若X.key＜R[mid].key
则high＜-mid-1
否则{{U}} (4) {{/U}}
③后移
循环：j以-1为步长，从{{U}} (5) {{/U}}，反复执行
R[j+1]＜-R[j]
④插入
R[low]＜-X
3．算法结束
填空题[说明] 下面程序定义了一个类Shape及其成员函数，然后从类Shape派生出类Point、类Circle、类Cylinder，以及它们的成员函数。 [Java程序] (1) Shape public abstract void printShapeName(); //纯虚函数。 public double area()return 0.0; public double volumn()return 0.0; class Point extends Shape private double x.y; public Point (double a, double b)x=a; y=b; public void setPoint (double a,double b)x=a;y=b; final public double getX() return x; final public double getY()return y; public void printShapeName() (2) ; class Circle extends Point private double radius; public Circle(double r, double a, double b) (3) ; radius=r＞0? r:0; public void setRadius (double r) radius=r＞0 ? r:0; public double getRadius () return radius; public double area()return 3.14259 * radius * radius; public void printshapeName () System.out.print ("circle: ") ; ; ; class Cylinder (4) private double height; public Cylinder(double h, double r, double x, double y) super (r, x, y) ; height = h＞0 ? h:0; public void setHeight (double h) height = h＞0 ? h:0; public double area () //计算表面积 return (5) ; public double volumn () double r=super.getRadius () ; return 3.14159 * r * r * height; public void printShapeName () System. out .print ("cylinder: ") ;
填空题阅读以下函数说明和C语言函数，将应填入{{U}} (n) {{/U}}处的字句写在对应栏内。 [说明] 这是一个模拟渡口管理的算法。某汽车轮渡口，过江渡船每次能载10辆车过江。过江车辆分为客车类和火车类，上船有如下规定：同类车先到先上船，客车先于货车上渡船，且每上4辆客车，才允许上一辆货车；若等待客车不足4辆，则以货车代替，若无货车等待则允许客车都上船。 程序中用到的函数有enqueue(queue*sq，elemtype*x)在队列sq中入队一个元素x；outqueue(queue*sq，elemtype*x)在队列sq中出队一个元素，并将其值赋给x；empty(queue*sq)判断队列sq是否为空队，若为空，返回1；否则返回0。 [C程序] #include＜stdio.h＞ void pass(){ queue bus,truct; /*bus表示客车队列，truck表示货车队列*/ char ch; int n,tag； /* ]n为车号，tag为标志，tag=0表示客车，tag=1表示货车*/ intcount=0，countbus=0，counttruck=0; /*分别表示上渡船汽车数、客车数、货车数*/ while(1){ printf("输入命令: /n"); Scanf("%c"， switch(ch){ case'e': case'E': printf("车号: /n"); Scanf("%d"， printf("客车/货车(0/1): /n"); scanf("%d"， if({{U}} (1) {{/U}}) enqueue( else enqueue( break; case'i': case'I': while(count＜10){ if({{U}} (2) {{/U}}bus)==0){ /*客车出队*/ outqueue( printf("上船的车号为: /n"); count++; {{U}}(3) {{/U}}; } eise if({{U}} (4) {{/U}}){ /*货车出队*/ countbus=0; outqueue( printf("上船的车号为: /n"); count++; counttruck++; } else if(empty( outqueue(n); printf("没有10辆车排队轮渡/n"); count++; countbus++; } else{ printf("没有10辆车排队轮渡/n"); retUrn; } break; } case'q': case'Q':break; } if(ch=='q' || ch=='Q') break; } }
填空题[说明] 下面程序实现十进制向其他进制的转换。 [Java程序] C1ass Node int data； Node next； class Transform private Node top； publiC void print() Node P； while(top !=null) P=top； if(P.data＞9) System.out.print((char)(p.data+55))； else System.out.print(p.data); top=P.next; public void Trans(int d,int i)(//d为数字;i为进制 int m； (1) n=false; Node P; while(d＞0) (2) ; d=d/i; P=flew Node()； if( (3) ) P.data=m； (4) ; top=P； n=true； else p.data=m； (5) ； toP=P；
填空题[说明] 下面程序计算正方体、球体和圆柱体的表面积和体积。 [C++程序] #include＜iostream.h＞ class container protected: double radius; public： container(double radius) container::radius=radius; (1) ; (2) ; ; class cube: (3) public： cube(double radius)::container(radius)(); double surface_area() return radius*radius*6; double volume() return radius*radius*radius; ; class sphere: public container (4) ; double surface_area() return 4*3.1416 *radius*radius; double volume() return 3.1416*radius *radius*radius*4/3; ; class cylinder:public container double height; public： cylinder(double radius, double height):container(radius) (5) ; double surface_area() return 2*3.1416*radius*(height+radius); double volume() return 3.1416 *radius*radius*height; ; void main() container *p; cube obj1(5); sphere obj2 (5); cylinder obj3(5，5); p=＆obj1; cout＜＜"正方体表面积："＜＜p-＞surface_area()＜＜endl; cout＜＜"正方体体积："＜＜p-＞volume()＜＜endl; p=＆obj2; cout＜＜"球体表面积："＜＜p-＞surface_area()＜＜endl; cout＜＜"球体体积："＜＜p-＞volume()＜＜endl; p=＆obj3; cout＜＜"圆柱体表面积："＜＜p-＞surface_area()＜＜endl; cout＜＜"圆柱体体积："＜＜p-＞volume()＜＜endl;
填空题[说明]下面流程图完成快速排序算法。快速排序法通过分割的方法来进行排序。其本质是把数组分成左右两个部分，在左边部分只保存数组中小于某个特定数值的那些数据，而在右边的部分保存数组中大于这个特定数值的那些数据，在两个部分之间插入这个特定的数值。当快速排序算法对数组的分割完成后，这个数值就在正确的排序位置了(这时它就没有必要继续和后面的数据比较了)，于是快速排序法产生了两个单独的数组。如果这两个数组不相关，单独排序，于是又产生了两个排序的单独数组，对这两个单独的表进行快速排序，重复上述步骤直到所有的数据都处在各自适当的位置。注：快排函数定义为run(data，left，right)，left和right分别为数组上下界。[问题]将流程图的(1)～(5)处补充完整。
填空题阅读以下说明和Java程序，将应填入 (n) 处的字句写在对应栏内。 [说明] 下面程序实现十进制向其它进制的转换。 [Java程序] ClasS Node int data; Node next;class Transform private Node top; public void print() Node p; while(top!=null) P=top; if(P.data＞9) System.out.print((char)(P.data+55)); else System.out.print(p.data); top=p.next; public void Trans(int d,int i)//d为数字;i为进制 int m; (1) n=false; Node p; while(d＞0) (2) ; d=d/i; p=new Node(); if( (3) ) p.data=m; (4) ; top=P; n=true; else p.data=m; (5) ； top=P；
填空题[说明]如图所示的一圆圈上分布6个环，请在每个环中填一个数字，使得从任一环开始按顺时针所得的六位数与按逆时针所得的6位数都为素数。[函数]main()inti,j,a,b,k;longm,m1,n,t,u,v;for(n=100001;n＜999999;n+2)/*n穷举所有6位奇数*/a=0;(1);/*设m为一个顺转6位数*/for(i=1;i＜=6;i++)t=-m/1000000;(2);for(v=u,m1=0,k=1;k＜=5;k++)b=v%10;v=v/10;m1=m1*m1*10+b;(3);/*m1为相应的逆转6位数*//*m为顺圈数,m1为逆圈数*/for(j=2;j＜=999;j++)if(m%j==0｜｜.(4))/*判别m,m1是否为素数*/a=1;break;(5);/*原m转一环得新顺转数m*//*原m转一环得新顺圈数m*/if(a==1)break;if(a==0)prinff("%1d/n",n);break;
填空题[函数2.1说明] L为一个带头结点的循环链表。函数deletenode(LinkList L，int c)的功能是删除L中数据域data的值大于c的所有结点，并由这些结点组建成一个新的带头结点的循环链表，其头指针作为函数的返回值。 [函数2.1] LinkList deletenode(LinkList L, int c) LinkList Lc，p，pre; pre=L; p= (1) ; Lc=(LinkList)malloc(sizeof(ListNode)); Lc-＞next=Lc; while(p!=L) if(p-＞data＞c) (2) ; (3) ; Lc-＞next=p; p=pre-＞next; else pre=p; p=pre-＞next; return Lc; [函数2.2说明] 递归函数dec_to_k_2(int n，int k)的功能是将十进制正整数n转换成k(2≤k≤9)进制数，并打印。 [函数2.2] dec_to_k_2 (int n,int k) //将十进制正整数n转换成k(2≤k≤9)进制数。 if(n!=0) dec_to_k_2( (4) ，k); printf("%d"， (5) );
填空题1】【应用说明5.1】本应用程序的窗体中有一个下拉式列表框(名称为Combo1)和两个文本框(名称分别为Txt1和Txt2)。运行时，用户从Combo1的列表中进行选择，程序就会将选中条目的内容以及编号(从0开始)分别在文本框Txt1和Txt2中显示出来。【程序代码5.1】PrivateSubCombo1_Click()Txt1.Text=Combo1.(1)Txt2.Text=Combo1.(2)EndSub(注：可供(2)处选择的选项：List,Index,Listlndex,ListCount,Number)【应用说明5.2】本应用程序的运行窗口如图2所示。开发该应用的部分程序代码如下：【程序代码5.2】PrivateSubCmbOp_Click()DimDatalnAsDouble,DataOutasDoubleDataln=(3)SelectCase(4)Case"取整数部分"DataOut=Int(Dataln)Case"求平方根"IfDataln＜0ThenMagBox"负数不能开平方!"ElseDataOut=Sqr(Dataln)EndIfCase"取绝对值"DataOut=Abs(Dataln)(5)TxtOut.Text=str$(DataOut)EndSub
填空题阅读以下函数说明和C语言函数，将应填入 (n) 处的字句写在对应栏内。 [说明] 这是一个模拟渡口管理的算法。某汽车轮渡口，过江渡船每次能载10辆车过江。过江车辆分为客车类和火车类，上船有如下规定：同类车先到先上船，客车先于货车上渡船，且每上4辆客车，才允许上一辆货车；若等待客车不足4辆，则以货车代替，若无货车等待则允许客车都上船。 程序中用到的函数有enqueue(queue*sq，elemtype*x)在队列sq中入队一个元素x；outqueue(queue*sq，elemtype*x)在队列sq中出队一个元素，并将其值赋给x；empty(queue*sq)判断队列sq是否为空队，若为空，返回1；否则返回0。 [C程序] #include＜stdio.h＞ void pass() queue bus,truct; /*bus表示客车队列，truck表示货车队列*/ char ch; int n,tag； /* ]n为车号，tag为标志，tag=0表示客车，tag=1表示货车*/ intcount=0，countbus=0，counttruck=0; /*分别表示上渡船汽车数、客车数、货车数*/ while(1) printf("输入命令: /n"); Scanf("%c"， switch(ch) case'e': case'E': printf("车号: /n"); Scanf("%d"， printf("客车/货车(0/1): /n"); scanf("%d"， if( (1) ) enqueue( else enqueue( break; case'i': case'I': while(count＜10) if( (2) bus)==0) /*客车出队*/ outqueue( printf("上船的车号为: /n"); count++; (3) ; eise if( (4) ) /*货车出队*/ countbus=0; outqueue( printf("上船的车号为: /n"); count++; counttruck++; else if(empty( outqueue(n); printf("没有10辆车排队轮渡/n"); count++; countbus++; else printf("没有10辆车排队轮渡/n"); retUrn; break; case'q': case'Q':break; if(ch=='q' || ch=='Q') break;
填空题阅读以下函数说明和C语言函数，将应填入{{U}} (n) {{/U}}处的字句写在对应栏内。 [说明] 本程序实现对指定文件内的单词进行计数。其中使用二叉树结构来保存已经读入的不同单词，并对相同单词出现的次数进行计数。此二叉树的左孩子结点的字符串值小于父结点的字符串值，右孩子结点的字符串值大于父结点的字符串值。函数getword(char*filename，char*word)是从指定的文件中得到单词。char*strdup(char*S)是复制S所指向的字符串，并返回复制字符串的地址。 [C程序] #include ＜stdio.h＞ #include ＜ctype.h＞ #include ＜string.h＞ #define MAXWORD 100 struct node { char*word; int count; struct node*left; struct node*right; } struct node*addtree(struct node*P,char*w) { int cond; if(p==NULL){ /*向树中插入结点*/ P=(struct node*)malloc(sizeof(struct node)); P-＞word=strdup(w); P-＞count=1; {{U}} (1) {{/U}}; } elseif((oond=strcmp(w,p-＞word))==0){{U}} (2) {{/U}}; else if(cond＜0)p-＞left={{U}} (3) {{/U}}; else p-＞right={{U}} (4) {{/U}}; return p; } main() { Struct node*root; char word[MAXWORD]; root=NULL; filename="example.dat"; while(getword(filename,word)!=EOF)) root={{U}} (5) {{/U}}; }
填空题【说明2.1】 L为一个带头结点的循环链表。函数deletenode(LinkList L, int c)的功能是删除L中数据域data的值大于c的所有结点，并由这些结点组建成一个新的带头结点的循环链表，其头指针作为函数的返回值。 【函数2.1】 LinkList deletenode(LinkList L, int c) LinkList Lc,p,pre; pre=L; p= (1) ; Lc=(LinkList)malloc(sizeof(ListNode) ); Lc-＞next=Lc while(p!=L) if(p-＞data＞c) (2) ; (3) ; Lc-＞next=p; p=pre-＞next; else pre=p; p=pre-＞next; return Lc; 【说明2.2】 递归函数dec_to_k_2(int n, int k)的功能是将十进制正整数n转换成k＜2≤k≤9)进制数，并打印。 【函数2.2】 dec_to_k_2(int n, int k) /*将十进制正整数n转换成k(2≤k≤9)进制数*/ if(n!=0) dec_to_k_2( (4) ,k); printf("%d", (5) );
填空题阅读以下说明和算法，完善算法并回答问题，将解答写在对应栏内。[说明]假设以二维数组G[1..m,1..n]表示一幅图像各像素的颜色，则G[i,j]表示区域中点(i,j]处的颜色，颜色值为0到k的整数。下面的算法将指定点(i0,j0)所在的同色邻接区域的颜色置换为给定的颜色值。约定所有与点(i0,j0)同色的上、下、左、右可连通的点组成同色邻接区域。例如，一幅8×9像素的图像如图1-1所示。设用户指定点(3,5)，其颜色值为0，此时其上方(2,5)、下方(4,5)、右方(3,6)邻接点的颜色值都为0，因此这些点属于点(3,5)所在的同色邻接区域，再从上、下、左、右四个方向进行扩展，可得出该同色邻接区域的其他点(见图1-1中的阴影部分)。将上述同色区域的颜色替换为颜色值7所得的新图像如图1-2所示。[算法]输入：矩阵G，点的坐标(i0,j0)，新颜色值newcolor。输出：点(i0,j0)所在同色邻接区域的颜色置换为newcolor之后的矩阵G。算法步骤(为规范算法，规定该算法只在第七步后结束)：第一步：若点(i0,j0)的颜色值与新颜色值newcolor相同，则{{U}}(1){{/U}}；第二步：点(i0,j0)的颜色值→oldcolor；创建栈S，并将点坐标(i0,j0)入栈；第三步：若{{U}}(2){{/U}}，则转第七步；第四步：栈顶元素出栈→(x,y)，并{{U}}(3){{/U}}；第五步：1)若点(x,y-1)在图像中且G[x,y-1]等于oldcolor,则(x,y-1)入栈S；2)若点(x,y+1)在图像中且G[x,y+1]等于oldcolor,则(x,y+1)入栈S；3)若点(x-1,y)在图像中且G[x-1,y]等于oldcolor,则(x-1,y)入栈S；4)若点(x+1,y)在图像中且G[x+1,y)等于oldcolor,则(x+1,y)入栈S：第六步：转{{U}}(4){{/U}}；第七步：算法结束。[问题]是否可以将算法中的栈换成队列?回答：{{U}}(5){{/U}}。
填空题【说明】 本题给出四个函数，它们的功能分别是： 1．int push(PNODE*top，int e)是进栈函数，形参top是栈顶指针的指针，形参e是入栈元素。 2．int pop(PNODE*top，int*e)是出栈函数，形参top是栈顶指针的指针，形参e作为返回出栈元素使用。 3．int enQueue(PNODE*tail，int e)是入队函数，形参tail是队尾指针的指针，形参e是入队元素。 4．int deQueue(PNODE*tail，int*e)是出队函数，形参tail是队尾指针的指针，形参e作为返回出队元素使用。 以上四个函数中，返回值为。表示操作成功，返回值为-1表示操作失败。 栈是用链表实现的；队是用带有辅助结点(头结点)的单向循环链表实现的。两种链表的结点类型均为： typedef struct node int value; struct node * next; NODE, * PNODE; 【函数1】 int push(PNOOE * top,int e) PNODE p = (PNODE) malloc (sizeof (NODE)); if (! p) return-1; p-＞value=e; (1) ;. *top=p; return 0; 【函数2】 int pop (PNODE * top,int * e) PNODE p = * top; if(p == NULL) return-1; * e = p-＞value; (2) ; free(p); return 0; 【函数3】 int enQueue (PNODE * tail,int e) PNODE p,t; t= *tail; p = (PNODE) malloc(sizeof(NODE)); if(!p) return-1; p-＞value=e; p-＞next=t-＞next; (3) ; * tail = p; return 0; 【函数4】 int deQueue(PNODE * tail,int * e) PNODE p,q; if(( * tail)-＞next == * tail) return-1; p= (* tail)-＞next; q = p -＞next; * e =q -＞value; (4) =q-＞next; if(,tail==q) (5) ; free(q); return 0;
填空题【说明2.1】
L为一个带头结点的循环链表。函数deletenode(LinkList L, int c)的功能是删除L中数据域data的值大于c的所有结点，并由这些结点组建成一个新的带头结点的循环链表，其头指针作为函数的返回值。
【函数2.1】
LinkList deletenode(LinkList L, int c)
{
LinkList Lc,p,pre;
pre=L;
p={{U}} (1) {{/U}};
Lc=(LinkList)malloc(sizeof(ListNode) );
Lc-＞next=Lc
while(p!=L)
if(p-＞data＞c)
{
{{U}} (2) {{/U}};
{{U}} (3) {{/U}};
Lc-＞next=p;
p=pre-＞next;
}
else
{
pre=p;
p=pre-＞next;
}
return Lc;
}
【说明2.2】
递归函数dec_to_k_2(int n, int k)的功能是将十进制正整数n转换成k＜2≤k≤9)进制数，并打印。
【函数2.2】
dec_to_k_2(int n, int k)
{ /*将十进制正整数n转换成k(2≤k≤9)进制数*/
if(n!=0)
{
dec_to_k_2({{U}} (4) {{/U}},k);
printf("%d",{{U}} (5) {{/U}});
}
}