首页 > 试题广场 >

排序

[编程题]排序
  • 热度指数：316805 时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 256M，其他语言512M
  • 算法知识视频讲解
给定一个长度为 n 的数组，请你编写一个函数，返回该数组按升序排序后的结果。

数据范围： ，数组中每个元素都满足
要求：时间复杂度 ，空间复杂度
进阶：时间复杂度 ，空间复杂度

注：本题数据范围允许绝大部分排序算法，请尝试多种排序算法的实现。
示例1

输入

[5,2,3,1,4]

输出

[1,2,3,4,5]
示例2

输入

[5,1,6,2,5]

输出

[1,2,5,5,6]
算法知识视频讲解
添加回答
Java
不讲武德的芝士很年轻头像 不讲武德的芝士很年轻
import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 将给定数组排序
     * @param arr int整型一维数组 待排序的数组
     * @return int整型一维数组
     */
    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) {       
         Arrays.sort(arr);
        return arr;
    }
}

发表于 2024-05-20 15:24:21 回复(0)
Java
hansonh头像 hansonh 
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 将给定数组排序
     * @param arr int整型一维数组 待排序的数组
     * @return int整型一维数组
     */
    public int[] MySort (int[] arr) {
        // write code here
        boolean needSort = true;
        while (needSort) {
            needSort = false;
            for (int i = 0 ; i < arr.length - 1 ; i++) {
                if (arr[i] > arr[i + 1]) {
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                    needSort = true;
                }
            }
        }

        return arr;
    }

发表于 2023-12-07 15:32:41 回复(0)
Java
求知心态头像 求知心态
//java插入排序 
import java.util.*;


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


发表于 2023-10-29 19:47:37 回复(0)
Java
勤奋的nana头像 勤奋的nana
import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 将给定数组排序
     * @param arr int整型一维数组 待排序的数组
     * @return int整型一维数组
     */
    public int[] MySort (int[] arr) {
        // write code here
        for(int i=0;i<arr.length;i++){
            for(int j=0;j<arr.length;j++){
                if(arr[j]>arr[i]){
                    int temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
        }
        return arr;
    }
}
发表于 2023-06-19 18:13:16 回复(0)
Java
MZFST头像 MZFST 
public int[] MySort (int[] arr) {
        return Arrays.stream(arr).sorted().toArray();
    }
}
好像不太好(doge)
发表于 2023-06-05 17:32:20 回复(1)
Java
台灯亮了（知乎同名）头像 台灯亮了（知乎同名）
import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 将给定数组排序
     * @param arr int整型一维数组 待排序的数组
     * @return int整型一维数组
     */
    public int[] MySort (int[] arr) {
        // write code here
    int temp;
    for(int i=0; i<arr.length-1;i++){
        for(int j=0; j<arr.length-i-1;j++){
            if(arr[j]>arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }  
    return arr;
   
}}
发表于 2023-05-16 16:19:45 回复(0)
Java
SirSir头像 SirSir
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 lt , int rt ) {
        int ld = lt;
        int rd = rt;
        if ( lt >= rt) {
            return ;
        }
        while ( ld < rd) {
            // 从右边往左判断 比分类器大则不动 小则交换
            // 交换后从左边往右判断 比分类器小则不动 大则交换
            while ( arr[rd] > arr[ld] ) {
                rd --;
            }
            swap(arr,ld,rd);
            while ( arr[ld] < arr[rd] ) {
                ld ++;
            }
            swap(arr,ld,rd);
        }
        System.out.println(arr + " "+ lt + " " + ld + " " +rt);
        quickSort(arr,lt,ld - 1);
        quickSort(arr,ld + 1,rt);
    }

    private void swap(int[] arr, int ld, int rd) {
        // TODO
        int temp = arr[ld];
        arr[ld] = arr[rd];
        arr[rd] = temp;
    }

}
发表于 2023-04-20 16:49:39 回复(0)
Java
已注销头像 已注销

快速排序

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[] q,int l,int r){
        if(l>=r) return;
        int i=l-1,j=r+1;
        int x=q[l+(r-l)/2];
        while(i<j){
            do i++; while(q[i]<x);
            do j--; while(q[j]>x);
            if(i<j){
                int t=q[i];
                q[i]=q[j];
                q[j]=t;
            }
        }
        quickSort(q,l,j);
        quickSort(q,j+1,r);
    }
}
发表于 2023-03-14 16:40:37 回复(0)
Java
可为编程头像 可为编程 
import java.util.*;


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

        if (start > end) {
            return;
        }
        int pivot = arr[start];
        int left = start;
        int right = end;
        //start和end就是左右双向指针  start大于end就是比较到中间 指针交换了 就停止循环
        while (left <= right) {
            while (left <= right && pivot > arr[left]) {
                left++;
            }
            while (left <= right && pivot < arr[right]) {
                right--;
            }
            if (left <= right) {
                int tmp = arr[left];
                arr[left] = arr[right];
                arr[right] = tmp;
                left++;
                right--;
            }
        }
        sort(arr, start, right);
        sort(arr, left, end);
    }
}

发表于 2023-02-22 00:12:50 回复(0)
Java
牛客839384289号头像 牛客839384289号 
    public int[] MySort (int[] arr) {
        // write code here
        quickSort(arr,0,arr.length-1);
        return arr;
    }

    public void quickSort(int[] arr ,int start ,int end){
        if(start>=end){
            return;
        }
        int mid=partition(arr,start,end);
        quickSort(arr,start,mid-1);
        quickSort(arr,mid+1,end);
    }

    public int partition(int[] arr ,int start ,int end){
        int mid=arr[start] ,p1=start ,p2=end;
        while(p1<p2){
            while(p1<p2 && arr[p1]<mid){
                p1++;
            }
            while(p1<p2 && arr[p2]>mid){
                p2--;
            }
            int temp=arr[p1];
            arr[p1]=arr[p2];
            arr[p2]=temp;
        }
        return p1;
    }

发表于 2022-11-20 10:31:45 回复(0)
Java
一颗宏心头像 一颗宏心 
public int[] MySort (int[] arr) {
        for(int i = 0;i<arr.length-1;i++){
            int minIndex = i;
            int min = arr[i];
            for(int j=i+1;j<arr.length;j++){
               if(arr[j]<min){
                  min = arr[j];
                  minIndex = j;
               }
            }
            if(minIndex!=i){
                arr[minIndex] = arr[i];
                arr[i] =min;
            }
        }
        return arr;
    }

发表于 2022-11-13 18:01:56 回复(0)
Java
牛客70366231号头像 牛客70366231号
java 快排  
import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 将给定数组排序
     * @param arr int整型一维数组 待排序的数组
     * @return int整型一维数组
     */
    public int[] MySort (int[] arr) {
        // write code here
        int low=0,high=arr.length-1;
        QuickSort(arr,low,high);
        return arr;
    }
    public void QuickSort(int[] arr,int low, int high){
        if(low<high){
            int pivotpos=Partition(arr,low,high);// 分
            QuickSort(arr,low,pivotpos-1);
            QuickSort(arr,pivotpos+1,high);
        }
    }
    private int Partition(int[] arr,int low, int high){
        int pivot=arr[low];
        while(low<high){
            while(low<high&&arr[high]>=pivot)
                --high;
            arr[low]=arr[high];
            while(low<high&&arr[low]<=pivot)
                ++low;
            arr[high]=arr[low];
        }
        arr[low]=pivot;
        return low;
    }
}


发表于 2022-10-21 20:28:30 回复(0)
Java
XuJia028头像 XuJia028
堆排序
第一步，建堆；第二步，堆顶弹出与维护堆，不断地进行，形成排序。

class Solution2{
    /**
     * 堆排序  --- 数组构造完全二叉树 --- arr --- 下标i从0开始,左孩子下标2*i+1,右孩子小标2*i+2 --- (i-1)//2为父节点(i=0是根结点)
     */
    public int[] MySort2(int[] arr){
        heapSort(arr,(x, y)->{return y - x;});
        return arr;
    }
    public void heapSort(int[] arr,Comparator<Integer> comparator){
        if (arr == null || arr.length < 2) return;
        for (int i = 0; i < arr.length; i++) {
            tryUp(arr,i,comparator); // 构建堆
        }
        // 堆 --> 排序 (不断删除堆顶与重构堆的过程 ---> 一个简单方法是堆顶与末尾元素交换,size--,重构堆)
        int size = arr.length;  // 注意 堆顶下标idx = 0, 末尾元素下标tailIdx = size - 1
        while(size > 1){
            int topIdx = 0,tailIdx = size - 1;
            swap(arr,topIdx,tailIdx);
            tryDown(arr,--size,topIdx,comparator);
        }
    }
    public void tryUp(int[] arr,int idx,Comparator<Integer> comparator){ // 从idx到0,从下向上建堆
        int fatherIdx = (idx -1) / 2;  // father >= 0
        while(comparator.compare(arr[fatherIdx],arr[idx]) < 0){
            swap(arr,fatherIdx,idx);
            idx = fatherIdx;
        }
    }

    public void tryDown(int[] arr,int size,int idx,Comparator<Integer> comparator){ // 从idx到size-1, 从上向下建堆

        int leftIdx = 2 * idx + 1;
        while(leftIdx < size){
            int rightIdx = leftIdx + 1;
            int swapIdx = (rightIdx >= size) || comparator.compare(arr[leftIdx],arr[rightIdx]) > 0 ? leftIdx : rightIdx;
            if (comparator.compare(arr[idx],arr[swapIdx]) >= 0)
                break;
            swap(arr,idx,swapIdx);
            idx = swapIdx;
            leftIdx = 2 * idx + 1;
        }

    }
    public void swap(int[] arr,int i,int j){
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}


发表于 2022-09-15 10:45:45 回复(0)
Java
肥咩咪头像 肥咩咪 
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 left,int right){
        int l=left;
        int r=right;
        int pivot=arr[(l+r)/2];
        
        int temp;
        while(l<r){
            while(arr[l]<pivot){
                l+=1;
            }
            while(arr[r]>pivot){
                r-=1;
            }
            if(l>=r){
                break;
            }
            temp=arr[l];
            arr[l]=arr[r];
            arr[r]=temp;
            
            if(arr[l]==pivot){
                r-=1;
            }
            if(arr[r]==pivot){
                l+=1;
            }          
        }
        if(l==r){
            l+=1;
            r-=1;
        }
        if(left<r){
            quickSort(arr,left,r);
        }
        if(right>l){
            quickSort(arr,l,right);
        }
        
    }
}

发表于 2022-09-12 16:45:59 回复(0)
Java
zhongming头像 zhongming 
import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 将给定数组排序
     * @param arr int整型一维数组 待排序的数组
     * @return int整型一维数组
     */
    public int[] MySort (int[] arr) {
        
        // write code here
        //==========================
        //冒泡排序
//         int temp = 0;
//         for(int i=0;i<arr.length-1;i++){
//             for(int j=0;j<arr.length-i-1;j++){
//                 if(arr[j]>arr[j+1]){
//                     temp = arr[j];
//                     arr[j] = arr[j+1];
//                     arr[j+1] = temp;
//                 }
//             }
//         }
//         return arr;
        //==========================
        //冒泡改进版
//         int len = arr.length;
//         while(len>0){
//             for(int i=0;i<len-1;i++){
//                 int next = i+1;
//                 if(arr[i]>arr[next]){
//                     int temp = arr[i];
//                     arr[i] = arr[next];
//                     arr[next] = temp;
//                 }
//             }
//             len--;
//         }
//         return arr;
        //==========================
        //快速排序
//         quicksort(arr,0,arr.length-1);
//         return arr;
        //==========================
        //选择排序
//             for(int i=0;i<arr.length;i++){
//                 int minIndex = i;
//                 for(int j=i;j<arr.length;j++){
//                     if(arr[j]<arr[minIndex]){
//                         minIndex = j;
//                     }
//                 }
//                 int temp = arr[i];
//                 arr[i] = arr[minIndex];
//                 arr[minIndex] = temp;
//             }
//         return arr;
        //==========================
        //插入排序
//         int current;
//         for(int i=0;i<arr.length-1;i++){
//             //拿出第一个未排序数（待插入数）
//             current = arr[i+1];
//             //设置最后一个已排序位置
//             int preIndex = i;
//             //依次对比拿出来的数，如果此数比待插入大，
//             //就往后移动一位（第一次循环会覆盖current的位置）
//             while(preIndex>=0 && current<arr[preIndex]){
//                 //往右移动
//                 arr[preIndex+1] = arr[preIndex];
//                 //待插入数位置往左移动
//                 preIndex--;
//             }
//             //当遇到比待插入数小的数时候停止循环，此时preIndex已经向左移动了，
//             //+1移动回来到空位，插入
//             arr[preIndex+1] = current;
//         }
//         return arr;
        //==========================
        //希尔排序
//         for(int gap=arr.length/2; gap>=1 ;gap/=2){
//             for(int i=0;i<arr.length-gap;i+=gap){
//                 int index = i;
//                 int current = arr[i+gap];
//                 while(index >= 0 && current < arr[index]){
//                     arr[index+gap] = arr[index];
//                     index -= gap;
//                 }
//                 arr[index + gap] = current;
//             }
//         }
        //归并排序调用
//         return sort(arr);
        //堆排序调用
//         sort(arr);
        //计数排序调用
//         return countingSort(arr,getMaxValue(arr));
        
        return bucketSort(arr,100);
//             return arr;
     }
    
    
//------------------------------------------------------------------------------------------
    
    
    
    //==========================
    
    //归并排序
    //归并递归
//     public static int[] sort(int[] arr){
//         if(arr.length<2){
//             return arr;
//         }
//         int middle = (int)Math.floor(arr.length/2);//例2.5-->2
        
//         int[] left = Arrays.copyOfRange(arr,0,middle);
//         int[] right = Arrays.copyOfRange(arr,middle,arr.length);
        
//         return merge(sort(left),sort(right));
//     }
    
//     //合并
//     public static int[] merge(int[] left,int[] right){
//         int[] result = new int[left.length+right.length];
//             int i = 0;
//             //当两组都有数时
//             while(left.length > 0 && right.length > 0){
//                 //如果左边的小，把左边的头数放入结果数组，删除left第一个数，使下一个数变成头数
//                 if(left[0] <= right[0]){
//                     result[i++] = left[0];
//                     left = Arrays.copyOfRange(left,1,left.length);
//                 }else{
//                     result[i++] = right[0];
//                     right = Arrays.copyOfRange(right,1,right.length);
//                 }
//             }
//             //当仅剩左数组有数时
//             while(left.length > 0){
//                 result[i++] = left[0];
//                 left = Arrays.copyOfRange(left,1,left.length);
//             }
//             //同理
//             while(right.length > 0){
//                 result[i++] = right[0];
//                 right = Arrays.copyOfRange(right,1,right.length);
//             }      

//             return result;
//     }
    //==========================
    
    //计数排序（测试数据的数很大，会出现数组越界）
    
//     public int[] countingSort(int[] arr,int maxvalue){
//         int bucketLen = maxvalue + 1;
//         int[] bucket = new int[bucketLen];
        
//         //计数数组
//         for(int value:arr){
//             bucket[value]++;
//         }
        
//         //结果数组待添加的位置
//         int sortedIndex = 0;
//         for(int j=0;j<bucketLen;j++){
//             while(bucket[j]>0){
//                 arr[sortedIndex++] = j;
//                 bucket[j]--;
                
//             }
//         }
//         return arr;
//     }
    
//     public int getMaxValue(int[] arr){
//         int maxvalue = arr[0];
//         for(int value:arr){
//             if(value > maxvalue){
//                 maxvalue = value;
//             }
//         }
//         return maxvalue;
//     }
    //==========================
    //桶排序（对于大数效率还是很低）
//     private int[] bucketSort(int[] arr,int bucketSize){
//         int minvalue = arr[0];
//         int maxvalue = arr[0];
//         for(int value:arr){
//             if (value < minvalue) {
//                 minvalue = value;
//             } else if (value > maxvalue) {
//                 maxvalue = value;
//             }
//         }
//         int bucketCount = (int) Math.floor((maxvalue-minvalue)/bucketSize)+1;
//         int[][] buckets = new int[bucketCount][0];
//         //分配到桶
//         for(int i=0;i<arr.length;i++){
//             int index = (int)Math.floor((arr[i]-minvalue)/bucketSize);
//             buckets[index] = arrAppend(buckets[index],arr[i]);
//         }
//         //装入结果数组
//         int arrIndex = 0;
//         for(int[] bucket:buckets){
//             if(bucket.length<=0){
//                 continue;
//             }
//             //排序单个桶的数据
//             //用希尔排序（原用插入排序）
//             for(int gap=bucket.length/2; gap>=1 ;gap/=2){
//             for(int i=0;i<bucket.length-gap;i+=gap){
//                 int index = i;
//                 int current = bucket[i+gap];
//                 while(index >= 0 && current < bucket[index]){
//                     bucket[index+gap] = bucket[index];
//                     index -= gap;
//                 }
//                 bucket[index + gap] = current;
//             }
//         }
            
            
//             for(int value:bucket){
//                 arr[arrIndex++] = value;
//             }
//         }
//         return arr;
//     }
    
//     //数组扩容插入
//     private int[] arrAppend(int[] arr, int value){
//         arr = Arrays.copyOf(arr,arr.length + 1);
//         arr[arr.length-1] = value;
//         return arr;
//     }
    //==========================
    //堆排序
    
//     public int[] sort(int[] arr){
//         int len = arr.length;
//         buildMaxheap(arr,len);
        
//         for(int i = len -1;i>0;i--){
//             swap(arr,0,i);
//             len--;
//             heapify(arr,0,len);
//         }
//         return arr;
//     }
    
//     //将整个数组整理成大根数
//     public void buildMaxheap(int[] arr,int len){
//         for(int i = (int)Math.floor(len/2);i>=0;i--){
//             heapify(arr,i,len);
//         }
//     }
    
//     //下滤
//     public void heapify(int[] arr,int i,int len){
//         int left = 2*i+1;
//         int right = 2*i+2;
//         int largest = i;
        
//         if(left<len && arr[left]>arr[largest]){
//             largest = left;
//         }
//         if(right<len && arr[right]>arr[largest]){
//             largest = right;
//         }
        
//         if(largest != i){
//             swap(arr,i,largest);
//             heapify(arr,largest,len);
//         }
//     }
    
//     public void swap(int[] arr, int i, int j) {
//         int temp = arr[i];
//         arr[i] = arr[j];
//         arr[j] = temp;
//     }
    
    
    
    
    //==========================
    //快速排序递归方法
//     public static void quicksort(int[] target,int left,int right){
//                 if(left>=right){
//                     return;
//                 }
//                 int pivot = target[left];
//                 int l = left;
//                 int r = right;
//                 while(l < r){
//                     while(target[r] >= pivot && l<r){
//                         r --;
//                     }
//                     target[l] = target[r];
//                     while(target[l]<=pivot && l<r){
//                         l ++;
//                     }
//                     target[r] = target[l];
//                 }
//                 target[l] = pivot;
//                 quicksort(target,left,l-1);
//                 quicksort(target,r+1,right); 
//             }
}

发表于 2022-09-01 20:56:02 回复(0)
Java
真·气死我了头像 真·气死我了
鄙人只用java写了几个排序 
import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 将给定数组排序
     * @param arr int整型一维数组 待排序的数组
     * @return int整型一维数组
     */
    public int[] MySort (int[] arr) {
        // write code here
        /*冒泡查找
        
        int temp=0;
        int i=0,j=0;
        for(;i<arr.length;i++)
            for(j=i+1;j<arr.length;j++)
            {
                if(arr[i]>arr[j])
                {
                    temp=arr[j];
                    arr[j]=arr[i];
                    arr[i]=temp;
                }
            }
        return arr;
        */
        
        /*选择排序
        int i=0,j=0;
        int temp=0,index=0;
        for(i=0;i<arr.length;i++)
        {
            temp=arr[i];
            index=i;
            for(j=i+1;j<arr.length;j++)
                if(arr[j]<temp)
                {
                    temp=arr[j];
                    index=j;
                }
            
            arr[index]=arr[i];
            arr[i]=temp;
        }
        return arr;
        */
        
        
        /*插入排序
        
        int i=0,j=0,k=0;
        int temp=0,index=0;
        
        for(;i<arr.length;i++){
            temp=arr[i];
            index=i;
            for(j=i+1;j<arr.length;j++)
                if(arr[j]<temp)
                {
                    temp=arr[j];
                    index=j;
                }
            for(k=index;k>i;k--)
            {
                arr[k]=arr[k-1];
            }
            arr[i]=temp;
        }
        return arr;
        */   
        
  
        
    }
}


发表于 2022-08-28 13:27:56 回复(0)
Java
周星星lm头像 周星星lm
快速排序： 
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;
    }
    public void quickSort(int[] arr,int l,int r){
        if(l >= r) return;
        int x = arr[l];
        int i = l - 1;
        int j = r + 1;
        while(i < j){
            while(arr[++i] < x);
            while(arr[--j] > x);
            if(i < j) swap(arr,i,j);
        }
        quickSort(arr,l,j);
        quickSort(arr,j + 1,r);
    }
    
    public void swap(int[] arr,int i,int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}


发表于 2022-08-01 09:24:53 回复(0)
Java
BlueProtocol头像 BlueProtocol 
import java.util.*;


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

发表于 2022-07-28 13:41:03 回复(0)
提交观点

问题信息

排序
难度：
93条回答 16101浏览

热门推荐

通过挑战的用户

查看代码

相关试题

排序

扫一扫，把题目装进口袋

求职之前，先上牛客

扫描二维码，进入QQ群

扫描二维码，关注牛客公众号