网站开发程序用什么好,wordpress外网固定链接,重庆百度快照优化排名,wordpress+html5特效【问题描述】
给你一个整数数组 nums#xff0c;将该数组升序排列。
示例 1#xff1a;
输入#xff1a;nums [5,2,3,1]
输出#xff1a;[1,2,3,5]【解答思路】
1.插入排序#xff08;熟悉#xff09;
每次将一个数字插入一个有序的数组里#xff0c;成为一个长度更…【问题描述】
给你一个整数数组 nums将该数组升序排列。
示例 1
输入nums [5,2,3,1]
输出[1,2,3,5]【解答思路】
1.插入排序熟悉
每次将一个数字插入一个有序的数组里成为一个长度更长的有序数组有限次操作以后数组整体有序。
优化「将一个数字插入一个有序的数组」这一步可以不使用逐步交换使用先赋值给「临时变量」然后「适当的元素」后移空出一个位置最后把「临时变量」赋值给这个空位的策略就是上面那张图的意思。编码的时候如果不小心可能会把数组的值修改建议多调试
时间复杂度O(N^2) 空间复杂度O(1)
public class Solution {// 插入排序稳定排序在接近有序的情况下表现优异public int[] sortArray(int[] nums) {int len nums.length;// 循环不变量将 nums[i] 插入到区间 [0, i) 使之成为有序数组for (int i 1; i len; i) {// 先暂存这个元素然后之前元素逐个后移留出空位int temp nums[i];int j i;// 注意边界 j 0while (j 0 nums[j - 1] temp) {nums[j] nums[j - 1];j--;}nums[j] temp;}return nums;}
}作者liweiwei1419
链接https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/2.归并排序重点
借助额外空间合并两个有序数组得到更长的有序数组。 时间复杂度O(NlogN) 空间复杂度O(N)
优化 1在「小区间」里转向使用「插入排序」Java 源码里面也有类似这种操作「小区间」的长度是个超参数需要测试决定我这里参考了 JDK 源码优化 2 在「两个数组」本身就是有序的情况下无需合并优化 3全程使用一份临时数组进行「合并两个有序数组」的操作避免创建临时数组和销毁的消耗避免计算下标偏移量。注意实现归并排序的时候要特别注意不要把这个算法实现成非稳定排序区别就在 和 已在代码中注明。
public class Solution {// 归并排序/*** 列表大小等于或小于该大小将优先于 mergeSort 使用插入排序*/private static final int INSERTION_SORT_THRESHOLD 7;public int[] sortArray(int[] nums) {int len nums.length;int[] temp new int[len];mergeSort(nums, 0, len - 1, temp);return nums;}/*** 对数组 nums 的子区间 [left, right] 进行归并排序** param nums* param left* param right* param temp 用于合并两个有序数组的辅助数组全局使用一份避免多次创建和销毁*/private void mergeSort(int[] nums, int left, int right, int[] temp) {// 小区间使用插入排序if (right - left INSERTION_SORT_THRESHOLD) {insertionSort(nums, left, right);return;}int mid left (right - left) / 2;// Java 里有更优的写法在 left 和 right 都是大整数时即使溢出结论依然正确// int mid (left right) 1;mergeSort(nums, left, mid, temp);mergeSort(nums, mid 1, right, temp);// 如果数组的这个子区间本身有序无需合并if (nums[mid] nums[mid 1]) {return;}mergeOfTwoSortedArray(nums, left, mid, right, temp);}/*** 对数组 arr 的子区间 [left, right] 使用插入排序** param arr 给定数组* param left 左边界能取到* param right 右边界能取到*/private void insertionSort(int[] arr, int left, int right) {for (int i left 1; i right; i) {int temp arr[i];int j i;while (j left arr[j - 1] temp) {arr[j] arr[j - 1];j--;}arr[j] temp;}}/*** 合并两个有序数组先把值复制到临时数组再合并回去** param nums* param left* param mid [left, mid] 有序[mid 1, right] 有序* param right* param temp 全局使用的临时数组*/private void mergeOfTwoSortedArray(int[] nums, int left, int mid, int right, int[] temp) {//void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)System.arraycopy(nums, left, temp, left, right 1 - left);int i left;int j mid 1;
//两条有序序列合并for (int k left; k right; k) {
//left mid 1
//[1,1,2,3] [5,6,7,8] //边界 左边遍历完 右边还没开始 右边持续插入if (i mid 1) {nums[k] temp[j];
//没能改变值 j;
// [5,6,7,8] [1,1,2,3]
//边界 右边遍历完 左边还没开始 左边持续插入} else if (j right 1) {nums[k] temp[i];i;} else if (temp[i] temp[j]) {// 注意写成 就丢失了稳定性相同元素原来靠前的排序以后依然靠前nums[k] temp[i];i;} else {// temp[i] temp[j]nums[k] temp[j];j;}}}
}作者liweiwei1419
链接https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/
3. 快速排序重点
快速排序每一次都排定一个元素这个元素呆在了它最终应该呆的位置然后递归地去排它左边的部分和右边的部分依次进行下去直到数组有序 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bH18YcEd-1585662450983)(https://upload-images.jianshu.io/upload_images/17025746-9d7d9ff3a2826052.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)]
import java.util.Random;public class Solution {// 快速排序 1基本快速排序/*** 列表大小等于或小于该大小将优先于 quickSort 使用插入排序*/private static final int INSERTION_SORT_THRESHOLD 7;private static final Random RANDOM new Random();public int[] sortArray(int[] nums) {int len nums.length;quickSort(nums, 0, len - 1);return nums;}private void quickSort(int[] nums, int left, int right) {// 小区间使用插入排序if (right - left INSERTION_SORT_THRESHOLD) {insertionSort(nums, left, right);return;}int pIndex partition(nums, left, right);quickSort(nums, left, pIndex - 1);quickSort(nums, pIndex 1, right);}/*** 对数组 nums 的子区间 [left, right] 使用插入排序** param nums 给定数组* param left 左边界能取到* param right 右边界能取到*/private void insertionSort(int[] nums, int left, int right) {for (int i left 1; i right; i) {int temp nums[i];int j i;while (j left nums[j - 1] temp) {nums[j] nums[j - 1];j--;}nums[j] temp;}}//版本 1基本快排把等于切分元素的所有元素分到了数组的同一侧可能会造成递归树倾斜private int partition(int[] nums, int left, int right) {
//避免有序数组 效率低下
随机生成一个整数这个整数的范围就是[0,right - left 1int randomIndex RANDOM.nextInt(right - left 1) left;swap(nums, left, randomIndex);// 基准值int pivot nums[left];int lt left;// 循环不变量// all in [left 1, lt] pivot// all in [lt 1, i) pivotfor (int i left 1; i right; i) {if (nums[i] pivot) {lt;swap(nums, i, lt);}}swap(nums, left, lt);return lt;}
//版本 2双指针快排把等于切分元素的所有元素等概率地分到了数组的两侧避免了递归树倾斜递归树相对平衡private int partition(int[] nums, int left, int right) {int randomIndex left RANDOM.nextInt(right - left 1);swap(nums, randomIndex, left);int pivot nums[left];int lt left 1;int gt right;// 循环不变量// all in [left 1, lt) pivot// all in (gt, right] pivotwhile (true) {while (lt right nums[lt] pivot) {lt;}while (gt left nums[gt] pivot) {gt--;}if (lt gt) {break;}// 细节相等的元素通过交换等概率分到数组的两边swap(nums, lt, gt);lt;gt--;}swap(nums, left, gt);return gt;}private void swap(int[] nums, int index1, int index2) {int temp nums[index1];nums[index1] nums[index2];nums[index2] temp;}
}作者liweiwei1419
链接https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/
版本 3三指针快排把等于切分元素的所有元素挤到了数组的中间在有很多元素和切分元素相等的情况下递归区间大大减少 -partition() 合并到quickSort()
private void quickSort(int[] nums, int left, int right) {// 小区间使用插入排序if (right - left INSERTION_SORT_THRESHOLD) {insertionSort(nums, left, right);return;}int randomIndex left RANDOM.nextInt(right - left 1);swap(nums, randomIndex, left);// 循环不变量// all in [left 1, lt] pivot// all in [lt 1, i) pivot// all in [gt, right] pivotint pivot nums[left];int lt left;int gt right 1;int i left 1;while (i gt) {if (nums[i] pivot) {lt;swap(nums, i, lt);i;} else if (nums[i] pivot) {i;} else {gt--;swap(nums, i, gt);}}swap(nums, left, lt);// 注意这里大大减少了两侧分治的区间quickSort(nums, left, lt - 1);quickSort(nums, gt, right);}作者liweiwei1419
链接https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/
4. 堆排序堆很重要堆排序根据个人情况掌握
堆排序是选择排序的优化选择排序需要在未排定的部分里通过「打擂台」的方式选出最大的元素复杂度 O(N)O(N)而「堆排序」就把未排定的部分构建成一个「堆」这样就能以 O(\log N)O(logN) 的方式选出最大元素
参考《算法 4》堆部分
public class Solution {public int[] sortArray(int[] nums) {int len nums.length;// 将数组整理成堆heapify(nums);// 循环不变量区间 [0, i] 堆有序for (int i len - 1; i 1; ) {// 把堆顶元素当前最大交换到数组末尾swap(nums, 0, i);// 逐步减少堆有序的部分i--;// 下标 0 位置下沉操作使得区间 [0, i] 堆有序siftDown(nums, 0, i);}return nums;}/*** 将数组整理成堆堆有序** param nums*/private void heapify(int[] nums) {int len nums.length;// 只需要从 i (len - 1) / 2 这个位置开始逐层下移for (int i (len - 1) / 2; i 0; i--) {siftDown(nums, i, len - 1);}}/*** param nums* param k 当前下沉元素的下标* param end [0, end] 是 nums 的有效部分*/private void siftDown(int[] nums, int k, int end) {while (2 * k 1 end) {int j 2 * k 1;if (j 1 end nums[j 1] nums[j]) {j;}if (nums[j] nums[k]) {swap(nums, j, k);} else {break;}k j;}}private void swap(int[] nums, int index1, int index2) {int temp nums[index1];nums[index1] nums[index2];nums[index2] temp;}
}作者liweiwei1419
链接https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/
5. 选择排序
每一轮选取未排定的部分中最小的部分交换到未排定部分的最开头经过若干个步骤就能排定整个数组。即先选出最小的再选出第 2 小的以此类推。 时间复杂度O(N) 空间复杂度O(1) // 选择排序每一轮选择最小元素交换到未排定部分的开头
import java.util.Arrays;public class Solution {// 选择排序每一轮选择最小元素交换到未排定部分的开头public int[] sortArray(int[] nums) {int len nums.length;// 循环不变量[0, i) 有序且该区间里所有元素就是最终排定的样子for (int i 0; i len - 1; i) {// 选择区间 [i, len - 1] 里最小的元素的索引交换到下标 iint minIndex i;for (int j i 1; j len; j) {if (nums[j] nums[minIndex]) {minIndex j;}}swap(nums, i, minIndex);}return nums;}private void swap(int[] nums, int index1, int index2) {int temp nums[index1];nums[index1] nums[index2];nums[index2] temp;}public static void main(String[] args) {int[] nums {5, 2, 3, 1};Solution solution new Solution();int[] res solution.sortArray(nums);System.out.println(Arrays.toString(res));}
}作者liweiwei1419
链接https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/6. 希尔排序不建议多花时间了解
插入排序的优化。在插入排序里如果靠后的数字较小它来到前面就得交换多次。「希尔排序」改进了这种做法。带间隔地使用插入排序直到最后「间隔」为 1 的时候就是标准的「插入排序」此时数组里的元素已经「几乎有序」 希尔排序的时间复杂度至今还没有明确的结论只有一个范围
public class Solution {// 希尔排序public int[] sortArray(int[] nums) {int len nums.length;int h 1;// 使用 Knuth 增量序列// 找增量的最大值while (3 * h 1 len) {h 3 * h 1;}while (h 1) {// insertion sortfor (int i h; i len; i) {insertionForDelta(nums, h, i);}h h / 3;}return nums;}/*** 将 nums[i] 插入到对应分组的正确位置上其实就是将原来 1 的部分改成 gap** param nums* param gap* param i*/private void insertionForDelta(int[] nums, int gap, int i) {int temp nums[i];int j i;// 注意这里 j deta 的原因while (j gap nums[j - gap] temp) {nums[j] nums[j - gap];j - gap;}nums[j] temp;}
}作者liweiwei1419
链接https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/
7. 冒泡排序了解
外层循环每一次经过两两比较把每一轮未排定部分最大的元素放到了数组的末尾
public class Solution {// 冒泡排序超时public int[] sortArray(int[] nums) {int len nums.length;for (int i len - 1; i 0; i--) {// 先默认数组是有序的只要发生一次交换就必须进行下一轮比较// 如果在内层循环中都没有执行一次交换操作说明此时数组已经是升序数组boolean sorted true;for (int j 0; j i; j) {if (nums[j] nums[j 1]) {swap(nums, j, j 1);sorted false;}}if (sorted) {break;}}return nums;}private void swap(int[] nums, int index1, int index2) {int temp nums[index1];nums[index1] nums[index2];nums[index2] temp;}
}作者liweiwei1419
链接https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/8. 计数排序了解
每个出现的数值都做一个计数然后根据计数从小到大输出得到有序数组。 -保持稳定性的做法是先对计数数组做前缀和在第 2 步往回赋值的时候根据原始输入数组的数据从后向前赋值前缀和数组保存了每个元素存放的下标信息这里没有说得太细本来这一点就不重要也不难理解。
作者liweiwei1419 链接https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/
public class Solution {// 计数排序private static final int OFFSET 50000;public int[] sortArray(int[] nums) {int len nums.length;// 由于 -50000 A[i] 50000// 因此桶 的大小为 50000 - (-50000) 10_0000// 并且设置偏移 OFFSET 50000目的是让每一个数都能够大于等于 0// 这样就可以作为 count 数组的下标查询这个数的计数int size 100000;// 计数数组int[] count new int[size];// 计算计数数组for (int num : nums) {count[num OFFSET];}// 把 count 数组变成前缀和数组for (int i 1; i size; i) {count[i] count[i - 1];}// 先把原始数组赋值到一个临时数组里然后回写数据int[] temp new int[len];System.arraycopy(nums, 0, temp, 0, len);// 为了保证稳定性从后向前赋值for (int i len - 1; i 0; i--) {int index count[temp[i] OFFSET] - 1;nums[index] temp[i];count[temp[i] OFFSET]--;}return nums;}
}作者liweiwei1419
链接https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/9. 选择排序了解
基于关键字的排序例如针对数值排序个位、十位、百位就是关键字。针对日期数据的排序年、月、日、时、分、秒就是关键字「基数排序」用到了「计数排序」
public class Solution {// 基数排序低位优先private static final int OFFSET 50000;public int[] sortArray(int[] nums) {int len nums.length;// 预处理让所有的数都大于等于 0这样才可以使用基数排序for (int i 0; i len; i) {nums[i] OFFSET;}// 第 1 步找出最大的数字int max nums[0];for (int num : nums) {if (num max) {max num;}}// 第 2 步计算出最大的数字有几位这个数值决定了我们要将整个数组看几遍int maxLen getMaxLen(max);// 计数排序需要使用的计数数组和临时数组int[] count new int[10];int[] temp new int[len];// 表征关键字的量除数// 1 表示按照个位关键字排序// 10 表示按照十位关键字排序// 100 表示按照百位关键字排序// 1000 表示按照千位关键字排序int divisor 1;// 有几位数外层循环就得执行几次for (int i 0; i maxLen; i) {// 每一步都使用计数排序保证排序结果是稳定的// 这一步需要额外空间保存结果集因此把结果保存在 temp 中countingSort(nums, temp, divisor, len, count);// 交换 nums 和 temp 的引用下一轮还是按照 nums 做计数排序int[] t nums;nums temp;temp t;// divisor 自增表示采用低位优先的基数排序divisor * 10;}int[] res new int[len];for (int i 0; i len; i) {res[i] nums[i] - OFFSET;}return res;}private void countingSort(int[] nums, int[] res, int divisor, int len, int[] count) {// 1、计算计数数组for (int i 0; i len; i) {// 计算数位上的数是几先取个位再十位、百位int remainder (nums[i] / divisor) % 10;count[remainder];}// 2、变成前缀和数组for (int i 1; i 10; i) {count[i] count[i - 1];}// 3、从后向前赋值for (int i len - 1; i 0; i--) {int remainder (nums[i] / divisor) % 10;int index count[remainder] - 1;res[index] nums[i];count[remainder]--;}// 4、count 数组需要设置为 0 以免干扰下一次排序使用for (int i 0; i 10; i) {count[i] 0;}}/*** 获取一个整数的最大位数** param num* return*/private int getMaxLen(int num) {int maxLen 0;while (num 0) {num / 10;maxLen;}return maxLen;}
}作者liweiwei1419
链接https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/
10. 桶排序了解
ublic class Solution {// 桶排序// 1 A.length 10000// -50000 A[i] 50000// 10_0000private static final int OFFSET 50000;public int[] sortArray(int[] nums) {int len nums.length;// 第 1 步将数据转换为 [0, 10_0000] 区间里的数for (int i 0; i len; i) {nums[i] OFFSET;}// 第 2 步观察数据设置桶的个数// 步长步长如果设置成 10 会超出内存限制int step 1000;// 桶的个数int bucketLen 100000 / step;int[][] temp new int[bucketLen 1][len];int[] next new int[bucketLen 1];// 第 3 步分桶for (int num : nums) {int bucketIndex num / step;temp[bucketIndex][next[bucketIndex]] num;next[bucketIndex];}// 第 4 步对于每个桶执行插入排序for (int i 0; i bucketLen 1; i) {insertionSort(temp[i], next[i] - 1);}// 第 5 步从桶里依次取出来int[] res new int[len];int index 0;for (int i 0; i bucketLen 1; i) {int curLen next[i];for (int j 0; j curLen; j) {res[index] temp[i][j] - OFFSET;index;}}return res;}private void insertionSort(int[] arr, int endIndex) {for (int i 1; i endIndex; i) {int temp arr[i];int j i;while (j 0 arr[j - 1] temp) {arr[j] arr[j - 1];j--;}arr[j] temp;}}
}作者liweiwei1419
链接https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/
【总结】
#####1.排序算法总结 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1VAMavOi-1585662450986)(https://upload-images.jianshu.io/upload_images/17025746-64aa4a7d0e174744.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)]
1.1 插入排序
时间复杂度O(N^2) 空间复杂度O(1)优点 在「几乎有序」的数组上表现良好特别地在「短数组」上的表现也很好。因为「短数组」的特点是每个元素离它最终排定的位置都不会太远应用在小区间内执行排序任务的时候可以转向使用「插入排序」
1.2 归并排序
时间复杂度O(NlogN) 空间复杂度O(N) -算法思想递归、分治处理问题的思想在算法领域是非常常见的通过编写「归并排序」学习递归思想了解递归的细节熟悉分治思想是相当好的学习材料。 -优点「归并排序」比「快速排序」好的一点是它借助了额外空间可以实现「稳定排序」Java 里对于「对象数组」的排序任务就是使用归并排序的升级版 TimSort在这里就不多做介绍。
1.3 快排
时间复杂度O(NlogN) 空间复杂度O(logN)算法思想分而治之分治思想与「归并排序」不同「快速排序」在「分」这件事情上不想「归并排序」无脑地一分为二而是采用了 partition 的方法因此就没有「合」的过程。 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BWOPzOP8-1585662450988)(https://upload-images.jianshu.io/upload_images/17025746-ad48df7591da38ac.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)] -缺点 快速排序丢失了稳定性如果需要稳定的快速排序需要具体定义比较函数这个过程叫「稳定化」在这里就不展开了。缺点针对特殊测试用例顺序数组或者逆序数组一定要随机化选择切分元素pivot否则在输入数组是有序数组或者是逆序数组的时候快速排序会变得非常慢等同于冒泡排序或者「选择排序」
1.4 堆排序
时间复杂度O(NlogN) 空间复杂度O(1)堆排序是选择排序的优化选择排序需要在未排定的部分里通过「打擂台」的方式选出最大的元素复杂度 O(N)而「堆排序」就把未排定的部分构建成一个「堆」这样就能以 O(logN) 的方式选出最大元素堆是一种相当有意思的数据结构它在很多语言里也被命名为「优先队列」。它是建立在数组上的「树」结构类似的数据结构还有「并查集」「线段树」等。「优先队列」是一种特殊的队列按照优先级顺序出队从这一点上说与「普通队列」无差别。「优先队列」可以用数组实现也可以用有序数组实现但只要是线性结构复杂度就会高因此「树」结构就有优势「优先队列」的最好实现就是「堆」。
1.5 选择排序
时间复杂度O(N^2) 空间复杂度O(1)优点交换次数最少。算法思想 1贪心算法每一次决策只看当前当前最优则全局最优。注意这种思想不是任何时候都适用。算法思想 2减治思想外层循环每一次都能排定一个元素问题的规模逐渐减少直到全部解决即「大而化小小而化了」。运用「减治思想」很典型的算法就是大名鼎鼎的「二分查找」。
1.6 希尔排序
时间复杂度尚不明确
1.7 冒泡排序了解
时间复杂度O(N^2) 空间复杂度O(1)优点「冒泡排序」有个特点在遍历的过程中提前检测到数组是有序的从而结束排序而不像「选择排序」那样即使输入数据是有序的「选择排序」依然需要「傻乎乎」地走完所有的流程。
1.8 计数排序 1.9 选择排序 1.10 桶排序
时间复杂度O(N) 优化特点 一个数该放在哪里是由这个数本身的大小决定的它不需要经过比较。也可以认为是哈希的思想由数值映射地址。特点 一定需要额外的空间才能完成排序任务缺点 适用场景不多主要是因为使用这三种排序一定要保证输入数组的每个元素都在一个合理的范围内优点可以实现成稳定排序无需稳定化
2.代码规范
2.1 循环不变量 快排 -保持「循环不变量」即定义的变量在循环开始前、循环过程中、循环结束以后都保持不变的性质这个性质是人为根据问题特点定义的。 循环不变量」是证明算法有效性的基础更是写对代码的保证遵守循环不变量是不是该写等于号先交换还是先 就会特别清楚绝对不会写错将遵守的「循环不变量」作为注释写在代码中。 2.2 《算法 4》代码风格不推荐
代码是写给人看的应该尽量避免代码个人风格化采用统一规范的写法保证易读性可扩展性。 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ntkuZXCs-1585662450990)(https://upload-images.jianshu.io/upload_images/17025746-5aba0141df398096.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)] 2.3 变量名称优化lt 是 less than 的缩写表示严格小于gt 是 greater than 的缩写表示严格大于le 是 less than or equal 的缩写表示小于等于本代码没有用到ge 是 greater than or equal 的缩写表示大于等于本代码没有用到。
3.排序入门成功 笔试面试不慌 public int[] sortArray(int[] nums) {Arrays.sort(nums);return nums;}安利网站
算法动态演示
参考链接https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/
