Merge Sort

package algorithm;

public class MergeSort
{
    public void  merge(Integer[] array, Integer begin,Integer mid ,Integer end)
    {
        Integer[] newArray = new Integer[end + 1];
        Integer sign = 0;
        while(begin <= end/2 && mid < end)
        {
            if(array[begin] < array[mid])
            {
                newArray[sign] = array[begin];
                begin++;
            }
            else
            {
                newArray[sign]= array[mid];
                mid++;
            }
            sign++;
        }
        while(begin <= end/2)
        {
            newArray[sign] = array[begin];
            begin++;
        }
        while(mid < end)
        {
            newArray[sign]= array[mid];
            mid++;
        }
        for(int i = 0; i < end; i++)
        {
            array[i] = newArray[i];
        }
    }

    public void sort(Integer[] array, Integer begin, Integer end)
    {
        if(end - begin > 0)
        {
            Integer mid = (begin + end)/2;
            sort(array,begin,mid);
            sort(array,mid,end);
           merge(array,begin,mid,end);
        }
    }
}
package altest;

import algorithm.MergeSort;

public class AlgorithmTest
{
    public static void main(String[] args)
    {
        MergeSort mergeSort = new MergeSort();
        Integer[] array ={8,2,5,4,7,0,9,1,3,6};
        mergeSort.sort(array,0,10);
        for(Integer i:array)
        {
            System.out.print(array [i] + " ");
        }
    }
}
时间: 2024-10-19 06:03:56

Merge Sort的相关文章

[算法]——归并排序(Merge Sort)

归并排序(Merge Sort)与快速排序思想类似:将待排序数据分成两部分,继续将两个子部分进行递归的归并排序:然后将已经有序的两个子部分进行合并,最终完成排序.其时间复杂度与快速排序均为O(nlogn),但是归并排序除了递归调用间接使用了辅助空间栈,还需要额外的O(n)空间进行临时存储.从此角度归并排序略逊于快速排序,但是归并排序是一种稳定的排序算法,快速排序则不然. 所谓稳定排序,表示对于具有相同值的多个元素,其间的先后顺序保持不变.对于基本数据类型而言,一个排序算法是否稳定,影响很小,但是

排序算法二:归并排序(Merge sort)

归并排序(Merge sort)用到了分治思想,即分-治-合三步,算法平均时间复杂度是o(nlgn). (一)算法实现 1 private void merge_sort(int[] array, int first, int last) { 2 if (first + 1 < last) { 3 int mid = (first + last) / 2; 4 merge_sort(array, first, mid); 5 merge_sort(array, mid, last); 6 7 /

SQL Tuning 基础概述06 - 表的连接方式:Nested Loops Join,Merge Sort Join &amp; Hash Join

nested loops join 嵌套循环 merge sort join 排序合并 hash join 哈希连接 nested loops join(嵌套循环)   驱动表返回几条结果集,被驱动表访问多少次,有驱动顺序,无须排序,无任何限制. 驱动表限制条件有索引,被驱动表连接条件有索引. hints:use_nl() merge sort join(排序合并)   驱动表和被驱动表都是最多访问1次,无驱动顺序,需要排序(SORT_AREA_SIZE),连接条件是<>或like导致无法使用

STL 源码剖析 算法 stl_algo.h -- merge sort

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie merge sort ---------------------------------------------------------------------- 描述:归并排序 思路: 1.将区间对半分割 2.对左.右段分别排序 3.利用inplace_merge将左.右段合并成为一个完整的有序序列 复杂度:O(nlog n) 源码: template<class Bidirection

经典排序算法 - 归并排序Merge sort

经典排序算法 - 归并排序Merge sort 原理,把原始数组分成若干子数组,对每个子数组进行排序, 继续把子数组与子数组合并,合并后仍然有序,直到所有合并完,形成有序的数组 举例 无序数组[6 2 4 1 5 9] 先看一下每一个步骤下的状态,完了再看合并细节 第一步 [6 2 4 1 5 9]原始状态 第二步 [2 6] [1 4] [5 9]两两合并排序,排序细节后边介绍 第三步 [1 2 4 6] [5 9]继续两组两组合并 第四步 [1 2 4 5 6 9]合并完成,排序完成 输出结

1.7 逆序数与归并排序[inversion pairs by merge sort]

[本文链接] http://www.cnblogs.com/hellogiser/p/inversion-pairs-by-merge-sort.html [题目] 编程之美1.7光影切割问题可以进一步将问题转化为求逆序数问题. [分析] 求解逆序对问题与MergeSort类似,只需要对MergeSort稍作修改即可实现.MergeSort是采用分治法的思想,若需要排序A[p...r],则可以对半分成A[p...q]和A[q...r],然后将这有序的两部分Merge,而Merge的过程为Θ(n)

oracle表之间的连接之------&gt;排序合并连接(Merge Sort Join)

排序合并连接 (Sort Merge Join)是一种两个表在做连接时用排序操作(Sort)和合并操作(Merge)来得到连接结果集的连接方法. 对于排序合并连接的优缺点及适用场景如下: a,通常情况下,排序合并连接的执行效率远不如哈希连接,但前者的使用范围更广,因为哈希连接只能用于等值连接条件,而排序合并连接还能用于其他连接条件(如<,<=,>.>=) b,通常情况下,排序合并连接并不适合OLTP类型的系统,其本质原因是对于因为OLTP类型系统而言,排序是非常昂贵的操作,当然,如

Iterative (non-recursive) Merge Sort

An iterative way of writing merge sort: #include <iostream> using namespace std; void merge(int A[], int l, int r, int e, int B[]) { int i = l, j = r, k = l; while (i<r && j<e) { if (A[i] > A[j]) B[k++] = A[j++]; else B[k++] = A[i++

Codeforces 847B - Preparing for Merge Sort

847B - Preparing for Merge Sort 思路:前面的排序的最后一个一定大于后面的排序的最后一个.所以判断要不要开始新的排序只要拿当前值和上一个排序最后一个比较就可以了. 代码: #include<bits/stdc++.h> using namespace std; #define ll long long #define pb push_back #define mem(a,b) memset(a,b,sizeof(a)) const int N=2e5+5; int

Natural Merge Sort(自然归并排序)

This is a Natural Merge Sort program from my textbook. It works, but I don't think it's good. // Natural merge sort program in the textbook public class NaturalMergeSortProgram { public static void main(String[] args) { int a[] = new int[10000000]; i