数组排序问题的两种方法：插入排序算法和递归(分治)算法

            在这里我将讨论数组的排序问题，并引入插入排序算法和递归算法求解。

1、插入排序

             这里通过算法导论中的伪代码说明算法过程。

        Insertion-sort(A)

        for(j=2 to A.length)

                  key=A[j]

                  //Insert A[j] into sorted sequence A[1..j-1]

                  i=j-1

                  while(i>0 and A[i]>key)

                           A[i+1]=A[i]

                           i=i-1

                  A[i+1]=key

         //over

         算法说明：

          1）j=2，从数组的第二个元素开始迭代即当前手中的牌只有一张，桌面有A.length-1张牌；

          2）假设j为当前插入的牌。若当前牌A[j]大于手中最大的牌A[i](因为排序好了)，则将其插入(最大牌)前面；

 否则当前牌需要与前面A[1..i]比较，不满足则下移，直到找到满足条件的位置i（A[i]<A[j]）或者牌首(数组下标的边界0)，则将其插入位置(i+1);

        

          按照上述原理，编写测试代码证明其正确性。

// method1:插入排序
void main()
{

	int a[]={3,1,6,10,9,8,14};
	int len=7;
	//cout<<len;
	int i,j;
	int key;

	for (j=1; j<len; j++)
	{
		key=a[j];
		i=j-1;

		while(i>=0 && a[i]>key)
		{

			a[i+1]=a[i];
			i--;
		}
		//find the value of position i is bigger than key
		a[i+1]=key;
	}

	//output the array
	cout<<"array sort is:\n";
	for (i=0; i<len; i++)
	{
		cout<<a[i]<<" ";
	}
	cout<<endl;
}
 

实验结果：

 

2、分治算法

      分治法的思想：将原问题分解成几个规模较小但类似于原问题的子问题，递归求解这些子问题，然后合并这些子问题的解来建立原问题的解。

         归并排序算法：1)将数组分割成2个子数组； 2）对2个子数组进行排序； 3）合并子数组的解得到原始问题的解。其中，合并数组的程序记为Merge(A,p,q,r); 待排序的数组程序记为Merge_sort(A,p,r).

         Merge(A,p,q,r)的伪代码：

              n1=q-p+1;

         n2=r-q;

         let L[1..n1+1] and R[1..n2+1] be new arrays

         for i=1 to n1

               L[i]=A[p+i-1]

         for j=1 to n2

               L[j]=A[q+j]

         L[n1+1]=无穷大

         L[n2+1]=无穷大

         i=1

         j=1

         for k=p to r

               if L[i]<=R[j]

                     A[k]=L[i]

                     i++

               else

                     A[k]=R[j]

                     j++

 

         merge_sort(A,p,r)伪代码

         if p<r

              q=(p+r)/2;

              merge_sort(A,p,q);

              mege_sort(A,q+1,r);

              merge(A,p,q,r);

 

                数组采用归并排序算法的测试程序。

//method2: 递归/分治 
#define  Large_integre 9999999999
void merge_array(int a[],int p, int q, int r)
{
	int i,j;
	int n1=q-p+1;
	int n2=r-q;

	int *a1=(int*)malloc((n1+1)*sizeof(int));
	int *a2=(int*)malloc((n2+1)*sizeof(int));

	for (i=0; i<n1; i++)
	{
		*(a1+i)=a[p+i];
	}
	a1[n1]=Large_integre;
	for (j=0; j<n2; j++)
	{
		*(a2+j)=a[q+1+j];
	}

	a2[n2]=Large_integre;

	i=0;
	j=0;
    for (int k=p; k<=r; k++)
	{
		if (a1[i]<=a2[j])
		{
			a[k]=a1[i];
			i++;
		}
		else
		{
			a[k]=a2[j];
			j++;
		}
	}

	free(a1);
	free(a2);
}

void merge_sort(int a[], int p, int r)
{
	int q;
	if (p<r)
	{
		q=(r+p)/2;
		merge_sort(a,p,q);
		merge_sort(a,q+1,r);
		merge_array(a,p,q,r);

	}
	return;
}

void main()
{
	int i,j;
	int _min,_max;
	int array[]={3,7,19,10,13,9,8,5,66};
	_min=0,_max=8;
	merge_sort(array,_min,_max);

	cout<<" Sort array by recurrence is:\n";
	for (i=0; i<=_max; i++)
	{
		cout<<array[i]<<" ";
	}
	cout<<endl;
}

实验结果：