目录
排序
题目描述
给定一个数组,请你编写一个函数,返回该数组排序后的形式。
示例一
输入
[5,2,3,1,4]
返回值
[1,2,3,4,5]
示例2
输入
[5,1,6,2,5]
返回值
[1,2,5,5,6]
备注:
数组的长度不大于100000,数组中每个数的绝对值不超过
方法一:快速排序
第一个方法我们使用经典的快速排序
import java.util.*;
public class Solution {
public int[] MySort (int[] arr) {
// write code here
arr=QuickSort(arr,0,arr.length-1);
return arr;
}
public static int[] QuickSort(int[] arr,int low,int high){
if(low<high){
int curpos=Partition(arr,low,high);
QuickSort(arr,low,curpos-1);
QuickSort(arr,curpos+1,high);
}
return arr;
}
public static int Partition(int[] arr,int low,int high){
int curPos=low;
int curVal=arr[low];
for (int i = low+1; i <= high; i++) {
if(arr[i]<curVal){
curPos++;//循环结束之后可以找到当前元素在数组中的下标
if(curPos!=i){//将处于右边小于当前元素的数交换到左边
int temp=arr[curPos];
arr[curPos]=arr[i];
arr[i]=temp;
}
}
}
arr[low]=arr[curPos];//将当前元素放置到应位置
arr[curPos]=curVal;
return curPos;
}
}
快排的时间和空间复杂度还是可以的
方法二:堆排序
import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
* 将给定数组排序
* @param arr int整型一维数组 待排序的数组
* @return int整型一维数组
*/
public int[] MySort (int[] arr) {
// write code here
arr=heapSort(arr);
return arr;
}
//堆排序
public static int[] heapSort(int[] arr) {
for (int i = arr.length/2-1; i >= 0; i--) {
adjustHeap(arr,i,arr.length);
}
for (int j = arr.length-1; j >0 ; j--) {
swap(arr,0,j);
adjustHeap(arr,0,j);
}
return arr;
}
//调整堆:arr 待组堆, i 起始结点, length 堆的长度
public static void adjustHeap(int[] arr, int i, int length) {
int temp=arr[i];
for (int k = 2*i+1; k < length; k=2*k+1) {
if(k+1<length && arr[k]<arr[k+1]){
k++;
}
if(arr[k]>temp){
swap(arr,k,i);
i=k;
}else{
break;
}
}
}
public static void swap(int[] arr, int a, int b) {
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
}
堆排序的时间复杂度更好一点
方法三:归并排序
import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
* 将给定数组排序
* @param arr int整型一维数组 待排序的数组
* @return int整型一维数组
*/
public int[] MySort (int[] arr) {
// write code here
arr=MergeSort(arr);
return arr;
}
public static int[] MergeSort(int[] arr){
int[] res=new int[arr.length];
mergeSort(arr,res,0,arr.length-1);
return arr;
}
public static void mergeSort(int[] arr,int[] res,int low,int high){
if(low>=high){
return;
}else{
int mid=(low+high)/2;
mergeSort(arr,res,low,mid);
mergeSort(arr,res,mid+1,high);
merge(arr,res,low,mid,high);
}
}
public static void merge(int[] arr,int[] res,int low,int mid,int high){
for (int i = low; i <= high; i++) {
res[i]=arr[i];
}
int i=low;
int j=mid+1;
int k=low;
while(i<=mid && j<=high) {
if(res[i]>res[j]){
arr[k++]=res[j++];
}else{
arr[k++]=res[i++];
}
}
while(i<=mid){
arr[k++]=res[i++];
}
while(j<=high){
arr[k++]=res[j++];
}
}
}
和堆排序差不多,但是略差点
综合看来,感觉还是堆排序性能更优!