排序Java

如果你想简单：

import java.util.*;
public class Solution {
    public int[] MySort (int[] arr) {
      Arrays.sort(arr);
      return arr;
    }
}

如果你想归并：

import java.util.*;
public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 将给定数组排序
     * @param arr int整型一维数组 待排序的数组
     * @return int整型一维数组
     */
    public int[] MySort (int[] arr) {
        // write code here
        return sort(arr);
    }

    private int[] sort(int []arr){
        if(arr.length==1)
            return arr;
        else{
            int mid = arr.length/2;
            int temp[]=new int[arr.length];
            int [] left=sort(Arrays.copyOfRange(arr,0,mid));
            int [] right=sort(Arrays.copyOfRange(arr,mid,arr.length));
            int i = 0;
            int j = 0;
            for(int k = 0;k<temp.length;k++){
                if(i<left.length&&j<right.length) {
                    if(left[i]<=right[j]){
                        temp[k]=left[i];
                        i++;
                    }else{
                        temp[k]=right[j];
                        j++;
                    }
                }else if(i<left.length&&j>=right.length){
                    temp[k]=left[i];
                    i++;
                }else if(i>=left.length&&j<right.length){
                    temp[k]=right[j];
                    j++;
                }
            }
            return temp;
        }
    }
}

如果你想快速排序：

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 将给定数组排序
     *
     * @param arr int整型一维数组 待排序的数组
     * @return int整型一维数组
     */
    public int[] MySort(int[] arr) {
        // write code here
        quickSort(arr, 0, arr.length - 1);
        return arr;
    }

    private void quickSort(int[] arr, int start, int end) {
        if (start >= end) {
            return;
        }
        int standard = arr[start];
        int i = start;
        int j = end;
        while (i < j) {
            while (j > i && arr[j] > standard) {
                j--;
            }
            while (i < j && arr[i] <= standard) {
                i++;
            }
            swap(arr, i, j);
        }
        swap(arr, i, start);

        quickSort(arr, start, i - 1);
        quickSort(arr, i + 1, end);
    }

    private void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

如果你想堆排序：

import java.util.*;
//  this message  written by windows 10
// Good luck :)

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 将给定数组排序
     *
     * @param arr int整型一维数组 待排序的数组
     * @return int整型一维数组
     */
    public int[] MySort(int[] arr) {
        // write code here
        if (arr == null || arr.length == 0) return arr;
        heapSort(arr);
        return arr;
    }

    private void heapSort(int[] arr) {
        maxHeap_init(arr);
        for (int i = 0; i < arr.length; i++) {
            swap(arr, 0, arr.length - 1 - i);
            maxHeap(arr, arr.length - 1 - i, 0);
        }
    }

    private void maxHeap(int[] arr, int size, int begin) {
        adjust(arr, size, begin);
    }

    private void maxHeap_init(int arr[]) {
        for (int i = arr.length / 2; i >= 0; i--) {
            adjust(arr, arr.length, i);
        }
    }

    private void adjust(int[] arr, int heapSize, int index) {
        int left = index * 2 + 1;
        int right = index * 2 + 2;
        int biggest_index = index;
        if (left < heapSize && arr[left] > arr[biggest_index]) {
            biggest_index = left;
        }
        if (right < heapSize && arr[right] > arr[biggest_index]) {
            biggest_index = right;
        }
        if (index != biggest_index) {
            swap(arr, index, biggest_index);
            adjust(arr, heapSize, biggest_index);
        }

    }

    private void swap(int[] arr, int i, int j) {

        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}