• 数据结构C语言--基础实验

    实验1 线性表的顺序实现

    1.！顺序表的倒置

    1. /**********************************/
    2. /*文件名称：lab1-01.c             */
    3. /**********************************/
    4. /*基于sequlist.h中定义的顺序表，编写算法函数reverse(sequence_list *L)，实现顺序表的就地倒置。*/
    5. #include "sequlist.h"
    6. /*请将本函数补充完整，并进行测试*/
    7. void reverse(sequence_list *L)
    8. {
    9.     int i,j;
    10.     datatype x;
    11.     i=0;
    12.     j=L->size-1;
    13.     while (i
    14.     {
    15.         x=L->a[i];
    16.         L->a[i]=L->a[j];
    17.         L->a[j]=x;
    18.         i++;
    19.         j--;
    20.     }
    21. }
    22.  
    23. int main()
    24. {
    25.  
    26.     sequence_list L;		/*定义顺序表*/
    27.     input(&L);	        		/*输入测试用例*/
    28.     print(&L);                  /*输出原表*/
    29.     reverse(&L);
    30.     print(&L);                  /*输出新表*/
    31. }

    2.分类，奇数存放到存到顺序表L2中，偶数存到顺序表L3中

    1. /**********************************/
    2. /*文件名称：lab1_02.c             */
    3. /**********************************/
    4.  
    5. /*编写一个算法函数void sprit( sequence_list *L1,sequence_list *L2,sequence_list *L3)，
    6. 将顺序表L1中的数据进行分类，奇数存放到存到顺序表L2中，偶数存到顺序表L3中，编写main()进行测试。
    7. */
    8.  
    9. #include "sequlist.h"
    10. /*请将本函数补充完整，并进行测试*/
    11. void sprit(sequence_list *L1,sequence_list *L2,sequence_list *L3)
    12. {
    13.     int i,j,k;
    14.     i=j=k=0;
    15.     for (i=0;isize;i++)
    16.     {
    17.         if (L1->a[i]%2==1)
    18.                 L2->a[j++]=L1->a[i];
    19.         else
    20.                 L3->a[k++]=L1->a[i];
    21.  
    22.     }
    23.     L2->size=j;
    24.     L3->size=k;
    25. }
    26. int main()
    27. {   sequence_list L1,L2,L3;		/*定义三个顺序表*/
    28.     input(&L1);				    /*输入L1*/
    29.     sprit(&L1,&L2,&L3);		    /*对L1进行分类*/
    30.     print(&L1);				    /*输出L1、L2和L3*/
    31.     print(&L2);
    32.     print(&L3);
    33. }

    3.！将L1与L2中的数据合并到L3中，使数据在L3中按升序排列

    1. /*已知顺序表L1，L2中数据由小到大有序，请用尽可能快的方法将L1与L2中的数据合并到L3中，使数据在L3中按升序排列。*/
    2.  
    3. #include "sequlist.h"
    4. /*请将本函数补充完整，并进行测试*/
    5. void merge(sequence_list *L1,sequence_list *L2,sequence_list *L3)
    6. {
    7.         int i,j,k;
    8.         i=j=k=0;
    9.         while (isize && jsize )
    10.         {
    11.             if (L1->a[i]a[j])
    12.                 L3->a[k++]=L1->a[i++];
    13.             else
    14.                 L3->a[k++]=L2->a[j++];
    15.         }
    16.         while (isize)
    17.                 L3->a[k++]=L1->a[i++];
    18.         while (jsize)
    19.                 L3->a[k++]=L2->a[j++];
    20.         L3->size=k;
    21.  
    22. }
    23. int main()
    24. {
    25.     sequence_list L1,L2,L3;
    26.     input(&L1);				/*输入时请输入有序数据*/
    27.     input(&L2);				/*输入时请输入有序数据*/
    28.     merge(&L1,&L2,&L3);		/*合并数据到L3*/
    29.     print(&L3);				/*输出L3*/
    30. }

    4.！实现求顺序表la与lb的交集存放到顺序表lc中

    1. /*假设顺序表la与lb分别存放两个整数集合，函数inter(seqlist *la,seqlist *lb,seqlist *lc)
    2. 的功能是实现求顺序表la与lb的交集存放到顺序表lc中,请将函数补充完整.  */
    3. /**********************************/
    4. /*文件名称：lab1_04.c                 */
    5. /**********************************/
    6. #include "sequlist.h"
    7. /*请将本函数补充完整，并进行测试*/
    8. void  inter(sequence_list *la,sequence_list *lb,sequence_list *lc)
    9. {
    10.     int i,j,k;
    11.     k=0;
    12.     for (i=0; isize; i++)
    13.     {
    14.             j=0;
    15.            while (jsize  &&  la->a[i]!=lb->a[j])
    16.                 j++;
    17.            if (jsize)
    18.                     lc->a[k++]=la->a[i];
    19.     }
    20.     lc->size=k;
    21. }
    22. int main()
    23. {
    24.   sequence_list la,lb,lc;
    25.   inputfromfile(&la,"1.txt"); 		/*从文件1.txt建立顺序表*/
    26.   inputfromfile(&lb,"2.txt");		/*从文件2.txt建立顺序表*/
    27.   print(&la); 				 	    /*输出la*/
    28.   print(&lb);  				        /*输出lb*/
    29.   inter(&la,&lb,&lc);   		/*求la与lb的交集存于lc中*/
    30.   print(&lc); 					    /*输出lc*/
    31.   return 0;
    32. }

    5.！！将顺序表L中的所有奇数调整到表的左边，所有偶数调整到表的右边

    1. /*
    2. 请编写一个算法函数partion(sequence_list *L)，尽可能快地将顺序表L中的所有奇数调整到表的左边，
    3. 所有偶数调整到表的右边，并分析算法的时间复杂度。
    4. */
    5. /**********************************/
    6. /*文件名称：lab1_05.c                 */
    7. /**********************************/
    8. #include "sequlist.h"
    9. /*请将本函数补充完整，并进行测试*/
    10. void partion(sequence_list *L)
    11. {
    12.     int i, j;           // 定义两个指针i和j
    13.     datatype x;         // 定义临时变量x
    14.  
    15.     i = 0;              // 初始化i为表头位置
    16.     j = L->size - 1;    // 初始化j为表尾位置
    17.  
    18.     do {
    19.         while (i < j && L->a[i] % 2 == 1)   // 从表头向表尾查找第一个偶数元素
    20.             i++;
    21.         while (i < j && (L->a[j] & 0x1) == 0)   // 从表尾向表头查找第一个奇数元素
    22.             j--;
    23.         if (i < j) {    // 如果i
    24.             x = L->a[i];         // 交换元素位置
    25.             L->a[i++] = L->a[j];
    26.             L->a[j--] = x;
    27.         }
    28.     } while (i < j);    // 当i
    29.  
    30. }
    31.  
    32. int main()
    33. {
    34.   sequence_list L;
    35.   inputfromfile(&L,"3.txt");
    36.   print(&L);  						/*输出表L*/
    37.   partion(&L);
    38.   print(&L);  						/*输出新表*/
    39.   return 0;
    40. }

    实验2不带头结点的单链表

    1.删除不带头结点单链表head中第一个值为x 的结点。

    1. /*编写函数slnklist delx(linklist head, datatype x)，删除不带头结点单链表head中第一个值为x 的结点。
    2. 并构造测试用例进行测试。
    3. */
    4. /**********************************/
    5. /*文件名称：lab2_01.c                            */
    6. /**********************************/
    7. #include "slnklist.h"
    8. /*请将本函数补充完整，并进行测试*/
    9. linklist delx(linklist head,datatype x)
    10. {
    11.     linklist  pre,p;
    12.     pre=NULL;
    13.     p=head;
    14.     while (p &&p->info!=x)
    15.     {
    16.         pre=p;
    17.         p=p->next;
    18.     }
    19.     if (p)
    20.     {
    21.            if (pre==NULL)
    22.                     head=p->next;
    23.             else
    24.                     pre->next=p->next;
    25.             free(p);
    26.     }
    27.  
    28.     return head;
    29.  
    30. }
    31.  
    32. int main()
    33. {   datatype x;
    34.     linklist head;
    35.     head=creatbyqueue();		/*尾插入法建立单链表*/
    36.     print(head);
    37.     printf("请输入要删除的值：");
    38.     scanf("%d",&x);
    39.     head=delx(head,x);			/*删除单链表的第一个值为x的结点*/
    40.     print(head);
    41.     delList(head);				/*释放单链表空间*/
    42.     return 0;
    43. }

    2.！！！将不带头结点的单链表head就地 倒置

    1. /**********************************/
    2. /*文件名称：lab2_02.c                 */
    3. /**********************************/
    4. /*
    5. 假设线性表（a1,a2,a3,…an）采用不带头结点的单链表存储，
    6. 请设计算法函数linklist reverse1(linklist  head)和
    7. void reverse2(linklist *head)将不带头结点的单链表head就地 倒置，
    8. 使表变成（an,an-1,…a3.a2,a1）。并构造测试用例进行测试。
    9. */
    10. #include "slnklist.h"
    11. /*请将本函数补充完整，并进行测试*/
    12. linklist reverse1(linklist head)
    13. {
    14.     linklist p, s;  // 定义两个指针p和s
    15.     p = head;       // 将p指向头节点
    16.     head = NULL;    // 初始化反转后的链表头节点为空
    17.  
    18.     while (p)       // 当p非空时进行循环
    19.     {
    20.         s = p;                  // 保存p节点
    21.         p = p->next;            // 移动p指针到下一个节点
    22.         s->next = head;         // 将s节点的next指针指向反转后的链表头节点
    23.         head = s;               // 更新反转后的链表头节点为s节点
    24.     }
    25.  
    26.     return head;    // 返回反转后的链表头节点
    27. }
    28.  
    29. void reverse2(linklist *head)
    30. {
    31.     linklist p,s;
    32.     p=*head;
    33.     *head=NULL;
    34.     while (p)
    35.     {
    36.         s=p;
    37.         p=p->next;
    38.         s->next=*head;
    39.         *head=s;
    40.     }
    41. }
    42.  
    43. int main()
    44. {   datatype x;
    45.     linklist head;
    46.     head=creatbystack();		    /*头插入法建立单链表*/
    47.     print(head);				            /*输出原链表*/
    48.  
    49.     head= reverse1(head);		/*倒置单链表*/
    50.      print(head);				            /*输出倒置后的链表*/
    51.     reverse2(&head);			        /*倒置单链表*/
    52.     print(head);
    53.     delList(head);
    54.  
    55.     return 0;
    56. }

    3.！！插入

    1. /*
    2. 假设不带头结点的单链表head是升序排列的，设计算法函数linklist insert(linklist head,datatype x)，
    3. 将值为x的结点插入到链表head中，并保持链表有序性。
    4. 分别构造插入到表头、表中和表尾三种情况的测试用例进行测试。
    5. */
    6. /**********************************/
    7. /*文件名称：lab2_03.c                 */
    8. /**********************************/
    9. #include "slnklist.h"
    10. /*请将本函数补充完整，并进行测试*/
    11. linklist insert(linklist head ,datatype x)
    12. {
    13.         linklist pre,p,s;
    14.         pre=NULL;
    15.         p=head;
    16.         while ( p && p->info
    17.         {
    18.             pre=p;
    19.             p=p->next;
    20.         }
    21.         s=(linklist )malloc(sizeof(node));
    22.         s->info=x;
    23.  
    24.         if (pre==NULL)
    25.         {
    26.             s->next=head;
    27.             head=s;
    28.         }
    29.         else
    30.         {
    31.             s->next=p;
    32.             pre->next=s;
    33.         }
    34.         return head;
    35. }
    36. int main()
    37. {   datatype x;
    38.     linklist head;
    39.     printf("输入一组升序排列的整数：\n");
    40.     head=creatbyqueue();				/*尾插入法建立单链表*/
    41.     print(head);
    42.     printf("请输入要插入的值：");
    43.     scanf("%d",&x);
    44.     head=insert(head,x);				/*将输入的值插入到单链表适当位置*/
    45.     print(head);
    46.     delList(head);
    47.     return 0;
    48. }

    4.删除

    1. /*
    2. 编写算法函数linklist delallx(linklist head, int x)，删除不带头结点单链表head中所有值为x的结点。
    3. */
    4. /**********************************/
    5. /*文件名称：lab2_04.c                 */
    6. /**********************************/
    7. #include "slnklist.h"
    8. /*请将本函数补充完整，并进行测试*/
    9. linklist delallx(linklist head,int x)
    10. {
    11.      linklist  pre,p;
    12.     pre=NULL;
    13.     p=head;
    14.     while(p)
    15.     {
    16.       	while (p &&p->info!=x)            //找值为x的结点
    17.         {
    18.             pre=p;
    19.             p=p->next;
    20.         }
    21.         if (p)                                          //找到了
    22.         {
    23.             if (pre==NULL)                 //删除的结点为第一个结点
    24.            {
    25.                 head=p->next;
    26.                 free(p);
    27.                 p=head;
    28.            }
    29.             else                                    //删除的结点不是第一个结点
    30.             {
    31.                 pre->next=p->next;
    32.                 free(p);
    33.                 p=pre->next;
    34.             }
    35.         }
    36.  
    37.     }
    38.     return head;
    39. }
    40. int main()
    41. {   datatype x;
    42.     linklist head;
    43.     head=creatbyqueue();				/*尾插入法建立单链表*/
    44.     print(head);
    45.     printf("请输入要删除的值：");
    46.     scanf("%d",&x);
    47.     head=delallx(head,x);
    48.     print(head);
    49.     delList(head);
    50.     return 0;
    51. }

    实验3 带头结点的单链表

    1.删除带头结点单链表head中第一个值为x 的结点

    1. /*编写函数void delx(linklist head, datatype x)，删除带头结点单链表head中第一个值为x 的结点。
    2. 并构造测试用例进行测试。
    3. */
    4. /**********************************/
    5. /*文件名称：lab3_01.c                 */
    6. /**********************************/
    7. #include "slnklist.h"
    8. /*请将本函数补充完整，并进行测试*/
    9. void delx(linklist head,datatype x)
    10. {
    11.     linklist pre,p;
    12.     pre=head;
    13.     p=head->next;
    14.     while (p && p->info!=x)         //查找
    15.     {
    16.         pre=p;
    17.         p=p->next;
    18.     }
    19.     if (p)                                          //删除
    20.     {
    21.         pre->next=p->next;
    22.         free(p);
    23.     }
    24.  
    25. }
    26.  
    27. int main()
    28. {   datatype x;
    29.     linklist head;
    30.     head=creatbyqueue();		/*尾插入法建立带头结点的单链表*/
    31.     print(head);
    32.     printf("请输入要删除的值：");
    33.     scanf("%d",&x);
    34.     delx(head,x);			/*删除单链表的第一个值为x的结点*/
    35.     print(head);
    36.     delList(head);				/*释放单链表空间*/
    37.     return 0;
    38. }

    2.带头结点的单链表head就地倒置

    1. /**********************************/
    2. /*文件名称：lab3_02.c                 */
    3. /**********************************/
    4. /*
    5. 假设线性表（a1,a2,a3,…an）采用带头结点的单链表存储，请设计算法函数void reverse(linklist  head)，
    6. 将带头结点的单链表head就地倒置，使表变成（an,an-1,…a3.a2,a1）。并构造测试用例进行测试。
    7. */
    8. #include "slnklist.h"
    9. /*请将本函数补充完整，并进行测试*/
    10. void reverse(linklist head)
    11. {
    12.         linklist p,s;
    13.         p=head->next;
    14.         head->next=NULL;
    15.         while (p)
    16.         {
    17.             s=p;
    18.             p=p->next;
    19.             s->next=head->next;
    20.             head->next=s;
    21.         }
    22. }
    23. int main()
    24. {   datatype x;
    25.     linklist head;
    26.     head=creatbystack();			/*头插入法建立带头结点的单链表*/
    27.     print(head);					/*输出原链表*/
    28.     reverse(head);			/*倒置单链表*/
    29.     print(head);					/*输出倒置后的链表*/
    30.     delList(head);
    31.     return 0;
    32. }

    ！！！：是否带头结点的差别（带：第一个实际结点：head->next; 不带：第一个实际结点：head）

    1. linklist p,s;
    2. p=head;head=NULL;
    3. while(p)
    4. {
    5.     s=p;
    6.     p=p->next;
    7.     s->next=head;
    8.     head=s;
    9. }
    1. // 带头结点的单链表
    2. linklist p,s;
    3. p=head->next;
    4. head->next=NULL;
    5. while (p)
    6. {
    7.     s=p;
    8.     p=p->next;
    9.     s->next=head->next;
    10.     head->next = s;
    11. }

    3.插入

    1. /*
    2. 假设带头结点的单链表head是升序排列的，设计算法函数linklist insert(linklist head,datatype x)，
    3. 将值为x的结点插入到链表head中，并保持链表有序性。
    4. 分别构造插入到表头、表中和表尾三种情况的测试用例进行测试。
    5. */
    6. /**********************************/
    7. /*文件名称：lab3_03.c                 */
    8. /**********************************/
    9. #include "slnklist.h"
    10. /*请将本函数补充完整，并进行测试*/
    11. void  insert(linklist head ,datatype x)
    12. {
    13.     linklist pre,p,s;
    14.     pre=head;
    15.     p=head->next;
    16.     while (p && p->info
    17.     {
    18.         pre=p;
    19.         p=p->next;
    20.     }
    21.     s=(linklist)malloc(sizeof(node));
    22.     s->info=x;
    23.     s->next=p;
    24.     pre->next=s;
    25. }
    26. int main()
    27. {   datatype x;
    28.     linklist head;
    29.     printf("输入一组升序排列的整数：\n");
    30.     head=creatbyqueue();				/*尾插入法建立带头结点的单链表*/
    31.     print(head);
    32.     printf("请输入要插入的值：");
    33.     scanf("%d",&x);
    34.     insert(head,x);				    /*将输入的值插入到带头结点的单链表适当位置*/
    35.     print(head);
    36.     delList(head);
    37.     return 0;
    38. }

    4.删除

    1. /*
    2. 编写算法函数void  delallx(linklist head, int x)，删除带头结点单链表head中所有值为x的结点。
    3. */
    4. /**********************************/
    5. /*文件名称：lab3_04.c                 */
    6. /**********************************/
    7. #include "slnklist.h"
    8. /*请将本函数补充完整，并进行测试*/
    9. void  delallx(linklist head,int x)
    10. {
    11.     linklist pre,p;
    12.     pre=head;
    13.     p=head->next;
    14.     while(p)
    15.     {
    16.         while (p &&p->info!=x)      //查找
    17.         {
    18.             pre=p;
    19.             p=p->next;
    20.         }
    21.         if (p)                                      //找到了
    22.         {
    23.             pre->next=p->next;
    24.             free(p);
    25.             p=pre->next;                    //删除后p回到pre的后继结点
    26.         }
    27.  
    28.     }
    29. }
    30. int main()
    31. {   datatype x;
    32.     linklist head;
    33.     head=creatbyqueue();				/*尾插入法建立带头结点的单链表*/
    34.     print(head);
    35.     printf("请输入要删除的值：");
    36.     scanf("%d",&x);
    37.     delallx(head,x);
    38.     print(head);
    39.     delList(head);
    40.     return 0;
    41. }

    5.！！！将head中的结点按结点值 升序排列

    1. /*
    2. 已知线性表存储在带头结点的单链表head中，请设计算法函数void sort(linklist head)，将head中的结点按结点值升序排列。
    3. */
    4. /**********************************/
    5. /*文件名称：lab3_05.c                 */
    6. /**********************************/
    7. #include "slnklist.h"
    8. /*请将本函数补充完整，并进行测试*/
    9. void sort(linklist head)
    10. {
    11.     linklist pre, q, p, s;
    12.     p = head->next;     // 将p指向链表的第一个节点
    13.     head->next = NULL;  // 将头节点的next指针置为空，相当于创建一个空的链表
    14.  
    15.     while (p) {
    16.         s = p;          // 保存p节点
    17.         p = p->next;    // 移动p指针到下一个节点
    18.  
    19.         pre = head;     // 初始化pre指针为头节点
    20.         q = head->next; // 初始化q指针为头节点的下一个节点
    21.  
    22.         while (q && q->info < s->info) {    // 找到s节点的插入位置，即找到第一个比s大的节点位置
    23.             pre = q;
    24.             q = q->next;
    25.         }
    26.  
    27.         s->next = q;    // 将s节点插入到pre和q之间
    28.         pre->next = s;  // 修改pre的next指针，将s节点插入到pre和q之间
    29.     }
    30. }
    31.  
    32. int main()
    33. {        linklist head;
    34.          head=creatbyqueue();   		/*尾插法建立带头结点的单链表*/
    35.          print(head);    			    /*输出单链表head*/
    36.          sort(head);     				/*排序*/
    37.          print(head);
    38.          delList(head);
    39.          return 0;
    40. }

    6.

    实验5  递归

    1.！！！！求数组a[left..right]中的最大数

    1. /*
    2.   编写递归算法int max(int a[],int left, int right)，求数组a[left..right]中的最大数。
    3. */
    4.  
    5. #include "ArrayIo.h"
    6. /*请将本函数补充完整，并进行测试*/
    7. int max(int a[],int left,int right)
    8. {
    9.     int lmax,rmax,mid;
    10.     if (left==right) return a[left];
    11.       else
    12.       {
    13.           mid=(left+right)/2;
    14.           lmax=max(a,left,mid);
    15.           rmax=max(a,mid+1,right);
    16.           return lmax>rmax?lmax:rmax;
    17.       }
    18.  
    19. }
    20. int main()
    21. {   int a[10];
    22.     input(a,10);
    23.     print(a,10);
    24.     printf("数组的最大数是:%d\n",max(a,0,9));
    25.     return 0;
    26. }

    2.！！！！将数组a[left..right]中的所有奇数调整到表的左边，所有偶数调整到表的右边。

    1. /*
    2. 请编写一个递归算法函数void partion(int a[], int left, int right)，
    3. 将数组a[left..right]中的所有奇数调整到表的左边，所有偶数调整到表的右边。
    4. */
    5. #include "ArrayIo.h"
    6. #define N 10
    7. /*请将本函数补充完整，并进行测试*/
    8. void partion(int a[], int left, int right)
    9. {
    10.     int x;
    11.     if (left < right)
    12.     {
    13.         while (left < right && a[left] % 2 == 1)  // 从左边找到第一个偶数
    14.             left++;
    15.         while (left < right && a[right] % 2 == 0)  // 从右边找到第一个奇数
    16.             right--;
    17.         if (left < right)
    18.         {
    19.             x = a[left];
    20.             a[left] = a[right];
    21.             a[right] = x;  // 交换左边的偶数和右边的奇数
    22.             partion(a, left + 1, right - 1);  // 递归处理剩余部分
    23.         }
    24.     }
    25. }
    26.  
    27. int main()
    28. {   int a[N];
    29.     init(a,N);				/*随机产生N个数*/
    30.     print(a,N);
    31.     partion(a,0,N-1);
    32.     print(a,N);
    33.     return 0;
    34. }

    3.！！！！！！！冒泡法进行升序排序   采用二分查找法在数组a[left..right]中查找值为key的元素所在的位置

    这是一个经典的冒泡排序算法，使用递归的方式实现。具体步骤如下：

    1. 首先判断数组长度 n 是否大于0。
    2. 设置一个标志 flag 为0，用于标记本轮循环是否发生交换操作。
    3. 遍历数组，比较相邻的元素，如果前面的元素大于后面的元素，则交换它们，并将 flag 设置为1。
    4. 如果本轮循环发生了交换操作，则递归调用 bubbleSort 函数对长度为 n-1 的子数组进行排序。
    5. 递归结束条件是数组长度 n 不大于0。

    这是一个经典的二分查找算法，使用递归的方式实现。具体步骤如下：

    1. 首先判断左指针 left 是否大于右指针 right，如果大于则表示找不到目标元素，返回-1。
    2. 否则，计算中间位置 mid，并判断中间元素与目标元素的大小关系：
      • 如果中间元素等于目标元素，则返回中间位置 mid。
      • 如果目标元素小于中间元素，则在左半部分继续查找，即调用 binSearch 函数查找左半部分。
      • 如果目标元素大于中间元素，则在右半部分继续查找，即调用 binSearch 函数查找右半部分。

    通过以上步骤，可以在有序数组中高效地查找目标元素的位置。

     

    1. /*
    2.   请编写递归函数void bubbleSort(int a[],int n)，
    3.   对长度为n的数组采用冒泡法进行升序排序。
    4.   请编写递归函数int binSearch(int a[], int left, int right,int key)，
    5.   采用二分查找法在数组a[left..right]中查找值为key的元素所在的位置，
    6.   若查找失败函数返回-1。
    7.   */
    8.  
    9. #include "ArrayIo.h"
    10. #define N 10
    11. /*请将本函数补充完整，并进行测试*/
    12. void bubbleSort(int a[],int n)
    13. {    int i,t;
    14.       int flag;
    15.       if(n>0)
    16.       {
    17.           flag=0;
    18.           for(i=0;i-1;i++)
    19.           {
    20.               if(a[i]>a[i+1])
    21.               {
    22.                  t=a[i];
    23.                  a[i]=a[i+1];
    24.                  a[i+1]=t;
    25.                  flag=1;
    26.               }
    27.           }
    28.           if (flag==1) bubbleSort(a,n-1);
    29.       }
    30.       return ;
    31. }
    32. int binSearch(int a[], int left,int right,int key)
    33. {
    34.     int mid;
    35.     if (left>right)
    36.             return -1;
    37.     else
    38.     {
    39.         mid=(left+right)/2;
    40.         if (a[mid]==key)
    41.                 return mid;
    42.         else
    43.             if (key
    44.                 return binSearch(a,left,mid-1,key);
    45.             else
    46.                 return binSearch(a,mid+1,right,key);
    47.     }
    48. }
    49. int main()
    50. {   int x,pos,a[N];
    51.     init(a,N);
    52.    	bubbleSort(a,N);
    53.     print(a,N);
    54.     printf("请输入要查找的数：\n");
    55.     scanf("%d",&x);
    56.     pos=binSearch(a,0,N-1,x);
    57.     if (pos!=-1) printf("a[%d]=%d\n",pos,x);
    58.     else printf("Not found!\n");
    59.     return 0;
    60. }

    4.返回表中最大数所在的结点地址

    1. /*
    2. 已知带头结点的单链表结构定义同实验3，假设链表中所有结点值均不相同，
    3. 请编写一个递归函数linklist max(linklist head)，返回表中最大数所在的结点地址，若链表为空，返回NULL。
    4. */
    5.  
    6.  
    7. #include "slnklist.h"
    8. /*请将本函数补充完整，并进行测试*/
    9. linklist max(linklist head)
    10. {
    11.     linklist m;
    12.     if (head->next==NULL)
    13.             return NULL;
    14.     else
    15.         if (head->next->next==NULL)
    16.             return head->next;
    17.         else
    18.         {
    19.             m=max(head->next);
    20.             return head->next->info > m->info ? head->next:m;
    21.         }
    22. }
    23. int main()
    24. {   linklist head,p;
    25.     head=creatbyqueue();
    26.     print(head);
    27.     p=max(head);
    28.     if (p)
    29.         printf("max=%d\n",p->info);
    30.     else
    31.         printf("链表为空\n");
    32.     return 0;
    33. }

  • 相关阅读:
    Homebrew国内和国外如何自动安装（Mac & Linux）
    权限系统就该这么设计（万能通用），稳的一批！
    YGG 和 BlockchainSpace 举办全国最大的 Web3 活动：Philippine Web3 Festival
    ＜老式喜剧＞
    苹果签名有多少种类之TF签名(TestFlight签名）是什么？优势是什么？什么场合需要应用到？
    02--Spring中AOP
    修复一份SFN代码（可运行）
    26. Python数据类型之列表
    Java学习第七周
    2024.1IDEA 到2026年
  • 原文地址：https://blog.csdn.net/m0_73809176/article/details/134389236