归并排序模板(Java)

import java.util.Scanner;
import java.io.BufferedInputStream;
class Main{
    static int N = (int) 1e5 + 10,len;
    static int[] q = new int[N],temp = new int[N];
    static void mergeSort(int[] q,int l,int r){
        if(l>=r) return;
        int mid=(l+r)>>1;
        mergeSort(q,l,mid);
        mergeSort(q,mid+1,r);
        int k=0,i=l,j=mid+1;
        while(i<=mid&&j<=r)
            if(q[i]<q[j])temp[k++]=q[i++];
            else temp[k++]=q[j++];
        while(i<=mid) temp[k++]=q[i++];
        while(j<=r)temp[k++]=q[j++];
        for(k=0,i=l;i<=r;++i,++k)
            q[i]=temp[k];
    }

    public static void main(String[] args){
        Scanner sc=new Scanner(new BufferedInputStream(System.in));
        len=sc.nextInt();
        for(int x=0;x<len;++x)
            q[x]=sc.nextInt();
        mergeSort(q,0,len-1);
        for(int x:q)
            System.out.print(x+" ");
    }
}

原文地址:https://www.cnblogs.com/INnoVationv2/p/12432305.html

时间: 2024-07-31 15:29:00

归并排序模板(Java)的相关文章

leecode 归并排序 链表(java)

写了好久,终于写成了.第一次zai leecode错题,题目质量很高,适合面试,与 1.归并排序是稳定的,在java中 Arrays.sort(a);中对于对象的排序就是归并排序.对于原子类型数据使用的是快排. 2.算法复杂度,我们都知道归并排序的最好最坏最差复杂度为nlogn,空间复杂度为n,在链表当中,空间复杂度j降为O(1). 3.写链表的排序 1.分: 使用书上的快慢指针来获得中间节点,分割成2个链表 2.和: 将两个链表合成一个,比较简单 3. 主程序 ListNode lmerge(

归并排序算法--java

归并排序(Merge)是将两个(或两个以上)有序表合并成一个新的有序表,即把待排序序列分为若干个子序列,每个子序列是有序的.然后再把有序子序列合并为整体有序序列. 归并排序是建立在归并操作上的一种有效的排序算法.该算法是采用分治法(Divide and Conquer)的一个非常典型的应用. 将已有序的子序列合并,得到完全有序的序列:即先使每个子序列有序,再使子序列段间有序.若将两个有序表合并成一个有序表,称为2-路归并. 归并排序算法稳定,数组需要O(n)的额外空间,链表需要O(log(n))

排序算法入门之归并排序(java实现)

归并排序是采用分治法的典型应用. 参考<数据结构与算法分析-Java语言描述> 归并排序其实要做两件事: (1)"分解"--将序列每次折半划分. (2)"合并"--合并两个已排序的表. 合并:对于两个输入数组A和B,一个输出数组C,以及3个计数器Actr.Bctr.Cctr,他们的初始置于对应数组的开始端.A[Actr]和B[Bctr]中较小的拷贝到C中的下一个位置,相关的计数器向前推进一步.当两个输入表有一个用完时,则将另一个表中剩余的部分拷贝到C中.

归并排序算法-Java实现

简介: 归并(Merge)排序法是将两个(或两个以上)有序表合并成一个新的有序表,即把待排序序列分为若干个子序列,每个子序列是有序的.然后再把有序子序列合并为整体有序 基本思想: 将一个无序数组,利用递归和分治的方法划分为最小半子集,最终划分为完全二叉树.然后对半子集进行排序并进行递归合并到最后. 复杂度分析: 时间复杂度为O(nlogn)  空间复杂度为O(n+logn)  两两比较,不存在跳跃,因此归并排序是一种稳定的排序算法  归并排序是一种比较占内存,但却效率高且稳定的算法 工作原理 (

排序算法-归并排序(Java)

package com.rao.sort; import java.util.Arrays; /** * @author Srao * @className MergeSort * @date 2019/12/7 10:24 * @package com.rao.sort * @Description 归并排序 */public class MergeSort { /** * 归并排序:递归写法 * @param arr:要排序的数组 * @param left:数组最左边的元素的下标 * @p

递归和迭代两种方式实现归并排序(Java版)

递归版 package MergeSort; import Utils.SortUtils; /** * 归并排序递归版 * @author liguodong */ public class Demo02 { public static void mergeSort(int[] a){ mSort(a, a, 0, a.length-1); } /** * * @param SR为待排序的数据 * @param TR1为排序之后的数据 * @param s * @param t */ publ

归并排序的JAVA实现

转自:http://blog.csdn.net/chenjin_zhong/article/details/6045659 —————————————————————————————————————————————— public class MergeSort { /** * 归并排序 * 简介:将两个(或两个以上)有序表合并成一个新的有序表 即把待排序序列分为若干个子序列,每个子序列是有序的.然后再把有序子序列合并为整体有序序列 * 时间复杂度为O(nlogn) * 稳定排序方式 * @pa

归并排序模板

归并:将两个或两个以上的有序表组合成一个新的有序表. 一般情况不用这种方式排序,只有在将多个有序序列整合成一个有序序列是才会用到归并排序,才能想归并效率体现的最高. 算法描叙: 1.设初始序列含有n个记录,则可看成n个有序的子序列,每个子序列长度为1. 2.两两合并,得到 n/2 个长度为2或1的有序子序列. 3.再两两合并,--如此重复,直至得到一个长度为n的有序序列为止. 个人见解:也就是先将一个无序的序列对半拆分,将拆分后的序列继续拆分,直到拆分成一个元素为一个序列为止,然后在将两个这样的

单向链表的归并排序(Java)

Sort a linked list in O(n log n) time using constant space complexity. 1 package SortList; 2 3 import java.util.Iterator; 4 5 class ListNode { 6 7 int val; 8 ListNode next; 9 ListNode(int val) { 10 this.val = val; 11 } 12 } 13 14 public class Solutio