数组归并算法

❶ 急求归并排序算法:将有序数组A[0, … , n]和B[0 , … , m]合并(C语言)

int guibing(int *a,int *b,int n,int m,int *s)
{
int i=0,j=0;

while(i<n&&j<m)
{
if(a[i]<b[j])
{
s[i+j]=a[i];
i++;
}
else
{
s[i+j]=b[j];
j++;
}
}
while(i<n)
{
s[i+j]=a[i];
i++;
}
while(j<m)
{
s[i+j]=b[j];
j++;
}

return 1;
}

❷ C语言技术题～整型数组的归并排序～！特急！！！！！！

/*排序函数*/
void Sort( int *p,int n )
{
int i,j,temp;

for( i = 0; i < n; i++ )
{
for( j = i + 1; j < n; j++ )
{
if( *(p+i) < *(p+j) )
{
temp = *(p+i);
*(p+i) = *(p+j);
*(p+j) = temp;
}
}
}
}
/*连接两个数组*/
void Link_data(int *a,int *b,int *c,int len_a,int len_b)
{
int i = 0,j = 0, k = 0;

while( i < len_a &&j < len_b )
{
/*如果A数组中的元素大，放进c中并且指针i向下移动，否则B数组中的元素放进C中，指针j向下移动*/
if( a[i] > b[j] )
{
c[k] = a[i];
k++;
i++;
}
else
{
c[k] = b[j];
j++;
k++;
}
}

/*如果指针i大于数组a的长度，则表示a已经读完，则把b剩余的放进c*/
if( i >= len_a )
{
for( ; j < len_b; j++)
{
c[k] =b[j];
k++;
}
}
/*如果指针j大于数组b的长度，则表示b已经读完，则把a剩余的放进c*/
if( j >= len_b )
{
for(;i < len_a; i++ )
{
c[k] = a[i];
k++;
}
}
}
main()
{
int a[5] = {1,70,3,4,10},
b[5] = {6,7,30,9,-1},
c[10];
clrscr();

Sort(a,5);
Sort(b,5);
Link_data(a,b,c,5,5);

for( i = 0; i < 10; i++ )
{
printf("%d ",c[i]);
}

}

❸ 求算法。有两个排序好的数组，比如啊a，b。把这两个数组合并为1个数组，求出中间值。

好久没写java代码了，下面的代码相当于伪代码，简单描述一下算法吧！
public int merge(int a[], int b[]){
int lengtha = a.length,lengthb = b.length;
int c[] = new array[lengtha + lengthb];
int x = lengtha + lengthb,y = 0;
i = 0;
j = 0;
while(y < x){
if(i < lengtha && j < lengthb){
if(a[i] <= b[j]){
c[y++] = a[i++];
}
else{
c[y++] = b[j++];
}
}
else if(i < lengtha){
c[y++] = a[i++];
}
else{
c[y++] = b[j++];
}
}
return c[y/2];
}

❹ 什么叫归并算法

合并排序（MERGE SORT）是又一类不同的排序方法，合并的含义就是将两个或两个以上的有序数据序列合并成一个新的有序数据序列，因此它又叫归并算法。它的基本思想就是假设数组A有N个元素，那么可以看成数组A是又N个有序的子序列组成，每个子序列的长度为1，然后再两两合并，得到了一个 N/2 个长度为2或1的有序子序列，再两两合并，如此重复，值得得到一个长度为N的有序数据序列为止，这种排序方法称为2—路合并排序。
例如数组A有7个数据，分别是： 49 38 65 97 76 13 27，那么采用归并排序算法的操作过程如图7所示：
初始值 [49] [38] [65] [97] [76] [13] [27]
看成由长度为1的7个子序列组成
第一次合并之后 [38 49] [65 97] [13 76] [27]
看成由长度为1或2的4个子序列组成
第二次合并之后 [38 49 65 97] [13 27 76]
看成由长度为4或3的2个子序列组成
第三次合并之后 [13 27 38 49 65 76 97]
合并算法的核心操作就是将一维数组中前后相邻的两个两个有序序列合并成一个有序序列。合并算法也可以采用递归算法来实现，形式上较为简单,但实用性很差。合并算法的合并次数是一个非常重要的量,根据计算当数组中有3到4个元素时,合并次数是2次,当有5到8个元素时,合并次数是3次,当有9到16个元素时,合并次数是4次，按照这一规律,当有N个子序列时可以推断出合并的次数是X(2 >=N,符合此条件的最小那个X)。
其时间复杂度为：O(nlogn).所需辅助存储空间为：O(n)
归并算法如下：
long merge(long *A,long p,long q,long r)
{
long n1,n2,i,j,k;
long *L,*R;
n1=q-p+1;
n2=r-q;
L=(long *)malloc((n1+2)*sizeof(long));
R=(long *)malloc((n2+2)*sizeof(long));
for(i=1;i<=n1;i++)
L=A[p+i-1];
for(j=1;j<=n2;j++)
R[j]=A[q+j];
L[n1+1]=R[n2+1]=RAND_MAX;
i=j=1;
for(k=p;k<=r;k++)
{
if(L<=R[j])
{
A[k]=L;
i++;
}
else
{
A[k]=R[j];
j++;
}
}
free(L);
free(R);
return 0;
}
long mergesort(long *A,long p,long r)
{
long q;
if(p<r)
{
q=(p+r)/2;
mergesort(A,p,q);
mergesort(A,q+1,r);
merge(A,p,q,r);
}
return 0;
}

❺ 给解析一下这个数组的归并排序算法

len = 1 的第一轮归并： 4 6 1 2 3 5
len = 2 的第二轮归并： 1 2 4 6 3 5
len = 4 的第三轮归并： 1 2 3 4 5 6

以上采用的是二路归并，如果每一段的长度大于2*len，进行二路归并，如果大于len小于2*len，也进行归并。。如果小于len，那么就直接传递进行下一轮的归并

❻ 归并排序算法

两种归并排序算法的实现：二路归并排序和基本归并排序（虚拟消除递归的二路归并排序）
#define ARRAY_SIZE 1024

int B[1024]; //使用一个全局变量，避免归并排序中每次都重新申请和释放空间造成的开销

template <typename T>
void Merge(T A[], int l, int m, int h)
{
int i = l;
int j = m+1;
int k = 0;

while(i<=m&&j<=h)
{
if(A[i]<A[j])
{
B[k++] = A[i];
i++;
}
else
{
B[k++] = A[j];
j++;
}
}

while(i<=m)
{
B[k++] = A[i++];
}

while(j<=h)
{
B[k++] = A[j++];
}

for(i=l; i<=h; i++)
{
A[i] = B[i-l];
}
}

//二路归并排序的实现

template <typename T>
void MergeSort(T a[], int l, int h)
{
int m = (h+l)/2;
if(l>=h)
{
return;
}

if(l+1==h)
{
if(a[l]>a[h])
{
std::swap(a[l], a[h]);
}

return;
}

MergeSort(a, l, m);
MergeSort(a, m+1, h);
Merge(a, l, m, h);
}

//将a经过步长s归并到b中，n表示数组的大小
template <typename T>
void Merge2(T a[], T b[], int s, int n)
{
int m = 0;

//从头至尾按照步长s进行相邻数据的合并
for(int i=0; i<n; i+=2*s)
{
int j = i; //合并的第一组数的起始位置
int k = i+s; //合并的第二组数的起始位置
int jE = i+s; //合并的第一组数的起始位置
int kE = i+2*s; //合并的第二组数的起始位置

while((j<jE)&&(k<kE)&&j<n && k<n)
{
if(a[j]<a[k])
{
b[m++] = a[j];
j++;
}
else
{
b[m++] = a[k];
k++;
}
}

while((j<jE)&&(j<n))
{
b[m++] = a[j++];
}

while((k<kE)&&(k<n))
{
b[m++] = a[k++];
}
}
}

//基本归并排序，虚拟消除递归
template <typename T>
void MergeSort2(T a[], int n)
{
int s = 1; //merge 的步长
T* b = new T[n];

while(s<n)
{
Merge2(a, b, s, n); //由a合并到b
s += s;

Merge2(b, a, s, n); //由b合并到a
s += s;
}

delete[] b;
}

//使用如下代码在VS2005中可以对两种归并排序进行性能比较，

//基本归并排序的时间性能稍微好一点，基本归并排序直接对数据按步长Merge，

//而二路归并排序需要将数据先不断的分层，到为一个或者两个元素时再进行Merge

void main()
{
int * p = new int[ARRAY_SIZE];
int i = 0;

for(i=0; i<ARRAY_SIZE; i++)
{
*(p+i) = rand()%ARRAY_SIZE;
}
MergeSort(p, 0, ARRAY_SIZE-1);

for(i=0; i<ARRAY_SIZE; i++)
{
*(p+i) = rand()%ARRAY_SIZE;
}
MergeSort2(p, ARRAY_SIZE);

delete[] p;
}

❼ 如何将两个随机数组归并为一从小到大排列的数组

合并后用排序算法就可以了啊，排序算法很多的，冒泡法，快速排序法等。

❽ 编写程序:整型数组的归并排序

这种题大致的框架给你，具体的你细想下
void fun(int a[],int b[],int c[])
{
int i=0,j=0,k=0;
while(a没访问结束&&b没访问结束)
{
if(a[i]<b[j])
{
c[k++]=a[i];
j++;
}
else
c[k++]=b[j];
i++
}
if(数组a未访问完毕)
{
将数组a中的剩余元素插入C
}
else if（b未访问完）
{
将数组b中的元素插入C
}
}

❾ 在C语言的数组排序中,归并法又称什么法

在数组中的良好秩序的开始：从小到大，或降序。然后这个数组被妥协，你想找到这个数字，比较大小，（例如，中间的数字：如果我长大了，我会和中间的数字，你正在寻找一些这样的比较的数组，如果小，这个数字就是你想要找的绝对范围在左侧的中间，如果数量大，要找到绝对范围的中间到右边，然后是同样的道理，慢慢慢慢缩小，谁知看远）