MergeSort分治实现代码(java)

package coretext;

public class MergeSort {

    public static void main(String[] args) {
        int []arr = {2,5,3,6,8,4,9,1};
        MergeText a =new MergeText();
        int [] array =a.MS(arr, 8);
        for(int i=0;i<8;i++) {
            System.out.println(array[i]);
        }
    }

}
class MergeText{
    //归并排序
    public int[] MS(int A[],int n) {
        MSort(A,A,0,n-1);
        return A;
    }
    //把一个数组分解成两个分段
    public void MSort(int A[],int B[],int s,int t){
        if(s==t) {
            B[s]=A[s];
        }
        else {
            int n;
            n=(s+t)/2;
            int [] C= new int[100];
            MSort(A,C,s,n);
            MSort(A,C,n+1,t);
            merge(C,B,s,n,t);
        }


    }
    //把两个分段合并成一个数组
    public void merge(int A[],int B[],int i,int m,int n) {
        int j,k; //k即是用来遍历A的又是来标记B
        for(j=m+1,k=i;i<=m && j<=n;k++) {
            if(A[i]<A[j])
                B[k]=A[i++];
            else
                B[k]=A[j++];
        }
        if(i<=m) {
            while(i<=m)
                B[k++]=A[i++];
            }
        if(j<=n) {
            while(j<=n)
                B[k++]=A[j++];
            }
    }
}

测试结果为:
12345689.

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 常见的排序方法包括:冒泡排序、快速排序、插入排序、选择排序、堆排序、希尔排序等。Java实现代码可以参考:http://www.cnblogs.com/java-my-life/archive/2012/05/16/2502240.html 。 ### 回答2: 常见的排序方法有冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序和堆排序。以下是这些排序方法的Java实现代码。 1. 冒泡排序: ```java public static void bubbleSort(int[] arr) { int n = arr.length; for (int i = 0; i < n-1; i++) { for (int j = 0; j < n-i-1; j++) { if (arr[j] > arr[j+1]) { // 交换arr[j]和arr[j+1] int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } } } } ``` 2. 选择排序: ```java public static void selectionSort(int[] arr) { int n = arr.length; for (int i = 0; i < n-1; i++) { int minIndex = i; for (int j = i+1; j < n; j++) { if (arr[j] < arr[minIndex]) { minIndex = j; } } // 交换arr[i]和arr[minIndex] int temp = arr[i]; arr[i] = arr[minIndex]; arr[minIndex] = temp; } } ``` 3. 插入排序: ```java public static void insertionSort(int[] arr) { int n = arr.length; for (int i = 1; i < n; i++) { int key = arr[i]; int j = i - 1; while (j >= 0 && arr[j] > key) { arr[j+1] = arr[j]; j--; } arr[j+1] = key; } } ``` 4. 希尔排序: ```java public static void shellSort(int[] arr) { int n = arr.length; for (int gap = n/2; gap > 0; gap /= 2) { for (int i = gap; i < n; i++) { int key = arr[i]; int j = i; while (j >= gap && arr[j-gap] > key) { arr[j] = arr[j - gap]; j -= gap; } arr[j] = key; } } } ``` 5. 归并排序: ```java public static void mergeSort(int[] arr, int left, int right) { if (left < right) { int mid = (left + right) / 2; mergeSort(arr, left, mid); mergeSort(arr, mid + 1, right); merge(arr, left, mid, right); } } public static void merge(int[] arr, int left, int mid, int right) { int n1 = mid - left + 1; int n2 = right - mid; int[] L = new int[n1]; int[] R = new int[n2]; for (int i = 0; i < n1; ++i) { L[i] = arr[left + i]; } for (int j = 0; j < n2; ++j) { R[j] = arr[mid + 1 + j]; } int i = 0, j = 0; int k = left; while (i < n1 && j < n2) { if (L[i] <= R[j]) { arr[k] = L[i]; i++; } else { arr[k] = R[j]; j++; } k++; } while (i < n1) { arr[k] = L[i]; i++; k++; } while (j < n2) { arr[k] = R[j]; j++; k++; } } ``` 6. 快速排序: ```java public static void quickSort(int[] arr, int low, int high) { if (low < high) { int pi = partition(arr, low, high); quickSort(arr, low, pi - 1); quickSort(arr, pi + 1, high); } } public static int partition(int[] arr, int low, int high) { int pivot = arr[high]; int i = low - 1; for (int j = low; j < high; j++) { if (arr[j] < pivot) { i++; int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } int temp = arr[i+1]; arr[i+1] = arr[high]; arr[high] = temp; return i+1; } ``` 7. 堆排序: ```java public static void heapSort(int[] arr) { int n = arr.length; for (int i = n / 2 - 1; i >= 0; i--) { heapify(arr, n, i); } for (int i = n - 1; i > 0; i--) { int temp = arr[0]; arr[0] = arr[i]; arr[i] = temp; heapify(arr, i, 0); } } public static void heapify(int[] arr, int n, int i) { int largest = i; int left = 2 * i + 1; int right = 2 * i + 2; if (left < n && arr[left] > arr[largest]) { largest = left; } if (right < n && arr[right] > arr[largest]) { largest = right; } if (largest != i) { int temp = arr[i]; arr[i] = arr[largest]; arr[largest] = temp; heapify(arr, n, largest); } } ``` ### 回答3: 常见的排序方法有冒泡排序、选择排序、插入排序、快速排序和归并排序等。 1. 冒泡排序: 冒泡排序是一种比较简单的排序方法,通过相邻元素的比较和交换来实现排序。具体代码实现如下: ```java public static void bubbleSort(int[] arr) { int len = arr.length; for (int i = 0; i < len - 1; i++) { for (int j = 0; j < len - 1 - i; j++) { if (arr[j] > arr[j + 1]) { int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } } ``` 2. 选择排序: 选择排序是每次遍历找到未排序部分的最小元素,并将其放到已排序部分的末尾。具体代码实现如下: ```java public static void selectionSort(int[] arr) { int len = arr.length; for (int i = 0; i < len - 1; i++) { int minIndex = i; for (int j = i + 1; j < len; j++) { if (arr[j] < arr[minIndex]) { minIndex = j; } } if (minIndex != i) { int temp = arr[i]; arr[i] = arr[minIndex]; arr[minIndex] = temp; } } } ``` 3. 插入排序: 插入排序将未排序部分的第一个元素插入到已排序部分的合适位置。具体代码实现如下: ```java public static void insertionSort(int[] arr) { int len = arr.length; for (int i = 1; i < len; i++) { int j = i; int current = arr[i]; while (j > 0 && arr[j - 1] > current) { arr[j] = arr[j - 1]; j--; } arr[j] = current; } } ``` 4. 快速排序: 快速排序是一种分治思想的排序算法,通过选取一个基准元素,将数组划分为左右两个子数组,对子数组进行递归排序。具体代码实现如下: ```java public static void quickSort(int[] arr, int low, int high) { if (low < high) { int partitionIndex = partition(arr, low, high); quickSort(arr, low, partitionIndex - 1); quickSort(arr, partitionIndex + 1, high); } } public static int partition(int[] arr, int low, int high) { int pivot = arr[high]; int i = low - 1; for (int j = low; j < high; j++) { if (arr[j] < pivot) { i++; int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } int temp = arr[i + 1]; arr[i + 1] = arr[high]; arr[high] = temp; return i + 1; } ``` 5. 归并排序: 归并排序是一种将数组拆分为若干个子数组,并对每个子数组进行排序,然后再合并的排序算法。具体代码实现如下: ```java public static void mergeSort(int[] arr, int left, int right) { if (left < right) { int mid = (left + right) / 2; mergeSort(arr, left, mid); mergeSort(arr, mid + 1, right); merge(arr, left, mid, right); } } public static void merge(int[] arr, int left, int mid, int right) { int[] temp = new int[right - left + 1]; int i = left; int j = mid + 1; int k = 0; while (i <= mid && j <= right) { if (arr[i] <= arr[j]) { temp[k] = arr[i]; i++; } else { temp[k] = arr[j]; j++; } k++; } while (i <= mid) { temp[k] = arr[i]; i++; k++; } while (j <= right) { temp[k] = arr[j]; j++; k++; } for (int m = 0; m < temp.length; m++) { arr[left + m] = temp[m]; } } ``` 以上是常见排序方法的Java实现代码。每种排序方法都有其特点和优劣,根据具体场景可以选择合适的排序方法。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值