归并排序的递归与非递归实现java

package com.edu.hpu.sort.merge;

import com.edu.hpu.sort.Sort;

public class MergeSort extends Sort {

    @Override
    public int[] doSort(int[] arr) {

        return mergeSort2(arr, 0, arr.length - 1);
    }

    @SuppressWarnings("unused")
    private int [] mergeSort(int [] arr, int p, int r){
        if(p < r){
            int q = (p + r) / 2;
            mergeSort(arr, p, q);
            mergeSort(arr, q + 1, r);
            merge(arr, p, q, r);
        }
        return arr;
    }
    // 归并排序非递归
    private int [] mergeSort2(int [] arr, int p, int r){
        int [] res = new int[arr.length];
        int index = 0;
        // 表示每次归并完后有多少个元素无法进行归并
        int last = 0;
        int w = 0;
        // 每次归并的个数
        for(int j = 2; j <= arr.length; j *= 2){
            // 每次将多余的元素,不能进行但不归并的放入另外的辅助数组中去,原数组的长度将去放入的长度。
            for(int i = 0; i < arr.length - last && w < arr.length; i += j){
                if(arr.length - i >= j) {
                    int q = (i + i + j -1) / 2;
                    // 归并
                    merge(arr, i, q, i + j - 1);
                }else{
                    // 对辅助数组的元素进行归并处理
                    index = w;
                    for(int v = i; v < arr.length - index; v++){
                        res[w] = arr[v];
                        //arr[v] = 0;
                        w++;
                        last = w;
                    }
                    // 对辅助数组进行归并
                    res = merge(res, 0, index - 1, w - 1);
                }
            }
        }
        for(int i = 0; i < arr.length - last; i++){
            res[last + i] = arr[i];
        }
        //两个数组归并
        arr = merge(res, 0, last - 1, res.length - 1);
        return arr;
    }
    private int [] merge(int [] arr, int p, int q, int r){
        // 多加一个位置是为了安放一个哨兵
        int [] letf = new int[q - p + 1 + 1];
        int [] right = new int[r - q + 1];
        // 放入哨兵
        letf[letf.length - 1] = Integer.MAX_VALUE;
        right[right.length - 1] = Integer.MAX_VALUE;
        int i = 0, j = 0;
        // 初始化数组
        for( ; i < letf.length - 1; i++){
            letf[i] = arr[p + i];
        }
        for( ; j < right.length - 1; j++){
            right[j] = arr[q + j + 1];
        }
        // 对两个数组进行归并
        i = 0; j = 0;
        for(int k = p; k <= r; k++){
            if(letf[i] < right[j]){
                arr[k] = letf[i];
                i++;
            }else{
                arr[k] = right[j];
                j++;
            }
        }
        return arr;
    }
    public static void main(String[] args) {
        MergeSort mergeSort = new MergeSort();
        mergeSort.printOrder(new int []{90, 4342,89, 0, 8,90,45,8,23,1,0,43242,43,432,54,543,45431,321,8,8,9,1,7,8,777,5});
    }
}
时间: 2024-10-29 19:05:48

归并排序的递归与非递归实现java的相关文章

JAVA递归、非递归遍历二叉树(转)

原文链接: JAVA递归.非递归遍历二叉树 import java.util.Stack; import java.util.HashMap; public class BinTree { private char date; private BinTree lchild; private BinTree rchild; public BinTree(char c) { date = c; } // 先序遍历递归 public static void preOrder(BinTree t) {

Java数据结构系列之——树(4):二叉树的中序遍历的递归与非递归实现

package tree.binarytree; import java.util.Stack; /** * 二叉树的中序遍历:递归与非递归实现 * * @author wl * */ public class BiTreeInOrder { // 中序遍历的递归实现 public static void biTreeInOrderByRecursion(BiTreeNode root) { if (root == null) { return; } biTreeInOrderByRecursi

Java数据结构系列之——树(5):二叉树的后序遍历的递归与非递归实现

package tree.binarytree; import java.util.Stack; /** * 二叉树后序遍历的递归与非递归实现 * * @author wl * */ public class BitreePostOrder { // 后序遍历的递归实现 public static void biTreePostOrderByRecursion(BiTreeNode root) { if (root == null) { return; } biTreePostOrderByRe

算法之归并排序的递归与非递归的实现

一.什么是归并排序 归并排序就是将多个有序的数据段合成一个有序的数据段,如果参与合并的只有两个有序的数据段,则称为二路归并.与快速排序和堆排序相比,其最大的特点是一种稳定的算法,算法的平均时间复杂度O(nlog2n). 二.归并排序的基本思路 (1).对于一个原始的待排序表,可以将R[1]到R[n]可以看做是n个长度为1的有序表,即分解. (2).进行第一趟归并,即将上述的n个子序两两合并,得到 n/2向上取整 个有序表,若n为奇数,则归并到最后一个子序列长度为1,即合并. (3).再将两个 n

数据结构二叉树的递归与非递归遍历之 实现可编译(1)java

前一段时间,学习数据结构的各种算法,概念不难理解,只是被C++的指针给弄的犯糊涂,于是用java,web,javascript,分别去实现数据结构的各种算法. 二叉树的遍历,本分享只是以二叉树中的先序遍历为例进行说明,中序遍历和后序遍历,以此类推! 二叉树递归与非递归遍历的区别,虽然递归遍历,跟容易读懂,代码量少,运算快,但是却容易出现溢出的问题,所以所以非递归遍历,在处理千万级的运算量时会先的很有用处. 二叉树的先序遍历:先访问根节点,再访问先后访问左右节点.如图: 二叉树的递归遍历之java

二叉树三种遍历递归及非递归实现(Java)

import java.util.Stack; //二叉树三种遍历递归及非递归实现(Java) public class Traverse { /******************定义二叉树**************************/ private final int MAX_SIZE = 10; //链式存储 public static class BinaryTreeNode { int mValue; BinaryTreeNode mLeft; BinaryTreeNode

归并排序(递归、非递归、以及自然归并排序)算法总结

注:本文所指归并排序指 二路归并排序. 归并排序是平均情况.最坏情况.最好情况时间复杂度都为O(Nlog2N)的稳定的排序算法.最近梳理了下归并排序的递归.非递归.以及自然归并排序算法. 归并排序的基础:将两个有序数组合并为一个有序数组,需要O(n)的辅助空间. 图片来自:https://www.cnblogs.com/chengxiao/p/6194356.html // array:待排序数组 //temparray: 临时数组 //startindex:起始下标 //middleindex

java扫描文件夹下面的所有文件(递归与非递归实现)

java中扫描指定文件夹下面的所有文件扫描一个文件夹下面的所有文件,因为文件夹的层数没有限制可能多达几十层几百层,通常会采用两种方式来遍历指定文件夹下面的所有文件.递归方式非递归方式(采用队列或者栈实现)下面我就给出两种方式的实现代码,包括了递归与非递归实现,code如下所示. package q.test.filescanner; import java.io.File;import java.util.ArrayList;import java.util.LinkedList; import

二叉树三种遍历(递归以及非递归实现)

package com.shiyeqiang.tree; import java.util.Stack; public class BiTree { public static void main(String[] args) { // 首先构造叶子节点 BiTree leafA1 = new BiTree(4); BiTree leafA2 = new BiTree(5); BiTree leafB1 = new BiTree(6); BiTree leafB2 = new BiTree(7)

二分查找算法(递归与非递归两种方式)

首先说说二分查找法. 二分查找法是对一组有序的数字中进行查找,传递相应的数据,进行比较查找到与原数据相同的数据,查找到了返回1,失败返回对应的数组下标. 采用非递归方式完成二分查找法.java代码如下所示. /* * 非递归二分查找算法 * 参数:整型数组,需要比较的数. */ public static int binarySearch(Integer[]srcArray,int des){ //第一个位置. int low=0; //最高位置.数组长度-1,因为下标是从0开始的. int h