数据结构：递增排列的数组 union all 算法 2.1

递增排列的数组 union all
假设有2个线性表，递增排列的数组，如
char a[20]="abbcopqtuwz";
char b[20]="bcfgjmtv";
我们需要实现一个union all，将两个字符串中的字符合并到

一个新的线性表c中，其中也是按照递增排列的。
那么按照我们要求输出应该为
abbbccfgjmopqttuvwz


那么算法如下：

点击(此处)折叠或打开

1. #include<stdio.h>
   
2. #include <string.h>
   
3. 
   
4. 
   
5. int main(void)
   
6. {
   
7.         char a[20]="abbcopqtuwz";
   
8.         char b[20]="bcfgjmtv";
   
9. 
   
10.         char c[30];
    
11.         memset(c,0,30);
    
12. 
    
13.         int n=0;
    
14.         int m=0;
    
15.         int h=0;
    
16. 
    
17.         int a_len=strlen(a);
    
18.         int b_len=strlen(b);
    
19. 
    
20.         while(n<a_len && m<b_len)
    
21.         {
    
22.                 if(a[n]< b[m])
    
23.                 {
    
24.                         c[h]=a[n];
    
25.                         n++;
    
26.                 }
    
27.                 else if(a[n]==b[m])
    
28.                 {
    
29.                         c[h]=a[n];
    
30.                         n++;
    
31.                 }
    
32.                 else
    
33.                 {
    
34.                         c[h]=b[m];
    
35.                         m++;
    
36.                 }
    
37.                 h++;
    
38.         }
    
39. 
    
40.         if(a[n] != 0)
    
41.         {
    
42.                 while(n<a_len)
    
43.                 {
    
44.                         c[h]=a[n];
    
45.                         n++;
    
46.                         h++;
    
47.                 }
    
48.         }
    
49. 
    
50.         if(b[m] != 0 )
    
51.         {
    
52.                 while(m<b_len)
    
53.                 {
    
54.                         c[h]=b[m];
    
55.                         m++;
    
56.                         h++;
    
57.                 }
    
58.         }
    
59. 
    
60.   
    
61.         printf("%s\n",c);
    
62. }

运行程序输出为：abbbccfgjmopqttuvwz

可以看到和预期一模一样。
分析这个算法的渐进时间复杂度，实际上我们发现他只是一个单循环，很明显我们原操作只是 c [ h ] = a [ n ] ;这样的复制
所以时间复杂度为：
T(n)=O(n)
但是这样的算法明显依赖于两个数组排序好了的情况

来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/7728585/viewspace-2124893/，如需转载，请注明出处，否则将追究法律责任。

转载于:http://blog.itpub.net/7728585/viewspace-2124893/