归并排序的思想很简单，就是将多个有序序列组合成一个新的有序序列。

对于一个无序的序列，我们可以先两两归并，然后四个四个归并，依次类推直到完成排序。这样的排序方式又称之为二路归并排序。

这里贴了我写的归并排序算法java实现片段，采用了非递归方式：

Java代码 复制代码 收藏代码
  1. protected void sortAlg(int[] ls)
  2. {
  3. int[] tmp = new int[ls.length];
  4. for(int len = 1; len < ls.length;)
  5. {
  6. int unit = len << 1;
  7. for(int i = 0; i < ls.length;)
  8. {
  9. int end = (i + unit >= ls.length) ? ls.length : i + unit;
  10. if(i + len >= ls.length)
  11. {
  12. break;
  13. }
  14. merge(ls, i, i + len - 1, end - 1,tmp);
  15. if(end == ls.length)
  16. {
  17. break;
  18. }
  19. i = i + unit;
  20. }
  21. len = unit;
  22. }
  23.  
  24. }
  25.  
  26. private void merge(int[] ls, int l, int m, int h, int[] tmp)
  27. {
  28. int lp = l;
  29. int hp = m + 1;
  30. int tmpi = 0;
  31. assert tmp.length >= (h-l+1) : "tmp array length more";
  32. while(ls[lp]<=ls[hp] && lp<=m)
  33. {
  34. lp++;
  35. }
  36. int tmpstart = lp;
  37. while(tmpi < tmp.length && !(lp > m || hp > h))
  38. {
  39. if(ls[lp] > ls[hp])
  40. {
  41. tmp[tmpi] = ls[hp];
  42. hp++;
  43. }
  44. else
  45. {
  46. tmp[tmpi] = ls[lp];
  47. lp++;
  48. }
  49. tmpi++;
  50. }
  51. if(hp > h)
  52. {
  53. for(int i = lp; i <= m; i++)
  54. {
  55. tmp[tmpi] = ls[i];
  56. tmpi++;
  57. }
  58. }
  59. for(int i = 0; i < tmpi; i++)
  60. {
  61. ls[tmpstart + i] = tmp[i];
  62. }
  63. }
    protected void sortAlg(int[] ls)
    {
    	int[] tmp = new int[ls.length];
        for(int len = 1; len < ls.length;)
        {
            int unit = len << 1;
            for(int i = 0; i < ls.length;)
            {
                int end = (i + unit >= ls.length) ? ls.length : i + unit;
                if(i + len >= ls.length)
                {
                    break;
                }
                merge(ls, i, i + len - 1, end - 1,tmp);
                if(end == ls.length)
                {
                    break;
                }
                i = i + unit;
            }
            len = unit;
        }

    }

    private void merge(int[] ls, int l, int m, int h, int[] tmp)
    {
        int lp = l;
        int hp = m + 1;
        int tmpi = 0;
        assert tmp.length >= (h-l+1) : "tmp array length more";
    	while(ls[lp]<=ls[hp] && lp<=m)
    	{
    		lp++;
    	}
        int tmpstart = lp;
        while(tmpi < tmp.length && !(lp > m || hp > h))
        {
            if(ls[lp] > ls[hp])
            {
                tmp[tmpi] = ls[hp];
                hp++;
            }
            else
            {
                tmp[tmpi] = ls[lp];
                lp++;
            }
            tmpi++;
        }
        if(hp > h)
        {
            for(int i = lp; i <= m; i++)
            {
                tmp[tmpi] = ls[i];
                tmpi++;
            }
        }
        for(int i = 0; i < tmpi; i++)
        {
            ls[tmpstart + i] = tmp[i];
        }
    }

与快速排序和堆排序相比，归并排序的最大特点是，它是一种稳定的排序算法。