Description 有两个有序数列，数据个数分别为m和n，每个数列中的数均从小到大有序排列。 请把这两个数列合并为一个，输出合并后的数列。 Input 输入数据有两组，每组数据分两行，第1行为两个

/*Description
有两个有序数列，数据个数分别为m和n，每个数列中的数均从小到大有序排列。
请把这两个数列合并为一个，输出合并后的数列。
Input
输入数据有两组，每组数据分两行，第1行为两个正整数m和n（m,n<=10），
第2行有m+n个整数，前m个数属于第1个数列，后n个属于第2个数列，各数列均从小到大
有序。输入保证两个数列中的数任意两个都不相等。
Output
对于每组测试数据，仍然按照从小到大的顺序输出合并后的结果数列，每组结果单独占
一行。数据之间用一个空格分隔。
Sample Input
5 4
1 3 5 7 9 2 4 6 8
6 3
10 15 30 35 36 40 2 20 45
Sample Output
1 2 3 4 5 6 7 8 9
2 10 15 20 30 35 36 40 45*/

#include <stdio.h>
#define N 10
#define M 2

int main()
{
	int a[M][N] = {0};
	int m,n,i,j,k,t;
	
	for(i = 0;i < M;i++)
	{
		scanf("%d %d",&m,&n);
		for(j = 0;j < (m + n);j++)
		{
			scanf("%d",&a[i][j]);
		}
		
		//冒泡排序 
		for(k = 0;k < (m + n - 1);k++)
		{
			for(j = 0;j < (m + n - 1 - i);j++)
			{
				if(a[i][j] > a[i][j + 1])
				{
					t = a[i][j];
					a[i][j] = a[i][j + 1];
					a[i][j + 1] = t;
				 } 
			}
		}
	}
	
	for(i = 0;i < M;i++)
	{
		j = 0;
		while(a[i][j] != 0)
		{
			printf("%d ",a[i][j++]);
		}
		printf("\n");
	}
}

在这里可以复习一下排序，上面用的冒泡排序当记录基本有序或者n值较小的时候，直接插入排序最简单。

//直接插入排序 
		for(k = 1;k <= (m + n - 1);++k)
		{
			if(a[i][k] < a[i][k - 1])
			{
				t = a[i][k];//复制成哨兵 
			    a[i][k] = a[i][k - 1]; 
			    
			    for(j = k - 2;t < a[i][j];--j)
			    a[i][j + 1] = a[i][j];
			    
			    a[i][j + 1] = t;
			}
			
		}

就平均性能而言，快速排序最好，但是在最坏情况下不如堆排序和归并排序

//快速排序
	    t = a[i][0];
	    k = 0;//low 
	    j = m + n - 1;//high 
	    
	    while(k < j)
	    {
	    	while(k < j && a[i][j] >= t)
	    	--j;
	    	a[i][k] = a[i][j];
	    	while(k < j && a[i][k] <= t)
	    	++k;
	    	a[i][j] = a[i][k];	
		}
		a[i][k] = t;

这是一次快速排序，要完成这个题目要进行多次快速排序
如下：

/*Description
有两个有序数列，数据个数分别为m和n，每个数列中的数均从小到大有序排列。
请把这两个数列合并为一个，输出合并后的数列。
Input
输入数据有两组，每组数据分两行，第1行为两个正整数m和n（m,n<=10），
第2行有m+n个整数，前m个数属于第1个数列，后n个属于第2个数列，各数列均从小到大
有序。输入保证两个数列中的数任意两个都不相等。
Output
对于每组测试数据，仍然按照从小到大的顺序输出合并后的结果数列，每组结果单独占
一行。数据之间用一个空格分隔。
Sample Input
5 4
1 3 5 7 9 2 4 6 8
6 3
10 15 30 35 36 40 2 20 45
Sample Output
1 2 3 4 5 6 7 8 9
2 10 15 20 30 35 36 40 45*/

#include <stdio.h>
#define N 10
#define M 2

int QSort(int a[M][N],int i,int low,int high);
int Partition(int a[M][N],int i,int low,int high);

int main()
{
	int a[M][N] = {0};
	int m,n,i,j,k,t;
	
	for(i = 0;i < M;i++)
	{
		scanf("%d %d",&m,&n);
		for(j = 0;j < (m + n);j++)
		{
			scanf("%d",&a[i][j]);
		}
		
		//快速排序
		k = 0;
		j = m + n -1;
		QSort(a,i,k,j);		
    }
	
	for(i = 0;i < M;i++)
	{
		j = 0;
		while(a[i][j] != 0)
		{
			printf("%d ",a[i][j++]);
		}
		printf("\n");
	}
}

int Partition(int a[M][N],int i,int low,int high)
{
	int t;
	t = a[i][low];
	while(low < high)
	    {
	    	while(low < high && a[i][high] >= t)
	    	--high;
	    	a[i][low] = a[i][high];
	    	while(low < high && a[i][low] <= t)
	    	++low;
	    	a[i][high] = a[i][low];	
		}
		a[i][low] = t;
		return low;
}

int QSort(int a[M][N],int i,int low,int high)
{
	int pivotloc;
	if(low < high)
	{
		pivotloc = Partition(a,i,low,high);
		QSort(a,i,low,high - 1);
		QSort(a,i,pivotloc + 1,high); 
	}
 } 

还有简单选择排序，这是最简单的一个排序方式

//简单选择排序 
		for(k = 0;k <= (m + n - 1);++k)
		{
			min = k;
			for(j = k + 1;j < (m + n);j++) 
			{
				if(a[i][j] < a[i][min])
				{
					min = j;
				}
			}
			if(min != k)
			{
				t = a[i][min];
				a[i][min] = a[i][k];
				a[i][k] = t;
			}		
		}

其实我感觉这个题还是用链表做更能体现题意

/*Description
有两个有序数列，数据个数分别为m和n，每个数列中的数均从小到大有序排列。
请把这两个数列合并为一个，输出合并后的数列。
Input
输入数据有两组，每组数据分两行，第1行为两个正整数m和n（m,n<=10），
第2行有m+n个整数，前m个数属于第1个数列，后n个属于第2个数列，各数列均从小到大
有序。输入保证两个数列中的数任意两个都不相等。
Output
对于每组测试数据，仍然按照从小到大的顺序输出合并后的结果数列，每组结果单独占
一行。数据之间用一个空格分隔。
Sample Input
5 4
1 3 5 7 9 2 4 6 8
6 3
10 15 30 35 36 40 2 20 45
Sample Output
1 2 3 4 5 6 7 8 9
2 10 15 20 30 35 36 40 45*/


typedef struct LNum{
	int num;
	struct LNum *next;
}*LinkList,LNum;

#include <stdio.h>
#include <stdlib.h>
#define N 1

int main()
{
	LinkList creat(int m);
	int Sort(LinkList p1,LinkList p2);
	int n,m,i;
	LinkList p1,p2; 
	
	for(i = 0;i < N;i++)
	{
		scanf("%d %d",&m,&n);
		p1 = creat(m); 
		p2 = creat(n);
		Sort(p1,p2);
	}
	
	p1 = p1->next;
	while(p1)
	{
		printf("%d ",p1->num);
		p1 = p1->next;
	}
}

LinkList creat(int m)
{
	int i = 0;
	LinkList head,p,q;
	
	head = (LinkList) malloc(sizeof(LNum));//头结点 
	head->next = NULL;
	
	while(i < m)
	{
		i++;
		p = (LinkList) malloc(sizeof(LNum));
		scanf("%d",&p->num);
		if(i == 1) head->next = p;
		else q->next = p;
		q = p;
	}
	q->next = NULL;
	
	return head;
} 

int Sort(LinkList p1,LinkList p2)
{
	LinkList q1,q2;
	p2 = p2->next;
	q1 = p1->next;
	
	while(p2)
	{
		q2 = p2;
		if(q1->num > q2->num)
		{
			p2 = p2->next;
			q2->next = q1;
			p1->next = q2;
			q1 = p1->next;
			continue;
		}
		
		if((q1->num < q2->num)&&((q1->next->num) > q2->num))
		{
			p2 = p2->next;
		    q2->next = q1->next;
		    q1->next = q2;
		    q1 = p1->next;
		    continue;
		}
		
		if(q1->next == NULL && (q1->num < q2->num))
		{
			p2 = p2->next;
			q1->next = q2;
			q1 = p1->next;
			continue;
		}			
		q1 = q1->next;
	}
}