以往使用的歸併排序都是利用“分而治之”的思想遞迴進行，也就是不斷二分到最小之後遞迴地歸併上來

然而，再引入一個數組就可以進行迭代法的歸併排序

把一個數組A裡的先兩兩排序到另一個數組B裡

再把陣列B裡的資料四個四個排序到A裡，以此類推

程式碼如下：

需要注意的是當j_end超過待排序總數N的時候需要把它置為N-1，不然就會下標越界

還有一個要注意的就是移位運算的優先順序是比雙目運算要低的，剛開始沒注意到這一點死活調不出來

所以乘二還是老老實實乘二，用移位的話裝逼有風險，調了一個小時，血的教訓QAQ

#include <stdio.h>

#define ElementType int
#define MAXN 100

void merge_pass( ElementType list[], ElementType sorted[], int N, int length );

void output( ElementType list[], int N )
{
    int i;
    for (i=0; i<N; i++) printf("%d ", list[i]);
    printf("\n");
}

void  merge_sort( ElementType list[],  int N )
{
    ElementType extra[MAXN];  /* the extra space required */
    int  length = 1;  /* current length of sublist being merged */
    while( length < N ) { 
        merge_pass( list, extra, N, length ); /* merge list into extra */
        output( extra, N );
        length *= 2;
        merge_pass( extra, list, N, length ); /* merge extra back to list */
        output( list, N );
        length *= 2;
    }
} 


int main()
{
    int N, i;
    ElementType A[MAXN];

    scanf("%d", &N);
    for (i=0; i<N; i++) scanf("%d", &A[i]);
    merge_sort(A, N);
    output(A, N);

    return 0;
}

void merge_pass( ElementType list[], ElementType sorted[], int N, int length )
{
	int i_begin = 0, i_end = length - 1, j_begin = length, j_end = (length<<1) - 1, aim;
	while(i_begin < N){
		if(j_end >= N)	j_end = N-1;
		if(i_end >= N)	i_end = N-1;
		aim = i_begin;
		while(i_begin <= i_end && j_begin <= j_end)
			sorted[aim++] = (list[i_begin] < list[j_begin]) ? list[i_begin++] : list[j_begin++];
		while(i_begin <= i_end)
			sorted[aim++] = list[i_begin++];
		while(j_begin <= j_end)
			sorted[aim++] = list[j_begin++];
		i_begin += length;
		j_begin += length;
		i_end += length<<1;
		j_end += length<<1;
	}
}