顺序表应用5：有序顺序表归并

1. 顺序表应用5：有序顺序表归并

   Time Limit: 100MS Memory limit: 800K

   题目描述

   已知顺序表A与B是两个有序的顺序表，其中存放的数据元素皆为普通整型，将A与B表归并为C表，要求C表包含了A、B表里所有元素，并且C表仍然保持有序。

   输入

    输入分为三行：
   第一行输入m、n（1<=m,n<=10000）的值，即为表A、B的元素个数；
   第二行输入m个有序的整数，即为表A的每一个元素；
   第三行输入n个有序的整数，即为表B的每一个元素；

   输出

    输出为一行，即将表A、B合并为表C后，依次输出表C所存放的元素。

   示例输入

   5 31 3 5 6 92 4 10

   示例输出

   1 2 3 4 5 6 9 10

   
   
2. #include <stdio.h>        
3. #include <string.h>        
4. #include <stdlib.h>        
5. #define maxsize 1000000       
6. #define LISTSIZE 100        
7. #define OK 1        
8. #define OVERFLOW -1        
9. typedef int element;        
10. typedef struct        
11. {        
12.     element *elem;        
13.     int length;        
14.     int listsize;        
15. }Sq;        
16. int initList(Sq * L)          
17. {          
18.     L->elem=(element *)malloc(maxsize*sizeof(element));        
19.     if(!L->elem) return -1;      
20.     L->length=0;          
21.     L->listsize=maxsize;          
22.     return 0;          
23. }          
24.           
25. void create(Sq * L,int k)          
26. {          
27.     int i;          
28.     for(i=0;i<k;i++)          
29.       scanf("%d",&L->elem[i]);          
30.         L->length=k;          
31. }          
32.       
33. void display(Sq * L)        
34. {        
35.     int i;        
36.     for(i=0;i<L->length-1;i++)        
37.     {        
38.         printf("%d ",L->elem[i]);        
39.     }        
40.     printf("%d\n",L->elem[i]);        
41. }        
42. void change(Sq *L,Sq *L1,Sq *L2)      
43. {      
44.     int k=L->length +L1->length;      
45.     int i=0,t,g=0,j=0;        
46.     initList(L2); //Ã�¥ï¿½ï¿½Ã�Â¥Ã�§ï¿½Ã�¥ï¿½ï¿½      
47.       
48.     while(i<L->length&&j<L1->length)      
49.     {      
50.          if(L->elem[i]<L1->elem[j])      
51.          {      
52.              L2->elem[g++] = L->elem[i];      
53.              i++;      
54.          }      
55.         else      
56.         {      
57.               L2->elem[g++] = L1->elem[j];      
58.               j++;      
59.          }      
60.     }      
61.           
62.          while(i<=L->elem[i])      
63.          {      
64.              L2->elem[g++] = L->elem[i];      
65.              i++;      
66.          }      
67.          while(j<=L1->elem[j])      
68.          {      
69.               L2->elem[g++] = L1->elem[j];      
70.               j++;      
71.          }      
72.           
73.     L2->length = L1->length + L->length;      
74. }      
75. int main()        
76. {        
77.     Sq L,L1,L2;        
78.     int n,i,m,x;        
79.     scanf("%d%d",&m,&x);  //Ã�¨Ã�¾ï¿½Ã�¥ï¿½Ã�Â¥      
80.       
81.     initList(&L);//Ã�¥ï¿½ï¿½Ã�Â¥Ã�§ï¿½Ã�¥ï¿½ï¿½      
82.     initList(&L1);       
83.       
84.     create(&L,m);  //Ã�¥ï¿½ï¿½Ã�Â¥Ã�»Ã�ºÃ�¨Ã�¡Ã�¨      
85.     create(&L1,x);       
86.       
87.     change(&L,&L1,&L2);//Ã�¥ï¿½ï¿½Ã�Â¥Ã�¹Ã�¶      
88.     display(&L2);//Ã�¨Ã�¾ï¿½Ã�¥ï¿½Ã�º      
89.           
90.        
91.     return 0;        
92. }      
93.