给定一个数组，请你编写一个函数，返回该数组排序后的形式。
冒泡排序
1.将第一个元素与与第二哥元素进行比较，大者后移（换位）
2.再将第二个元素和第三个元素比较，同上
3.直到最大的元素移到末尾
4.再对剩下的n-1个元素按上诉规则排序
import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
* 将给定数组排序
* @param arr int整型一维数组 待排序的数组
* @return int整型一维数组
*/
if(arr.length==0||arr.length==1){
return arr;
}
for(int i =0;i<arr.length;i++){
for(int j=0;j<arr.length-i-1;j++){
if(arr[j]>arr[j+1]){
//交换位置
int tem =arr[j];
arr[j]=arr[j+1];
arr[j+1]=tem;
}
}
}
return arr;
}
}
-
时间复杂度
若原数组本身就是有序的（这是最好情况），仅需n-1次比较就可完成，时间复杂度为O(n）
若是倒序，比较次数为 n-1+n-2+...+1=n(n-1)/2，交换次数和比较次数等值。所以，其时间复杂度为O(n2）
-
空间复杂度：O(1）
快速排序
1.在数组中任意取一个元素作为基准元素（一般选第一个，最好随机选）
2.对待排序的元素进行分区，大于的放在右边，小于的放在左边
3.对两个分区的元素重复以上步骤
基准元素不固定位置解法
import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
* 将给定数组排序
* @param arr int整型一维数组 待排序的数组
* @return int整型一维数组
*/
public int[] MySort (int[] arr) {
quickSort(arr,0,arr.length-1);
return arr;
}
public void quickSort(int[] arr,int left,int right){
if(left<right){
//分割点
int point =getPoint(arr,left,right);
//递归对左半部分进行排序
quickSort(arr,left,point-1);
//递归对右半部分进行排序
quickSort(arr,point+1,right);
}
}
public int getPoint(int[] arr,int left,int right){
int start =arr[left];
while(left<right){
//从前往后找第一个小于基准元素的元素
while(left<right&&arr[right]>start){
right--;
}
//将这个比基准元素小的元素换到前半部分
swap(arr,left,right);
//在从前往后找第一个大于基准元素的元素
while(left<right&&arr[left]>arr[right]){
left++;
}
//将这个比基准元素大的元素换到后半部分
swap(arr,left,right);
}
//返回基准元素所在位置
return start;
}
private void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
基准位置固定解法
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
* 将给定数组排序
* @param arr int整型一维数组 待排序的数组
* @return int整型一维数组
*/
public int[] MySort (int[] arr) {
quickSort( arr,0,arr.length-1);
return arr;
}
public void quickSort(int[] arr,int start,int end){
if(start<end){
int key =arr[start];
int i=start;
for(int j=start+1;j<=end;j++){
if(key>arr[j]){
//先挪前后的位置
swap(arr,j,++i);
}
}
//基准元素放到指定位置
arr[start]=arr[i];
arr[i]=key;
quickSort(arr,start,i-1);
quickSort(arr,i+1,end);
}
}
public void swap(int[] arr,int i,int j){
int tem =arr[i];
arr[i]=arr[j];
arr[j]=tem;
}
}
-
时间复杂度 最优的情况下，复杂度为O(nlogn) 最坏的情况下，复杂度为O(n2)
-
空间复杂度 最优 O(logn) 最坏 O(n)
