歸並排序php

⑴ 歸並排序的示例代碼

歸並排序原理
歸並排序具體工作原理如下（假設序列共有n個元素）：
將序列每相鄰兩個數字進行歸並操作（merge)，形成floor(n/2)個序列，排序後每個序列包含兩個元素
將上述序列再次歸並，形成floor(n/4)個序列，每個序列包含四個元素
重復步驟2，直到所有元素排序完畢
示例代碼
Go語言 funcmergeSort(r[]int)[]int{length:=len(r)iflength<=1{returnr}num:=length/2left:=mergeSort(r[:num])right:=mergeSort(r[num:])returnmerge(left,right)}funcmerge(left,right[]int)(result[]int){l,r:=0,0forl<len(left)&&r<len(right){ifleft[l]<right[r]{result=append(result,left[l])l++}else{result=append(result,right[r])r++}}result=append(result,left[l:]...)result=append(result,right[r:]...)return}Java語言 packagealgorithm;publicclassMergeSort{//privatestaticlongsum=0;/***<pre>*二路歸並*原理：將兩個有序表合並和一個有序表*</pre>**@parama*@params*第一個有序表的起始下標*@paramm*第二個有序表的起始下標*@paramt*第二個有序表的結束小標**/privatestaticvoidmerge(int[]a,ints,intm,intt){int[]tmp=newint[t-s+1];inti=s,j=m,k=0;while(i<m&&j<=t){if(a[i]<=a[j]){tmp[k]=a[i];k++;i++;}else{tmp[k]=a[j];j++;k++;}}while(i<m){tmp[k]=a[i];i++;k++;}while(j<=t){tmp[k]=a[j];j++;k++;}System.array(tmp,0,a,s,tmp.length);}/****@parama*@params*@paramlen*每次歸並的有序集合的長度*/publicstaticvoidmergeSort(int[]a,ints,intlen){intsize=a.length;intmid=size/(len<<1);intc=size&((len<<1)-1);//-------歸並到只剩一個有序集合的時候結束演算法-------//if(mid==0)return;//------進行一趟歸並排序-------//for(inti=0;i<mid;++i){s=i*2*len;merge(a,s,s+len,(len<<1)+s-1);}//-------將剩下的數和倒數一個有序集合歸並-------//if(c!=0)merge(a,size-c-2*len,size-c,size-1);//-------遞歸執行下一趟歸並排序------//mergeSort(a,0,2*len);}publicstaticvoidmain(String[]args){int[]a=newint[]{4,3,6,1,2,5};mergeSort(a,0,1);for(inti=0;i<a.length;++i){System.out.print(a[i]+);}}}Python語言 defMergeSort(lists):iflen(lists)<=1:returnlistsnum=int(len(lists)/2)left=MergeSort(lists[:num])right=MergeSort(lists[num:])returnMerge(left,right)defMerge(left,right):r,l=0,0result=[]whilel<len(left)andr<len(right):ifleft[l]<right[r]:result.append(left[l])l+=1else:result.append(right[r])r+=1result+=right[r:]result+=left[l:]returnresultprintMergeSort([1,2,3,4,5,6,7,90,21,23,45])C語言 #include<stdlib.h>#include<stdio.h>voidMerge(intsourceArr[],inttempArr[],intstartIndex,intmidIndex,intendIndex){inti=startIndex,j=midIndex+1,k=startIndex;while(i!=midIndex+1&&j!=endIndex+1){if(sourceArr[i]>=sourceArr[j])tempArr[k++]=sourceArr[j++];elsetempArr[k++]=sourceArr[i++];}while(i!=midIndex+1)tempArr[k++]=sourceArr[i++];while(j!=endIndex+1)tempArr[k++]=sourceArr[j++];for(i=startIndex;i<=endIndex;i++)sourceArr[i]=tempArr[i];}//內部使用遞歸voidMergeSort(intsourceArr[],inttempArr[],intstartIndex,intendIndex){intmidIndex;if(startIndex<endIndex){midIndex=(startIndex+endIndex)/2;MergeSort(sourceArr,tempArr,startIndex,midIndex);MergeSort(sourceArr,tempArr,midIndex+1,endIndex);Merge(sourceArr,tempArr,startIndex,midIndex,endIndex);}}intmain(intargc,char*argv[]){inta[8]={50,10,20,30,70,40,80,60};inti,b[8];MergeSort(a,b,0,7);for(i=0;i<8;i++)printf(%d,a[i]);printf( );return0;}php語言 //merge函數將指定的兩個有序數組(arr1arr2,)合並並且排序//我們可以找到第三個數組,然後依次從兩個數組的開始取數據哪個數據小就先取哪個的,然後刪除掉剛剛取過///的數據functional_merge($arrA,$arrB){$arrC=array();while(count($arrA)&&count($arrB)){//這里不斷的判斷哪個值小,就將小的值給到arrC,但是到最後肯定要剩下幾個值,//不是剩下arrA裡面的就是剩下arrB裡面的而且這幾個有序的值,肯定比arrC裡面所有的值都大所以使用$arrC[]=$arrA['0']<$arrB['0']?array_shift($arrA):array_shift($arrB);}returnarray_merge($arrC,$arrA,$arrB);}//歸並排序主程序functional_merge_sort($arr){$len=count($arr);if($len<=1)return$arr;//遞歸結束條件,到達這步的時候,數組就只剩下一個元素了,也就是分離了數組$mid=intval($len/2);//取數組中間$left_arr=array_slice($arr,0,$mid);//拆分數組0-mid這部分給左邊left_arr$right_arr=array_slice($arr,$mid);//拆分數組mid-末尾這部分給右邊right_arr$left_arr=al_merge_sort($left_arr);//左邊拆分完後開始遞歸合並往上走$right_arr=al_merge_sort($right_arr);//右邊拆分完畢開始遞歸往上走$arr=al_merge($left_arr,$right_arr);//合並兩個數組,繼續遞歸return$arr;}$arr=array(12,5,4,7,8,3,4,2,6,4,9);print_r(al_merge_sort($arr));Pascal語言 programmergesort_1;constmaxn=7;typearr=array[1..maxn]ofinteger;vara,b,c:arr;i:integer;proceremerge(r:arr;l,m,n:integer;varr2:arr);vari,j,k,p:integer;begini:=l;j:=m+1;k:=l-1;while(i<=m)and(j<=n)dobegink:=k+1;ifr[i]<=r[j]thenbeginr2[k]:=r[i];i:=i+1endelsebeginr2[k]:=r[j];j:=j+1;endend;ifi<=mthenforp:=itomdobegink:=k+1;r2[k]:=r[p];end;ifj<=nthenforp:=jtondobegink:=k+1;r2[k]:=r[p];end;end;proceremergesort(varr,r1:arr;s,t:integer);vark:integer;c:arr;beginifs=tthenr1[s]:=r[s]elsebegink:=(s+t)div2;mergesort(r,c,s,k);mergesort(r,c,k+1,t);merge(c,s,k,t,r1)end;end;beginwrite('Enterdata:');fori:=1tomaxndoread(a[i]);mergesort(a,b,1,maxn);fori:=1tomaxndowrite(b[i]:9);writeln;end.//============================================programmergesort_2;constmax=100000;vara,r:array[1..max]oflongint;n,i:longint;proceremsort(s,t:longint);varm,i,j,k:longint;beginifs=tthenexit;m:=(s+t)div2;msort(s,m);msort(m+1,t);i:=s;j:=m+1;k:=s;while(i<=m)and(j<=t)dobeginifa[i]<a[j]thenbeginr[k]:=a[i];inc(i);inc(k);endelsebeginr[k]:=a[j];inc(j);inc(k);end;end;whilei<=mdobeginr[k]:=a[i];inc(i);inc(k);end;whilej<=tdobeginr[k]:=a[j];inc(j);inc(k);end;fori:=stotdoa[i]:=r[i];end;beginreadln(n);fori:=1tondoread(a[i]);msort(1,n);fori:=1tondowriteln(a[i]);end.Basic語言 SubMergeSort(Array()AsInteger,FirstAsInteger,LastAsInteger)DimmidAsInteger=0Iffirst<lastThenmid=(first+last)2MergeSort(Array,first,mid);MergeSort(Array,mid+1,last);Merge(Array,first,mid,last);EndIfEndSub/*以下示例代碼實現了歸並操作。array[]是元素序列，其中從索引p開始到q位置，按照升序排列，同時，從(q+1)到r也已經按照升序排列，merge()函數將把這兩個已經排序好的子序列合並成一個排序序列。結果放到array中。*//***0<=p<=q<r,subarrayarray[p..q]andarray[q+1..r]arealreadysorted.*themerge()functionmergesthetwosub-arraysintoonesortedarray.*/voidMerge(intarray[],intp,intq,intr){inti,k;intbegin1,end1,begin2,end2;int*temp=(int*)malloc((r-p+1)*sizeof(int));begin1=p;end1=q;begin2=q+1;end2=r;k=0;while((begin1<=end1)&&(begin2<=end2)){if(array[begin1]<=array[begin2]){temp[k]=array[begin1];begin1++;}else{temp[k]=array[begin2];begin2++;}k++;}while(begin1<=end1||begin2<=end2){if(begin1<=end1){temp[k++]=array[begin1++];}if(begin2<=end2){temp[k++]=array[begin2++];}}for(i=0;i<=(r-p);i++)array[p+i]=temp[i];free(temp);}JavaScript語言
使用遞歸的代碼如下。優點是描述演算法過程思路清晰，缺點是使用遞歸，mergeSort()函數頻繁地自我調用。長度為n的數組最終會調用mergeSort()函數 2n-1次，這意味著一個長度超過1500的數組會在Firefox上發生棧溢出錯誤。可以考慮使用迭代來實現同樣的功能。 functionmerge(left,right){varresult=[];while(left.length>0&&right.length>0){if(left[0]<right[0]){/*shift()方法用於把數組的第一個元素從其中刪除，並返回第一個元素的值。*/result.push(left.shift());}else{result.push(right.shift());}}returnresult.concat(left).concat(right);}functionmergeSort(items){if(items.length==1){returnitems;}varmiddle=Math.floor(items.length/2),left=items.slice(0,middle),right=items.slice(middle);returnmerge(mergeSort(left),mergeSort(right));}非遞歸演算法（C++） #include<iostream>#include<ctime>#include<cstring>#include<cstdlib>usingnamespacestd;/**將a開頭的長為length的數組和b開頭長為right的數組合並n為數組長度，用於最後一組*/voidMerge(int*data,inta,intb,intlength,intn){intright;if(b+length-1>=n-1)right=n-b;elseright=length;int*temp=newint[length+right];inti=0,j=0;while(i<=length-1&&j<=right-1){if(data[a+i]<=data[b+j]){temp[i+j]=data[a+i];i++;}else{temp[i+j]=data[b+j];j++;}}if(j==right){//a中還有元素，且全都比b中的大,a[i]還未使用memcpy(temp+i+j,data+a+i,(length-i)*sizeof(int));}elseif(i==length){memcpy(temp+i+j,data+b+j,(right-j)*sizeof(int));}memcpy(data+a,temp,(right+length)*sizeof(int));delete[]temp;}voidMergeSort(int*data,intn){intstep=1;while(step<n){for(inti=0;i<=n-step-1;i+=2*step)Merge(data,i,i+step,step,n);//將i和i+step這兩個有序序列進行合並//序列長度為step//當i以後的長度小於或者等於step時，退出step*=2;//在按某一步長歸並序列之後，步長加倍}}intmain(){intn;cin>>n;int*data=newint[n];if(!data)exit(1);intk=n;while(k--){cin>>data[n-k-1];}clock_ts=clock();MergeSort(data,n);clock_te=clock();k=n;while(k--){cout<<data[n-k-1]<<'';}cout<<endl;cout<<thealgorithmused<<e-s<<miliseconds.<<endl;deletedata;return0;}二路歸並
ConstFI='in.txt';FO='out.txt';MaxN=10000;TypeTIndex=Longint;TDat=Array[0..MaxN]OfTIndex;VarN:TIndex;Dat:TDat;Tmp:TDat;ProcereMerge(L,Mid,R:TIndex);VarP1,P2:TIndex;E1,E2:TIndex;P:TIndex;I:TIndex;BeginP1:=L;P2:=Mid+1;P:=L;RepeatIf(Dat[P1]<=Dat[P2])ThenBeginTmp[P]:=Dat[P1];Inc(P1);Inc(P);EndElseBeginTmp[P]:=Dat[P2];Inc(P2);Inc(P);End;Until(P1=Mid+1)Or(P2=R+1);If(P1=Mid+1)ThenBeginE1:=P2;E2:=R;EndElseBeginE1:=P1;E2:=Mid;End;ForI:=E1ToE2DoBeginTmp[P]:=Dat[I];Inc(P);End;End;ProcereSort(L,R:TIndex);VarMid:TIndex=0;BeginMid:=(L+R)Shr1;If(L<Mid)ThenSort(L,Mid);If(Mid+1<R)ThenSort(Mid+1,R);Merge(L,Mid,R);ForMid:=LToRDoDat[Mid]:=Tmp[Mid];End;ProcereInit;VarI:TIndex;BeginFillChar(Dat,SizeOf(Dat),0);Readln(N);ForI:=1ToNDoRead(Dat[I]);End;ProcereMain;BeginSort(1,N);End;ProcereFinal;VarI:TIndex;BeginForI:=1ToNDoWrite(Dat[I],'');Writeln;End;BeginAssign(Input,FI);Assign(Output,FO);Reset(Input);Rewrite(Output);Init;Main;Final;Close(Input);Close(Output);End.
Delphi歸並排序完整源代碼例子： //合並子函數procereTForm1.MergePass(vardatas:arrayofInteger;left,mid,right:Integer);vartmpArr:arrayofInteger;arrLen:Integer;i,k:Integer;begin1,begin2,end1,end2:Integer;beginarrLen:=right-left+1;SetLength(tmpArr,arrLen);begin1:=left;end1:=mid;begin2:=mid+1;end2:=right;k:=0;while((begin1<=end1)and(begin2<=end2))dobeginif(datas[begin1]<datas[begin2])thenbegintmpArr[k]:=datas[begin1];Inc(begin1);endelsebegintmpArr[k]:=datas[begin2];Inc(begin2);end;inc(k);end;while(begin1<=end1)dobegintmpArr[k]:=datas[begin1];Inc(begin1);Inc(k);end;while(begin2<=end2)dobegintmpArr[k]:=datas[begin2];Inc(begin2);Inc(k);end;fori:=0to(right-left)dobegindatas[left+i]:=tmpArr[i];end;end;//排序主函數，left是數組左下標，0開始。right是數組右下標。procereTForm1.MergeSort(vardatas:arrayofInteger;left,right:Integer);varmid:Integer;i:Integer;beginmid:=0;if(left<right)thenbeginmid:=(right+left)div2;showLog('中間索引：'+inttostr(mid));MergeSort(datas,left,mid);MergeSort(datas,mid+1,right);MergePass(datas,left,mid,right);showLog('--->'+getArrayString(datas));//顯示數組中間狀態end;end;//調用方法：procereTForm1.btn1Click(Sender:TObject);varinArr:array[0..9]ofInteger;beginCopyMemory(@inArr[0],@CTabls[0],SizeOf(Integer)*10);showLog('輸入數據：'+getArrayString(inArr));MergeSort(inArr,0,High(inArr));showLog('輸出數據：'+getArrayString(inArr));end;

⑵ php合並兩個數組並排序

select * from A,B order by a.time,a.ip,b.ip

⑶ 3. 用任意一種編程語言（C/C++/Java/C#/VB.NET）寫出任意一種你所知的排序演算法（比如：冒泡排序， 歸並排

#include<stdio.h>
#include<stdlib.h>
void BubbleSort(int a[], const int first, const int last);//冒泡排序
void InsertSort(int a[], const int first, const int last);//插入排序
void SelectSort(int a[], const int first, const int last);//選擇排序
void MergeSort(int a[], const int p, const int r);//合並排序
void QuickSort(int a[],const int p,const int r);//快速排序
void ShellSort(int a[],const int p,const int r,const int dlta[],const int t);//希爾排序
void HeapSort(int a[],const int p, int r); //堆排序
void StoogeSort(int a[],const int p,const int r);//Stooge排序(不用)演算法復雜度沒算清楚

void main()
{
//插入排序演算法
int a[11] = {6,4,5,3,2,1};
int dlta[]={9,5,3,2,1};
//BubbleSort(a,0,5);
//InsertSort(a,0,5);
//SelectSort(a,0,5);
//MergeSort(a,0,5);
//QuickSort(a,0,5);
//ShellSort(a,0,5,dlta,5);
HeapSort(a,0,5);
//StoogeSort(a,0,5);

for(int i=0; i<=5;i++)
{
printf("%d ",a[i]);
}

}

/************************冒泡排序***********************/
void BubbleSort(int a[], int first, int last)
{
//實現對數組a[]中a[first]到a[last]升序的「冒泡」排序
int i,j,temp;
for(i=first; i<=last; i++)
{
for(j=first; j< last-i; j++)
{
if(a[j] > a[j+1])
{
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
}

/************************插入排序***********************/
void InsertSort(int a[], int first, int last)
{
//實現對數組a[]中a[first]到a[last]升序的「插入」排序
//最壞情況為n的平方，，多用於小數組
int i,j,temp;
for(i=first+1; i<=last; i++)
{
temp = a[i];
j = i - 1;
while((j >= 0) && (a[j] > temp))
{
a[j+1] = a[j];
j--;
}
a[j+1] = temp;
}
}

/************************選擇排序***********************/
void SelectSort(int a[], int first, int last)
{
//實現對數組a[]中a[first]到a[last]升序的「選擇」排序
int i, j, temp, num;
for(i=first; i<last; i++)
{
num = i;
for(j=i+1; j<=last; j++)
{
if(a[j] < a[num])
{
num = j;
}
}
if(i != num)
{
temp = a[num];
a[num] = a[i];
a[i] = temp;
}
}
}

/************************合並排序***********************/
void Merge(int a[],const int p,const int q,const int r)
{
//合並排序演算法中的實現合並的子程序
int iLLength,iRLength;
int *L, *R, i, j, k;
iLLength = q - p + 1;
iRLength = r - q;
L = (int *)malloc(iLLength*sizeof(int)); //或者 C++中 new int[iLLength];
R = (int *)malloc(iRLength*sizeof(int)); //或者 C++中 new int[iRLength];
if(L == 0 || R== 0)
{
printf("內存分配失敗！！！");
return;
}
for(i=0; i<iLLength; i++)
{
L[i] = a[p+i];
}
for(j=0; j<iRLength; j++)
{
R[j] = a[q+j+1];
}
i = 0;
j = 0;
for(k=p; k<=r; k++)
{
if((i<iLLength) && (j<iRLength) && (L[i]<=R[j]) || (j == iRLength))
{
a[k] = L[i];
i++;
}
else if(j<iRLength)
{
a[k] = R[j];
j++;
}
}

free(R);free(L);
}
void MergeSort(int a[],const int p,const int r)
{
//合並排序演算法-主程序
//n*lg(n),系數較小
int q;
if(p<r)
{
q = (p+r)/2;
MergeSort(a,p,q);
MergeSort(a,q+1,r);
Merge(a,p,q,r);
}
}

/************************Stooge排序***********************/
void StoogeSort(int a[],const int p,const int r)
{
//Stooge演算法
int temp, k;
if(a[p]>a[r])
{
temp = a[p];
a[p] = a[r];
a[r] = temp;
}
if((p+1) >= r)
{
return;
}
k = (r-p+1)/3;
StoogeSort(a,p,r-k);
StoogeSort(a,p+k,r);
StoogeSort(a,p,r-k);
}

/************************快速排序*********************/
int QuickPartition(int a[],const int p,const int r)
{
//快速排序的(關鍵)分治過程
int temp, x, i, j;
x = a[r];
i = p - 1;
for(j=p; j<r; j++)
{
if(a[j] <= x)
{
i = i + 1;
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
temp = a[i+1];
a[i+1] = a[r];
a[r] = temp;
return (i+1);
}
/*
void QuickSort(int a[],const int p,const int r)
{
//快速排序演算法-主程序
//與下面的「尾遞歸實現方法」比較，缺點：右邊數組的遞歸不是必須的，增加了運行堆棧深度和調用開銷
int q;
if(p < r)
{
q = QuickPartition(a, p, r);
QuickSort(a, p, q-1);
QuickSort(a, q+1, r);
}
}
*/
void QuickSort(int a[],int p,const int r)
{
//快速排序演算法-主程序
//「尾遞歸實現方法」是對上面的快速排序主程序實現的一種優化
//系數較小,常用大數組
int q;
while(p < r)
{
q = QuickPartition(a, p, r);
QuickSort(a, p, q-1);
p = q + 1;
}
}

/************************希爾排序**********************/
void ShellInsert(int a[],const int p,const int r, int dk)
{
//希爾排序演算法的關鍵子程序-插入排序子程序
int i, j, temp;
for(i=p+dk; i<=r; i++)
{
if(a[i] < a[i-dk])
{
temp = a[i];
for(j=i-dk; ((j>=0) && (temp < a[j])); j -= dk)
{
a[j+dk] = a[j];
}
a[j+dk] = temp;
}
}
}

void ShellSort(int a[],const int p,const int r,const int dlta[],const int t)
{
//希爾排序演算法-主程序
//按增量序列dlta[]中的前t個增量，實現對數組a[]中a[p]到a[r]的排序
//dlta[]可能取值如：1,2,3,5,9 dala[k]=2^(t-k+1)-1 其中0<=k<=t<=ld(b-1)
//增量序列的最後一個值必須是1
//增量序列中的值沒有除1以外的因子， 其精確時間復雜度：數學上尚未解決的難題
int k;
for(k=0; k<t; k++)
{
ShellInsert(a,p,r,dlta[k]);
}
}

/************************堆排序***********************/
//堆排序，不如快速排序
//但是可用其來實現「優先順序隊列」
int Parent(int i)
{
return ((i+1)/2-1);
}

int Right(int i)
{
return (2*(i+1)-1);
}

int Left(int i)
{
return (2*(i+1));
}

void Max_Heapify(int a[],const int hplast,const int i)
{
int l, r,largest,temp;
l = Left(i);
r = Right(i);
largest = ((l<=hplast) && (a[l]>a[i])) ? l:i;
if((r<=hplast) && (a[r]>a[largest]))
{
largest = r;
}
if(largest != i)
{
temp = a[i];
a[i] = a[largest];
a[largest] = temp;
Max_Heapify(a,hplast,largest);
}

}

void Build_Max_Heap(int a[],const int p, const int r)
{
int i;
for(i = (p+r)/2; i>=p; i--)
{
Max_Heapify(a,r,i);
}
}

void HeapSort(int a[],const int p, int r)
{
int i,temp;
Build_Max_Heap(a,p,r);
for(i = r; i > p; i--)
{
temp = a[p];
a[p] = a[i];
a[i] = temp;
r -= 1;
Max_Heapify(a,r,0);
}
}

⑷ php面試問題

天啊，看到這些題我都要瘋了，幹了一年的php還沒有想過這些

⑸ C++有哪些比較大小的排序方法

各種排序演算法

排序演算法是一種基本並且常用的演算法。由於實際工作中處理的數量巨大，所以排序演算法
對演算法本身的速度要求很高。
而一般我們所謂的演算法的性能主要是指演算法的復雜度，一般用O方法來表示。在後面我將
給出詳細的說明。

參考資料：http://cn.codeof.com/articles/programming/vc/1011.htm
介紹了主流的7種排法，有基本實現代碼。

一、排序的基本概念

排序：就是將記錄按關鍵字遞增(遞減)的次序排列起來,形成新的有序序列,稱為排序。設n個記錄的序列為{R1,R2,…,Rn},其相應關鍵字序列為{K1,K2,…,Kn},需確定一種排序P1,P2,…,Pn,使其相應的關鍵字滿足遞增(升序),或遞減(降序)的關系:
Kp1 £ Kp2 £ ...£ Kpn
或
Kp1 ³ Kp2 ³ … ³ Kpn

根據排序元素所在位置的不同,排序分: 內排序和外排序。

http://blog.csdn.net/phpme/archive/2006/06/22/820447.aspx

介紹了5種排法，有設計思想。

⑹ c語言 歸並排序

之前寫過一個模版類，這里是部分代碼：
void Merger<T>::sub_Merger(T * array, size_t n)
{
if(n == 1) //~ 遞歸終止
return ;
else if(n == 2) //~ 遞歸終止
{
if( array[0] > array[1] )
{
T tmp = array[0];
array[0] = array[1];
array[1] = tmp;
}
}
else
{
/* 將數組均分為兩部分，分別排好，然後歸並*/
size_t m = n / 2;
//~ 分別排序
sub_Merger(array, m + 1);
sub_Merger(array + m + 1, n - m - 1);
//~ 歸並
size_t i = 0, j = m + 1, k = 0;
memcpy(extra, array, (m + 1)* sizeof(T));
while( i <= m && j < n)
{
array[k++] = extra[i] < array[j] ? extra[i++]:array[j++];
}
while(i <= m)
{
array[k++] = extra[i++];
}
}
}

⑺ php 歸並排序，，對於兩次遞歸調用自身有點不理解，求大神指教，不太明白執行過程

可以考慮把變數名修改一下
$l => $start
$m => $mid
$r => $end
這樣的話兩次調用其實也就是把整個數組先拆分成兩部分，然後這兩部分各自做排序，之後再合並
遞歸處理，如果對代碼邏輯不能直接理解的話，可以考慮從實際數據著手來理解
比如假設數組中只有一個數，程序會怎樣執行，假設數組中只有兩個數，程序會怎樣執行。。。

⑻ 最常見的演算法，用PHP如何實現

1、冒泡排序
functionbubble_sort($arr){
$n=count($arr);
for($i=0;$i<$n-1;$i){
for($j=$i1;$j<$n;$j){
if($arr[$j]<$arr[$i]){
$temp=$arr[$i];
$arr[$i]=$arr[$j];
$arr[$j]=$temp;
}
}
}
return$arr;
}
2、歸並排序
functionMerge(&$arr,$left,$mid,$right){
$i=$left;
$j=$mid1;
$k=0;
$temp=array();
while($i<=$mid&&$j<=$right)
{
if($arr[$i]<=$arr[$j])
$temp[$k]=$arr[$i];
else
$temp[$k]=$arr[$j];
}
while($i<=$mid)
$temp[$k]=$arr[$i];
while($j<=$right)
$temp[$k]=$arr[$j];
for($i=$left,$j=0;$i<=$right;$i,$j)
$arr[$i]=$temp[$j];
}

functionMergeSort(&$arr,$left,$right)
{
if($left<$right)
{
$mid=floor(($left$right)/2);
MergeSort($arr,$left,$mid);
MergeSort($arr,$mid1,$right);
Merge($arr,$left,$mid,$right);
}
}
3、二分查找-遞歸
functionbin_search($arr,$low,$high,$value){
if($low>$high)
returnfalse;
else{
$mid=floor(($low$high)/2);
if($value==$arr[$mid])
return$mid;
elseif($value<$arr[$mid])
returnbin_search($arr,$low,$mid-1,$value);
else
returnbin_search($arr,$mid1,$high,$value);
}
}
4、二分查找-非遞歸
functionbin_search($arr,$low,$high,$value){
while($low<=$high){
$mid=floor(($low$high)/2);
if($value==$arr[$mid])
return$mid;
elseif($value<$arr[$mid])
$high=$mid-1;
else
$low=$mid1;
}
returnfalse;
}
5、快速排序
functionquick_sort($arr){
$n=count($arr);
if($n<=1)
return$arr;
$key=$arr[0];
$left_arr=array();
$right_arr=array();
for($i=1;$i<$n;$i){
if($arr[$i]<=$key)
$left_arr[]=$arr[$i];
else
$right_arr[]=$arr[$i];
}
$left_arr=quick_sort($left_arr);
$right_arr=quick_sort($right_arr);
returnarray_merge($left_arr,array($key),$right_arr);
}
6、選擇排序
functionselect_sort($arr){
$n=count($arr);
for($i=0;$i<$n;$i){
$k=$i;
for($j=$i1;$j<$n;$j){
if($arr[$j]<$arr[$k])
$k=$j;
}
if($k!=$i){
$temp=$arr[$i];
$arr[$i]=$arr[$k];
$arr[$k]=$temp;
}
}
return$arr;
}
7、插入排序
functioninsertSort($arr){
$n=count($arr);
for($i=1;$i<$n;$i){
$tmp=$arr[$i];
$j=$i-1;
while($arr[$j]>$tmp){
$arr[$j1]=$arr[$j];
$arr[$j]=$tmp;
$j--;
if($j<0)
break;
}
}
return$arr;
}

⑼ pascal的數據結構與演算法分類歸納

這是matrix67大牛歸納的
其實你也可以去
http://www.nocow.cn/index.php/NOCOW%E5%9C%B0%E5%9B%BE

去看
時間復雜度（漸近時間復雜度的嚴格定義，NP問題，時間復雜度的分析方法，主定理）
排序演算法（平方排序演算法的應用，Shell排序，快速排序，歸並排序，時間復雜度下界，三種線性時間排序，外部排序）
數論（整除，集合論，關系，素數，進位制，輾轉相除，擴展的輾轉相除，同餘運算，解線性同餘方程，中國剩餘定理）
指針（鏈表，搜索判重，鄰接表，開散列，二叉樹的表示，多叉樹的表示）
按位運算（and，or，xor，shl，shr，一些應用）
圖論（圖論模型的建立，平面圖，歐拉公式與五色定理，求強連通分量，求割點和橋，歐拉迴路，

⑽ 能不能幫我做一個常用排序演算法的設計呢 跪求啊 幫幫忙吧 我對這個一竅不通啊

常用的排序有：
1.直接插入排序
2.希爾排序（最小增量排序）
3.簡單選擇排序
4.堆排序
5.冒泡排序
6.快速排序
7.歸並排序
8.基數排序