精华内容
下载资源
问答
  • MergeSort

    2021-01-04 08:59:30
    这个人的mergesort写的特别好,如果你某一天失记忘了mergesort的原理,可以来这里瞧瞧:失忆点这里 以下代码供参考 void sort(vecotr<int> a) { if(a.empty||a.size()==1)return; mergesort(a,0,a.size()-1)...

    前言

    mergesort核心思想特别简单,实现也不复杂。
    这个人的mergesort相关写的特别好,如果你某一天失忆忘了mergesort的原理,可以来这里瞧瞧:失忆点这里

    以下代码供参考

    void sort(vector<int> &a)
    {
    	if (a.empty() || a.size() == 1)return;
    	mergesort(a, 0, a.size() - 1);
    }
    void mergesort(vector<int> &a, int b, int e)
    {
    	if (b >= e)return;
    	int m = b + (e - b) / 2;
    	mergesort(a, b, m);
    	mergesort(a, m + 1, e);
    	merge(a, b, e, m); 
    }
    void merge(vector<int>& a, int b, int e, int m)
    {
    	vector<int> t;
    	for (int i = b; i <= e; i++)t.push_back(a[i]);
    	int i = b; int j = m + 1; int r = b; 
    	while (i <= m && j <= e)
    	{
    		if (t[i - b] >= t[j - b])
    		{
    			a[r] = t[i - b]; i++; r++;
    		}
    		else
    		{
    			a[r] = t[j - b]; j++; r++;
    		}
    	}
    	if (i <= m)
    	{
    		while (i <= m) { a[r] = t[i - b]; i++; r++; }
    	}
    	else
    	{
    		while (j <= e) { a[r] = t[j - b]; j++; r++; }
    	}
    }
    
    展开全文
  • Mergesort

    2019-03-16 17:43:43
    Mergesort 是建立在归并操作上的一种有效的排序算法, 该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。 将已有序的子序列合并,得到完全有序的序列; 即先使每个子序列有序,再使子序列段间有序。 ...

    Mergesort
    是建立在归并操作上的一种有效的排序算法,
    该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。
    将已有序的子序列合并,得到完全有序的序列;
    即先使每个子序列有序,再使子序列段间有序。
    若将两个有序表合并成一个有序表,称为二路归并。

    import java.util.Arrays;
    public class MergeSort {
    
    	public static void main(String[] args) {
    		int[] arr = {1,7,10,9,5,2,17,8,4,0};
    		mergeSort(arr, 0, arr.length-1);
    		System.out.println(Arrays.toString(arr));
    	}
    	/**
    	 * 该方法是将数组分成两边比较,
    	 * low到mind mid+1到high各为一组,边遍历边比较,
    	 * 将小者放入临时数组中,完成数组的升序
    	 * @param arr	需要排序的数组
    	 * @param low	数组的起始位(低位)
    	 * @param middle	数组的中间位置
    	 * @param high	数组的末尾(高位)
    	 */
    	public static void merge(int[] arr,int low,int middle,int high) {
    		int[] temp = new int[high-low+1];	//临时数组大小应为low到high的范围
    		int i = low;						//i从低位开始遍历
    		int j = middle+1;					//j从mid+1开始遍历
    		int index = 0;						//index作为临时数组temp的索引
    		while(i<=middle && j<=high) {		//i和j在各自范围内遍历
    			if(arr[i]<=arr[j]) {			//比较的最小值取出放入临时数组中
    				temp[index++] = arr[i];
    				i++;
    			}else {
    				temp[index++] = arr[j];
    				j++;
    			}
    		}
    		while(i<=middle) {		//此处当某一边元素取完,将另一边剩余元素放入temp
    			temp[index++] = arr[i];
    			i++;
    		}
    		while(j<=high) {
    			temp[index++] = arr[j];
    			j++;
    		}
    		for(int k=0;k<temp.length;k++) {
    			arr[low+k] = temp[k];
    		}
    	}
    	
    	public static void mergeSort(int[] arr,int low,int high) {
    		int middle = (high+low)/2;
    		if(low<high) {	//将数组拆分成两边,进行递归
    						//需要将数组每一块拆成足够小
    			mergeSort(arr,low,middle);
    			mergeSort(arr,middle+1,high);
    			merge(arr,low,middle,high);
    		}
    	}
    }
    
    展开全文
  • mergesort

    2019-03-01 15:54:00
    class Solution { public int[] mergeSort(int[] arr){ if(arr.length<2||arr == null) return arr; return MSort(arr,0,arr.length-1); } public int[] M...
    class Solution {
        public int[] mergeSort(int[] arr){
            if(arr.length<2||arr == null)
                return arr;   
            return MSort(arr,0,arr.length-1);
        }
    
        public int[] MSort(int[] arr, int low, int high){
                if(low < high){
                        int mid = (low+high)/2;
                        int[] left = MSort(arr,low,mid);
                        int[] right = MSort(arr,mid+1,high);
                        return mergeTwoList(left,right);
                  }  
                  return new int[]{arr[low]};
        }
    
        public int[] mergeTwoList(int[] A, int[] B) {
            int[] C = new int[A.length + B.length];
            int k = 0;
            int i = 0;
            int j = 0;
            while(i < A.length && j < B.length) {
                if (A[i] < B[j])
                    C[k++] = A[i++];
                else
                    C[k++] = B[j++];
            }
            while (i < A.length) 
                C[k++] = A[i++];
            while (j < B.length) 
                C[k++] = B[j++];
            return C;
        }
    }

     

    转载于:https://www.cnblogs.com/yanhowever/p/10456864.html

    展开全文
  • mergeSort

    2014-08-15 20:27:00
    1 package POJ; 2 3 public class Main { 4 5 /** 6 * 7 * MergeSort 8 * 9 */ 10 public static void main(String[] args) { 11 Main so = new Main...
     1 package POJ;
     2 
     3 public class Main {
     4 
     5     /**
     6      * 
     7      * MergeSort
     8      * 
     9      */
    10     public static void main(String[] args) {
    11         Main so = new Main();
    12         int[] list = { 6, 4, 2, 3, 1, 5, 10, 4, 9, 8, 11, 7 };
    13         int[] result = so.mergeSort(list);
    14         for (int a : result)
    15             System.out.println(a);
    16     }
    17 
    18     public int[] mergeSort(int[] list) {
    19         int[] helper = new int[list.length];
    20         mergeSort(list, helper, 0, list.length - 1);
    21         return list;
    22     }
    23 
    24     private void mergeSort(int[] list, int[] helper, int low, int high) {
    25         // TODO Auto-generated method stub
    26         if (low < high) {
    27             int mid = (high + low) / 2;
    28             mergeSort(list, helper, low, mid);
    29             mergeSort(list, helper, mid + 1, high);
    30             merge(list, helper, low, mid, high);
    31         }
    32     }
    33 
    34     private void merge(int[] list, int[] helper, int low, int mid, int high) {
    35         // TODO Auto-generated method stub
    36         for (int i = low; i <= high; i++) {
    37             helper[i] = list[i];
    38         }
    39         int helperLeft = low;
    40         int helperRight = mid + 1;
    41         int current = low;
    42         while (helperLeft <= mid && helperRight <= high) {
    43             if (helper[helperLeft] <= helper[helperRight]) {
    44                 list[current] = helper[helperLeft];
    45                 helperLeft++;
    46             } else {
    47                 list[current] = helper[helperRight];
    48                 helperRight++;
    49             }
    50             current++;
    51         }
    52         int remaining = mid - helperLeft;
    53         for (int i = 0; i <= remaining; i++) {
    54             list[current + i] = helper[helperLeft + i];
    55         }
    56     }
    57 }

     

    转载于:https://www.cnblogs.com/Phoebe815/p/3915632.html

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,827
精华内容 1,530
关键字:

mergesort