阅读以下函数说明和C语言函数，将应填入(n)处的字句写在对应栏内。

 [说明]

 函数int psort(int a[],int n)实现将含n个整数的数组a[]的不同元素按从小到大顺序存于数组a[]中。实现方法是从未确定的元素列中找到最小元素并将a[]的第i最小元素交换至a[i]位置。如该最小元素比已确定的最后一个最小元素大，则将它接在已确定的元素序列的后面；否则，忽视该元素。

 [C函数]

 int psort(int a[],int n)

 {int i,J,k,P;

 for(i=0,k=0;i＜(1);i++){

 for(j=i+1, (2) ;j＜n; j++)

 if(a[p]＞a[j])

 p=j;

 if(p!=i){

 t=a[p];

 a[p]=a[i];

 a[i]=t;

 }

 if( (3) ) k++;

 else if( (4) ＜a[i])

  (5)=a[i];

 }

 return k;

 }

 int a[]={5,7,5,6,4,3,4,6,7};

 main()

 {int k,n;

 for(k=0;k＜(Sizeof a)/Sizeof(int);k++)

 printf("%5d",a[k]);

 printf ("\n\n");

 n=psort(a,(sizeof(a))/sizeof(int));

 for(k=0;k＜n;k++)

 printf("%5d",a[k]);

 printf("\n\n");

 }

阅读以下说明和Java程序，将应填入(n)处的字句写在对应栏内。

 [说明]

 下面程序输出一个矩形面积，以及矩形区域上的假想的作物产量。

 [Java程序]

 public class MainJava {

  public static void main(String[] args){

    Lot_size small=new Lot_size();

    Lot_size medium=new Lot_size();

    small.set(5,5,5，25);

    medium.set(10,10,10,50);

    System.out.println("For a small lot of area"

        +small.get_area()+"\n");

    System.out.println("the actual crops are $"

        +small.get_data2()+"\n");

    System.out.println("and ideal crops are $"

        +small.get data()+"\n");

    System.out.println("For a medium lot of area"

        +medium.get_area()+“\n”)；

    System.out.println("the actual crops are $"

        +medium.get_data2()+"\n");

    System.out.println ("and ideal crops are $"

        +medium.get_data()+"\n");

 }

}

class Crop_assessment{

 private int actual_crop;

 private int ideal_crop;

 public void set(int in_actual,int in ideal){

 actual_crop=in_actual;

 ideal_crop=in_ideal;

 }

 public int get_actual_crop(){return (1) ;}

 public int get_ideal_crop()(return (2) ;}

}

class Lot_size{

 private int length;

 private int width;

 private Crop_assessment crop= (3) ;

 public void set(int 1,int W,int a,int i){

   length=1;

   width=W;

   crop.set(a,i);

 }

 public int get_area(){return length*width;}

 public int get_data()freturn (4) ;}

 public int get_data2()(return (5) ;}

}

阅读以下说明和C++程序，将应填入(n)处的字句写在对应栏内

 [说明]

 以下程序的功能是计算三角形、矩形和正方形的面积并输出。

 程序由4个类组成：类Triangle，Rectangle和Square分别表示三角形、矩形和正方形；抽象类Figure提供了一个纯虚拟函数getArea()，作为计算上述三种图形面积的通用接口。

 [C++程序]

 #include＜iostream.h＞

 #include＜math.h＞

 class Figure{

 public:

 virtual double getArea()=0; //纯虚拟函数

 };

 class Rectangle: (1) {

 protected:

 double height;

 double width;

 public:

 Rectangle(){};

 Rectangle(double height,double width){

 This-＞height=height;

 This-＞width=width;

 }

 double getarea(){

 return (2);

 }

 };

 class Square: (3) 

 public:

 square(double width){

  (4);

 }

 };

 class triangle: (5) {

 double la;

 double lb;

 double lc;

 public:

 triangle(double la,double lb,double lc){

 this-＞la=la;thiS-＞ib;this-＞lc;

 }

 double getArea(){

 double s=(la+lb+lc)/2.0;

 return sqrt(s*(s-la)**(s-lb)*(s-lc));

 }

 };

 viod main(){

 figure*figures[3]={

 new triangle(2,3,3),new Rectangle(5,8),new Square(5)};

 for(int i=0; i＜3;i++){

 cout＜＜"figures["＜＜i＜＜"]area="＜＜(figures)-＞getarea()＜＜endl;

 }

 }

 };

阅读以下函数说明和C语言函数，将应填入(n)处的字句写在对应栏内。

 [说明]

 函数int psort(int a[],int n)实现将含n个整数的数组a[]的不同元素按从小到大顺序存于数组a[]中。实现方法是从未确定的元素列中找到最小元素并将a[]的第i最小元素交换至a[i]位置。如该最小元素比已确定的最后一个最小元素大，则将它接在已确定的元素序列的后面；否则，忽视该元素。

 [C函数]

 int psort(int a[],int n)

 {int i,J,k,P;

 for(i=0,k=0;i＜(1);i++){

 for(j=i+1, (2) ;j＜n; j++)

 if(a[p]＞a[j])

 p=j;

 if(p!=i){

 t=a[p];

 a[p]=a[i];

 a[i]=t;

 }

 if( (3) ) k++;

 else if( (4) ＜a[i])

  (5)=a[i];

 }

 return k;

 }

 int a[]={5,7,5,6,4,3,4,6,7};

 main()

 {int k,n;

 for(k=0;k＜(Sizeof a)/Sizeof(int);k++)

 printf("%5d",a[k]);

 printf ("\n\n");

 n=psort(a,(sizeof(a))/sizeof(int));

 for(k=0;k＜n;k++)

 printf("%5d",a[k]);

 printf("\n\n");

 }

阅读以下函数说明和C语言函数，将应填入(n)处的字句写在对应栏内。

 [说明]

 这是一个求解Josephus问题的函数。用整数序列1，2，3…，n表示顺序围坐在圆桌周围的人，并采用数组表示作为求解过程中使用的数据结构。Josephus问题描述，设n个人围坐在一个圆桌周围，现在从第s个人开始报数，数到第m个人，让他出局；然后从出局的下一个人重新开始报数，数到第m个人，再让他出局，…如此反复直到所有的人全部出局为止。

 [C函数]

 void Josephus(int A[],int n,s,m)

 (int i,j,k,temp;

 if(m==O){

 printf("m=0是无效的参数!\n");

 return;

 }

 for(i=0;i＜n;i++)  A[i]=i+1; /*初始化，执行n次*/

 i= (1)  /*报名起始位置*/

 for(k=n;k＞1;k-){

 if((2)) i=0;

 i=(3) /*寻找出局位置*/

 if(i!=k-1){

 tmp=A[i];

 for(j=i;J＜k-1;j++) (4);

 (5);

 }

 }

 for(k=0;k＜n/2;k++){

 tmp=A[k];A[k]=A[n-k+1];A[n-k+1]=tmp;

 }

 }

阅读以下函数说明和C语言函数，将应填入(n)处的字句写在对应栏内。

 [说明1]

 L为一个带头结点的循环链表。函数LinkList deletenode(LinkList L,int c)的功能是删除L中数据域data的值大于C的所有结点，并由这些结点组建成一个新的带头结点的循环链表，其头指针作为函数的返回值。

 [C函数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]

 递归函数dec_to_k_2(int n,int k)的功能是将十进制正整数n转换成k(2≤k≤9)进制数，并打印。

 [C函数2]

 dec to k 2(int n,int k)

 { if(n!=O){

 dec to k 2( (4) ,k);

 printf("%d", (5) );

 }

 }

阅读以下说明和流程图，回答问题将解答填入对应栏。

 [说明]

 本流程图采用“双向冒泡法”实现对数组a[n]的排序。双向冒泡法就是在逐步缩小的数组内，分别从数组的两端开始向内搜索，同时将大数往上浮，小数往下沉，每次交换一组数。flag是一个标志，发生过交换就置为1，当这个循环过程都不再发生交换时，则数组排序完成。

 注：流程中循环开始的说明按照“循环变量：循环初值，循环终值，增量”格式描述；

 定义swAP[a,b]为将a和b两数交换。

 [问题]

 将流程图的(1)～(5)处补充完整。