demo_3_24

   1 #define _CRT_SECURE_NO_WARNINGS 1
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5 struct date
   6 {
   7     int _year;
   8     int _month;
   9     int _day;
  10 };
  11 int main()
  12 {
  13     //定义一个日期数组
  14     int days[] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
  15     struct date d;
  16     //输入数据
  17     scanf("%d %d %d", &d._year, &d._month, &d._day);
  18     int day = 0;
  19     //循环累加
  20     for (int i = 1; i < d._month; ++i)
  21     {
  22         day += days[i];
  23     }
  24     //累加当前月的天数
  25     day += d._day;
  26     //判断是否为闰年
  27     if ((d._year % 4 == 0 && d._year % 100 != 0) || (d._year % 400 == 0))
  28     {
  29         if (d._month>2)
  30         {
  31             ++day;
  32         }
  33     }
  34     printf("这是这一年的第%d天\n", day);
  35     system("pause");
  36     return 0;
  37 }
  38 
  39 
  40 struct date
  41 {
  42     int _year;
  43     int _month;
  44     int _day;
  45 };
  46 days(struct date d)
  47 {
  48     //日期数组
  49     int num[] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
  50     int n = sizeof(num) / sizeof(num[0]);
  51     //累加日期
  52     int ret = 0;
  53     for (int i = 1; i < d._month; ++i)
  54     {
  55         ret += num[i];
  56     }
  57     //累加当前月的天数
  58     ret += d._day;
  59     //判断是否包含2月
  60     if (d._month>2)
  61     {
  62         if ((d._year % 4 == 0 && d._year % 100 != 0) || (d._year % 400 == 0))
  63         {
  64             ++ret;
  65         }
  66     }
  67     return ret;
  68 }
  69 int main()
  70 {
  71     struct date d;
  72     printf("请输入日期:>\n");
  73     scanf("%d %d %d", &d._year, &d._month, &d._day);
  74     printf("这是第 %d 天\n", days(d));
  75     system("pause");
  76     return 0;
  77 }
  78 
  79 
  80 #define LEN 10
  81 struct student
  82 {
  83     int num;
  84     char name[LEN];
  85     int score[3];
  86 };
  87 void print(struct student * stuArr,int num)
  88 {
  89     for (int i = 0; i < num; ++i)
  90     {
  91         printf("%d %s %d %d %d %d\n", stuArr[i].num, stuArr[i].name, stuArr[i].score[0], stuArr[i].score[1], stuArr[i].score[2]);
  92 
  93     }
  94 }
  95 int main()
  96 {
  97     struct student stuArr[5];
  98     printf("请输入5名学生的数据:学号 名字 成绩1 成绩2 成绩3>");
  99     for (int i = 0; i < 5; ++i)
 100     {
 101         scanf("%d %s %d %d %d", &stuArr[i].num, &stuArr[i].name, &stuArr[i].score[0], &stuArr[i].score[1], &stuArr[i].score[2]);
 102     }
 103     //调用函数,输出数据
 104     print(stuArr, 5);
 105     system("pause");
 106     return 0;
 107 }
 108 
 109 
 110 
 111 #define LEN 3
 112 struct student
 113 {
 114     int num;
 115     char name[LEN];
 116     int score[3];
 117 };
 118 void Input(struct student * stuArr,int n)
 119 {
 120     //输入学生的数据
 121     printf("输入五名学生的数据 学号 姓名 成绩1 成绩2 成绩3:>\n");
 122     for (int i = 0; i < 5; ++i)
 123     {
 124         scanf("%d %s %d %d %d", &stuArr[i].num, &stuArr[i].name, &stuArr[i].score[0], &stuArr[i].score[1], &stuArr[i].score[2]);
 125     }
 126 }
 127 void Print(struct student * stuArr,int n)
 128 {
 129     printf("请输入%d名学生的数据:>\n", n);
 130     for (int i = 0; i < n; ++i)
 131     {
 132         printf("%d %s %d %d %d", stuArr[i].num, stuArr[i].name, stuArr[i].score[0], stuArr[i].score[1], stuArr[i].score[2]);
 133     }
 134 }
 135 int main()
 136 {
 137     struct student stuArr[5];
 138     printf("请输入5名学生的数据:学号 名字 成绩1 成绩2 成绩3>");
 139     
 140     Input(stuArr, 5);
 141     Print(stuArr, 5);
 142     system("pause");
 143     return 0;
 144 }
 145 
 146 
 147 
 148 #define LEN 20
 149 #define STUCNT 5
 150 //定义学生结构体
 151 struct student
 152 {
 153     int num;
 154     char name[LEN];
 155     int score[STUCNT];
 156     float avg;
 157 };
 158 int main()
 159 {
 160     //定义学生结构体数组
 161     struct student arr[STUCNT];
 162     int maxI;
 163     float maxAvg = 0.0;
 164     //输入数据
 165     printf("请输%d个学生的数据:学号 姓名 成绩1 成绩2 成绩3>\n", STUCNT);
 166     for (int i = 0; i < STUCNT; ++i)
 167     {
 168         float avg = 0.0;
 169         scanf("%d %s", &arr[i].num, &arr[i].name);
 170         for (int j = 0; j < 3; ++j)
 171         {
 172             scanf("%d", &arr[i].score[j]);
 173             avg += arr[i].score[j];
 174         }
 175         //学生的平均值
 176         avg /= 3;
 177         arr[i].avg = avg;
 178         //记录最大数据
 179         if (avg>maxAvg)
 180         {
 181             maxAvg = avg;
 182             maxI = i;
 183         }
 184     }
 185     //打印数据
 186     printf("学号 姓名 成绩1 成绩2 成绩3 平均成绩:>");
 187     for (int i = 0; i < STUCNT; ++i)
 188     {
 189         printf("%d %s", arr[i].num, arr[i].name);
 190         for (int j = 0; j < 3; ++j)
 191         {
 192             printf("%d", arr[i].score[j]);
 193         }
 194         printf("%f\n", arr[i].avg);
 195     }
 196     //打印最高平均成绩的学生数据
 197     printf("平均成绩最高的学生:>\n");
 198     printf("%d %s %d %d %d %f\n", arr[maxI].num, arr[maxI].name, arr[maxI].score[0], arr[maxI].score[1], arr[maxI].score[2],arr[maxI].avg);
 199     system("pause");
 200     return 0;
 201 }
 202 
 203 
 204 
 205 #define NUM 13
 206 //定义节点
 207 typedef struct people
 208 {
 209     int num;
 210     struct people* next;
 211 }people;
 212 int main()
 213 {
 214     //定义包含13个人的数据
 215     people arr[NUM];
 216     //遍历环状链表
 217     people* head = arr;
 218     for (int i = 0; i < NUM; ++i)
 219     {
 220         head->num = i + 1;
 221         head->next = &arr[i + 1];
 222         head = head->next;
 223     }
 224     //构成环状结构
 225     arr[NUM - 1].next = arr;
 226     //开始报数
 227     int count = NUM;
 228     //从1开始报数
 229     int i = 1;
 230     head = arr;
 231     while (count > 1)
 232     {
 233         //判断是否已经退出
 234         if (head->num == 0)
 235         {
 236             //跳过此人
 237             head = head->next;
 238             continue;
 239         }
 240         if (i == 3)
 241         {
 242             //当前此人需要退出
 243             printf("第%d个人退出\n", head->num);
 244             head->num = 0;
 245             count--;
 246         }
 247         //继续报号
 248         ++i;
 249         head = head->next;
 250         //判断报号是否大于3
 251         if (i > 3)
 252         {
 253             i = 1;
 254         }
 255     }
 256     //找出编号不为0的人
 257     while (head->num == 0)
 258     {
 259         //找下一个人
 260         head = head->next;
 261         if (head->num != 0)
 262         {
 263             printf("没有退出的人为:%d\n", head->num);
 264             break;
 265         }
 266     }
 267     system("pause");
 268     return 0;
 269 }
 270 
 271 
 272 
 273 //删除单项动态链表
 274 typedef struct node
 275 {
 276     int num;
 277     struct node* next;
 278 }node;
 279 //创建链表:一个含有N个节点的单向链表,返回头节点的指针
 280 node* Creat(int n)
 281 {
 282     //创建一个头节点
 283     node* head = (node*)malloc(sizeof(node));
 284     head->num = 0;
 285     head->next = NULL;
 286     node* p = head;
 287     //创建数据为1-N的节点
 288     for (int i = 1; i <= n; ++i)
 289     {
 290         node* newNode = (node*)malloc(sizeof(node));
 291         newNode->num = i;
 292         newNode->next = NULL;
 293         p -> next = newNode;
 294         p = p->next;
 295     }
 296     return head;
 297 }
 298 //打印链表数据
 299 void PrintNote(node* next)
 300 {
 301     //第一个数据为head->next
 302     node* p = head->next;
 303     while (p != NULL)
 304     {
 305         printf("node %d\n", p->num);
 306         p = p->next;
 307     }
 308 }
 309 void Del(node* head, int val)
 310 {
 311     node* prev = head;
 312     node* p = head->next;
 313     //遍历链表,找到需要的删除的节点
 314     while (p != NULL)
 315     {
 316         if (p->num == val)
 317         {
 318             prev->next = p->next;
 319             free(p);
 320             break;
 321         }
 322         else
 323         {
 324             prev = p;
 325             p = p->next;
 326         }
 327     }
 328 }
 329 int main()
 330 {
 331     node* head = Creat(10);
 332     int n;
 333     printf("当前所有链表的所有节点:>\n");
 334     PrintNode(head);
 335     printf("请输入需要删除的节点编号:\n");
 336     scanf("%d", &n);
 337     //删除之后链表的节点
 338     printf("删除之后链表的节点:>\n");
 339     Del(head, n);
 340     system("pause");
 341     return 0;
 342 }
 343 
 344 
 345 
 346 //定义节点
 347 typedef struct node
 348 {
 349     int num;
 350     struct node* next;
 351 }node;
 352 void Insert(node* node, int n)
 353 {
 354     //创建节点
 355     node* newNode = (node*)malloc(sizeof(node));
 356     newNode->num = n;
 357     //连接
 358     newNode->next = node->next;
 359     p->next = newNode;
 360 }
 361 node* Creat(int n)
 362 {
 363     //创建含有N个有效数据的节点
 364     //创建一个带头的链表
 365     node* head = (node*)malloc(sizeof(node));
 366     head->num = 0;
 367     head->next = NULL;
 368     node* p = head;
 369     //创建有效数据的节点
 370     for (int i = 1; i <= n; ++i)
 371     {
 372         node* newNode = (node*)malloc(sizeof(node));
 373         newNode->num = i;
 374         newNode->next = NULL;
 375         p->next = newNode;
 376         p = p->next;
 377     }
 378     return head;
 379 }
 380 void PrintNode(node* head)
 381 {
 382     //从第一个有效数据开始打印
 383     node* p = head->next;
 384     while (p != NULL)
 385     {
 386         printf("node:%d\n", p->num);
 387         p = p->next;
 388     }
 389 }
 390 int main()
 391 {
 392     int n;
 393     node* head = Creat(10);
 394     printf("未插入数据之前的链表:>\n");
 395     PrintfNode(head);
 396     printf("请输入需要插入的数据:>\n");
 397     scanf("%d", &n);
 398     Insert(head, n);
 399     printf("插入数据之后的链表结构:>\n");
 400     PrintNode(head);
 401     system("pause");
 402     return 0;
 403 }
 404 
 405 
 406 //定义节点
 407 typedef struct node
 408 {
 409     int num;
 410     struct node* next;
 411 }node;
 412 //创建链表:从控制台输入数据
 413 node* Creat()
 414 {
 415     //先创建一个头节点,不存放有效数据
 416     node* head = (node*)malloc(sizeof(node));
 417     head->next = NULL;
 418     head->num = 0;
 419     node* p = head;
 420     printf("创建一个含有%d个数据的单链表", CNT);
 421     printf("请输入%d个数据", CNT);
 422     for (int i = 0; i < CNT; ++i)
 423     {
 424         int n;
 425         scanf("%d", &n);
 426         node* newNode = (node*)malloc(sizeof(node));
 427         newNode->num = n;
 428         newNode->next = NULL;
 429         //链表
 430         p->next = newNode;
 431         p = p->next;
 432     }
 433     return head;
 434 }
 435 //打印链表
 436 void PrintNode(node* head)
 437 {
 438     node* p = head->next;
 439     while (p != NULL)
 440     {
 441         printf("node:%d\n", p->num);
 442         p = p->next;
 443     }
 444 }
 445 //删除节点
 446 void Del(node* head, int val)
 447 {
 448     //遍历链表,找到待删除的位置
 449     node* p = head->next;
 450     node* prev = head;
 451     while (p != NULL)
 452     {
 453         if (p->num == val)
 454         {
 455             prev->next = p->next;
 456             free(p);
 457             break;
 458         }
 459         else{
 460             prev = p;
 461             p = p->next;
 462         }
 463     }
 464 }
 465 //插入节点
 466 void Insert(node* p, int val)
 467 {
 468     node* newNode = (node*)malloc(sizeof(node));
 469     newNode->num = val;
 470     newNode->next = p->next;
 471     p->next = newNode;
 472 }
 473 int main()
 474 {
 475     printf("创建链表:\n");
 476     node* head = Cread();
 477     printf("创建链表结束:\n");
 478     printf("初始链表:\n");
 479     PrintNode(head);
 480     printf("请输入需要查询的链表:\n");
 481     int n;
 482     scanf("%d", &n);
 483     Insert(head, n);
 484     printf("插入数据之后,链表的所有数据:\n");
 485     PrintNode(head);
 486     printf("请输入要要删除的数据:\n");
 487     scanf("%d", &n);
 488     Del(head, n);
 489     printf("删除数据 %d 之后,链表的所有数据:\n",n);
 490     PrintNode(head);
 491     system("pause");
 492     return 0;
 493 }
 494 
 495 
 496 
 497 //定义结构体
 498 #define NUM 5
 499 typedef struct node
 500 {
 501     int num;
 502     float score;
 503     struct node* next;
 504 }node;
 505 node* creat()
 506 {
 507     printf("请输入%d个数据:学号 成绩\n", NUM, 5);
 508     node* head = NULL;
 509     for (int i = 0; i < NUM; ++i)
 510     {
 511         int num;
 512         float score;
 513         scanf("%d %f", &num, &score);
 514         //创建节点
 515         node* newNode = (node*)malloc(sizeof(node));
 516         newNode->num = num;
 517         newNode->score = score;
 518         newNode->next = NULL;
 519         //插入到已有的链表
 520         //判断当前是否为链表
 521         if (head == NULL)
 522         {
 523             head = tail = newNode;
 524         }
 525         else{
 526             //把新的节点插入到尾节点后面
 527             tail->next = newNode;
 528             tail = newNode;
 529         }
 530     }
 531     return head;
 532 }
 533 //合并排序两个链表
 534 node* MergeList(node* a, node* b)
 535 {
 536     //合并 把b链表连接到a的最后一个节点
 537     node* head = a;
 538     while (head->next != NULL)
 539     {
 540         head = head->next;
 541     }
 542     head->next = b;
 543     head = a;
 544     node* prev = a
 545     //排序、选择排序
 546     while (prev->next != NULL)
 547     {
 548         //每次从未排序的节点中,选择一个学号最小的
 549         //放在第一个未排序节点的位置
 550         node* cur = prev->next;
 551         while (cur)
 552         {
 553             if (prev->num->cur->num)
 554             {
 555                 //把学号小的数据往前移动
 556                 int num = prev->num;
 557                 float score = prev->score;
 558 
 559                 prev->num = cur->num;
 560                 prev->score = cur->score;
 561 
 562                 cur->num = num;
 563                 cur->score = score;
 564             }
 565             cur = cur->next;
 566         }
 567         prev = prev->next;
 568     }
 569     return head;
 570 }
 571 void PrintNode(node* a)
 572 {
 573     while (a != NULL)
 574     {
 575         printf("学号:%d 成绩 %f", a->num, a->score);
 576         a = a->next;
 577     }
 578 }
 579 int main()
 580 {
 581     node* a = creat();
 582     node* b = creat();
 583     printf("链表a的数据:\n");
 584     PrintNode(a);
 585     printf("链表b的数据:\n");
 586     PrintNode(b);
 587     printf("合并a和b");
 588     a = mergeList(a, b);
 589     PrintNode(a);
 590     system("pause");
 591     return 0;
 592 }
 593 
 594 
 595 
 596 #define LEN 20
 597 typedef struct node
 598 {
 599     int num;
 600     char name[LEN];
 601     struct node* next;
 602 }node;
 603 node* del(node* a, node* b)
 604 {
 605     node* head = a;
 606     //遍历b中的每一个节点
 607     while (b)
 608     {
 609         //从a的表头开始遍历
 610         node* prev = a;
 611         node* cur = prev->next;
 612         //用头节点和b当前指向的节点进行比较
 613         if (prev->num == b->num)
 614         {
 615             prev->next = NULL;
 616             //更新表头
 617             head = cur;
 618         }
 619         //用非头节点和b当前指向的节点进行比较
 620         else{
 621             while (cur)
 622             {
 623                 if (cur->num == b->num)
 624                 {
 625                     //删除当前节点
 626                     prev->next = cur->next;
 627                     cur->next = NULL;
 628                     break;
 629                 }
 630                 else{
 631                     //继续向后遍历
 632                     prev = cur;
 633                     cur = cur->next;
 634                 }
 635             }
 636         }
 637         //处理b的下一个节点
 638         b = b->next;
 639     }
 640     return head;
 641 }
 642 void printNode(node* head)
 643 {
 644     while (head)
 645     {
 646         printf("%d-->%s\n", head->num, head->name);
 647         head = head->next;
 648     }
 649 }
 650 int main()
 651 {
 652     //建立链表
 653     node a[5] = { { 3, "zhao" }, { 4, "li" }, { 15, "wang" }, { 10, "chen" }, { 8, "ren" } };
 654     node b[3] = { { 8, "ren" }, { 3, "zhang" }, { 12, "wang" } };
 655     for (int i = 0; i < 5; ++i)
 656     {
 657         a[i].next = &a[i + 1];
 658     }
 659     a[4].next = NULL;
 660     for (int i = 0; i < 3; ++i)
 661     {
 662         b[i].next = &b[i + 1];
 663     }
 664     b[2].next = NULL;
 665     printf("链表a:\n");
 666     printNode(a);
 667     printf("链表b:\n");
 668     printNode(b);
 669     //删除操作
 670     node* head = del(a, b);
 671     printf("删除之后的链表:\n");
 672     printNode(head);
 673     system("pause");
 674     return 0;
 675 }
 676 
 677 
 678 
 679 #define LEN 20
 680 typedef struct node
 681 {
 682     int num;
 683     char name[LEN];
 684     char gender[LEN];
 685     int age;
 686     struct node* next;
 687 }node;
 688 node* del(node* a)
 689 {
 690     int age;
 691     printf("请输入需要删除的年龄:\n");
 692     scanf("%d", &age);
 693     //遍历删除
 694     node* prev = NULL;
 695     node* next;
 696     node* cur = a;
 697     node* head = a;
 698     while (cur)
 699     {
 700         if (cur->age == age)
 701         {
 702             //当前节点需要删除
 703             //头节点
 704             if (prev == NULL)
 705             {
 706                 //更新头节点
 707                 head = cur->next;
 708             }
 709             //非头节点
 710             else{
 711                 prev->next = cur->next;
 712             }
 713             //查看下一个节点
 714             cur = cur->next;
 715         }
 716         else{
 717             //当前节点不需要删除
 718             prev = cur;
 719             cur = cur->next;
 720         }
 721     }
 722 }
 723 void printNode(node* head)
 724 {
 725     while (head)
 726     {
 727         printf("%d %s %s %d\n", head->num, head->name, head->gender, head->age);
 728         head = head->next;
 729     }
 730     return head;
 731 }
 732 int main()
 733 {
 734     node arr[] = { { 1, "wang", "male",15 }, { 2, "zhang", "female",20 }, { 3, "li", "male",21 }, { 4, "chen", "male",22 }, { 5, "cheng", "male",23 } };
 735     //建立链表
 736     for (int i = 0; i < 5; ++i)
 737     {
 738         arr[i].next = &arr[i + 1];
 739     }
 740     arr[4].next = NULL;
 741     printf("链表的所有数据:\n");
 742     printNode(arr);
 743     node* head = del(arr);
 744     printf("删除之后链表的剩余数据:\n");
 745     printNode(head);
 746     system("pause");
 747     return 0;
 748 }
 749 
 750 
 751 int main()
 752 {
 753     int a = 0, b = 0, c = 0;
 754     c = (c -= a - 5);
 755     (a = b, b += 4);
 756     printf("%d %d %d\n", a, b, c);
 757     system("pause");
 758     return 0;
 759 }
 760 
 761 int main()
 762 {
 763     int a;
 764     scanf("%d", &a);
 765     if (a++ < 9) printf("%d\n", a);
 766     else printf("%d\n", a--);
 767     system("pause");
 768     return 0;
 769 }
 770 
 771 int main()
 772 {
 773     int a = 0, n;
 774     for (n = 0; n < 3; n++)
 775     {
 776         switch (a)
 777         {
 778         case 0:;
 779         case 1:a += 1;
 780         case 2:a += 2; break;
 781         case 3:a += 3;
 782         default:a += 4;
 783         }
 784         printf("%d,", a);
 785     }
 786     system("pause");
 787     return 0;
 788 }
 789 
 790 
 791 int main()
 792 {
 793     for (int k = -1; k < 0; k++)
 794     {
 795         printf("*****\n");
 796     }
 797     system("pause");
 798     return 0;
 799 }
 800 
 801 
 802 
 803 int main()
 804 {
 805     char a[20], b[20], c[20];
 806     scanf("%s%s", a, b);
 807     gets(c);
 808     printf("%s%s%s", a, b, c);
 809     system("pause");
 810     return 0;
 811 }
 812 
 813 void fun(char c)
 814 {
 815     if (c > 'x') fun(c - 1);
 816     printf("%c", c);//xyz
 817 }
 818 int main()
 819 {
 820     fun('z');
 821     system("pause");
 822     return 0;
 823 }
 824 
 825 struct stu
 826 {
 827     int num;
 828     char name[10];
 829     int age;
 830 };
 831 void fun(struct stu *p)
 832 {
 833     printf("%s\n", p->name);
 834 }
 835 int main()
 836 {
 837     struct stu x[3] = { { 01, "zhang", 20 }, { 02, "wang", 19 }, { 03, "zhao", 18 } };
 838     fun(x + 2);
 839     system("pause");
 840     return 0;
 841 }
 842 
 843 int main()
 844 {
 845     int a = 12, c;
 846     c = (a << 2) << 1;
 847     printf("%d\n", c);
 848     system("pause");
 849     return 0;
 850 }
 851 
 852 int main()
 853 {
 854     int x = 12, y = 8, z;
 855     z = 0.9 + x / y;
 856     printf("%d\n", z);
 857     system("pause");
 858     return 0;
 859 }
 860 
 861 int main()
 862 {
 863     int a = 1, b = 0;
 864     if (--a) b++;
 865     else if (a == 0) b += 2;
 866     else b += 3;
 867     printf("%d\n", b);
 868     system("pause");
 869     return 0;
 870 }
 871 
 872 int main()
 873 {
 874     int a = 7;
 875     while (a--)
 876     {
 877         ;
 878     }
 879     printf("%d\n", a);
 880     system("pause");
 881     return 0;
 882 }
 883 
 884 int main()
 885 {
 886     char *s = { "abc" };
 887     do{
 888         printf("%d", *s % 10);
 889         ++s;
 890     } while (*s);
 891     system("pause");
 892     return 0;
 893 }
 894 
 895 double f(double x)
 896 {
 897     return x*x + 1;
 898 }
 899 int main()
 900 {
 901     double a = 0; int i;
 902     for (i = 0; i < 30; i += 10)
 903     {
 904         a += f((double)i);
 905     }
 906     printf("%5.0f\n", a);
 907     system("pause");
 908     return 0;
 909 }
 910 
 911 void fun(int *p)
 912 {
 913     printf("%d\n", p[5]);
 914 }
 915 int main()
 916 {
 917     int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
 918     fun(&a[3]);//从地址3开始往后数5个
 919     system("pause");
 920     return 0;
 921 }
 922 
 923 
 924 #define N 4
 925 void fun(int a[][N], int b[])
 926 {
 927     int i;
 928     for (i = 0; i < N; i++)
 929     {
 930         b[i] = a[i][i] - a[i][N - 1 - i];
 931     }
 932 }
 933 int main()
 934 {
 935     int x[N][N] = { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 }, { 13, 14, 15, 16 } };
 936     int y[N];
 937     int i;
 938     fun(x, y);
 939     for (i = 0; i < N; i++)
 940     {
 941         printf("%d,", y[i]);
 942         printf("\n");
 943     }
 944     system("pause");
 945     return 0;
 946 }
 947 
 948 
 949 int main()
 950 {
 951     char a[5][10] = { "china", "beijing", "you", "tiananmen", "welcome" };
 952     int i, j;
 953     char t[10];
 954     for (i = 0; i < 4; i++)
 955     {
 956         for (j = i + 1; i < 5; j++)
 957         {
 958             if (strcmp(a[i], a[j])>0)
 959             {
 960                 strcpy(t, a[i]);
 961                 strcpy(a[i], a[j]);
 962                 strcpy(a[j], t);
 963             }
 964         }
 965     }
 966     puts(a[3]);
 967     system("pause");
 968     return 0;
 969 }
 970 
 971 int f(int m)
 972 {
 973     static int n = 0;
 974     n += m;
 975     return m;
 976 }
 977 int main()
 978 {
 979     int n = 0;
 980     printf("%d,", f(++n));
 981     printf("%d\n", f(n++));
 982     system("pause");
 983     return 0;
 984 }
 985 
 986 int main()
 987 {
 988     char ch[3][5] = { "AAAA", "BBB", "CC" };
 989     printf("%s\n", ch[1]);
 990     system("pause");
 991     return 0;
 992 }
 993 
 994 
 995 void fun(char *w, int m)
 996 {
 997     char s, *p1, *p2;
 998     p1 = w;
 999     p2 = w + m - 1;
1000     while (p1 < p2)
1001     {
1002         s = *p1;
1003         *p1 = *p2;
1004         *p2 = s;
1005 
1006         p1++;
1007         p2--;
1008     }
1009 }
1010 int main()
1011 {
1012     char a[] = "123456";
1013     fun(a, strlen(a));//654321
1014     puts(a);
1015     system("pause");
1016     return 0;
1017 }
1018 
1019 int main()
1020 {
1021     struct node
1022     {
1023         int n;
1024         struct node *next;
1025     }*p;
1026     struct node x[3] = { { 2, x + 1 }, { 4, x + 2 }, { 6, NULL } };
1027     p = x;
1028     printf("%d ", p->n);
1029     printf("%d\n", p->next->n);
1030     system("pause");
1031     return 0;
1032 }
1033 
1034 int main()
1035 {
1036     FILE *fp;
1037     int k, n, i, a[6] = { 1, 2, 3, 4, 5, 6 };
1038     fp = fopen("d2.dat", "w");
1039     for (i = 0; i < 6; i++)
1040     {
1041         fprintf(fp, "%d\n", a[i]);
1042     }
1043     fclose(fp);
1044     for (i = 0; i < 3; i++)
1045     {
1046         fscanf(fp, "%d%d", &k, &n);
1047     }
1048     fclose(fp);
1049     printf("%d\n,%d\n", k, n);
1050     system("pause");
1051     return 0;
1052 }

 

posted @ 2022-03-24 21:55  小团熙  阅读(25)  评论(0)    收藏  举报