最简单易懂的java数组排序方法整理
Java 数组排序是 Java 程序员最常用到的功能之一，它可以帮助我们快速把一组数据按照一定的规则排序，整理出的方法都是以字母顺序为主，理解起来非常简单，并且排序的效率也比较高，下面我们一起来看看具体的方法。
1. 冒泡排序
冒泡排序是一种简单的排序算法，它通过不断比较相邻的两个元素，将较大的元素往上移动，最终得到一个有序的数组。冒泡排序的时间复杂度为 O(n^2)。
例如，我们要对下面这个数组排序：
int[] nums = {5,3,8,6,4};
使用冒泡排序的方法，我们会先遍历整个数组，将 个元素（5）和第二个元素（3）比较，发现 3 比 5 小，因此将两者交换，数组变为 {3,5,8,6,4}。然后再将第二个元素（5）和第三个元素（8）进行比较，发现它们已经符合排序规则，不需要交换。以此类推，直到最后一个元素都被排序完毕，得到的数组就是 {3,4,5,6,8}。
下面是冒泡排序的实现代码：
public static void bubbleSort(int[] nums){
int temp;
for(int i=0;i<nums.length-1;i++){
for(int j=0;j<nums.length-1-i;j++){
if(nums[j]>nums[j+1]){
temp = nums[j];
nums[j] = nums[j+1];
nums[j+1] = temp;
}
}
}
}
2. 选择排序
选择排序是一种简单的排序算法，它每次在一个未排序的部分中找到最小的元素，然后将它放到已排序部分的末尾，直到所有元素都被排序完毕。选择排序的时间复杂度为 O(n^2)。
例如，我们要对下面这个数组排序：
int[] nums = {5,3,8,6,4};
使用选择排序的方法，我们会先遍历整个数组，找到最小的元素（3），并将它放到数组的 个位置。然后再从剩余的未排序部分中找到最小的元素（4），将它放到数组的第二个位置。以此类推，直到所有元素都被排序完毕，得到的数组就是 {3,4,5,6,8}。
下面是选择排序的实现代码：
public static void selectionSort(int[] nums){
int minIndex, temp;
for(int i=0;i<nums.length-1;i++){
minIndex = i;
for(int j=i+1;j<nums.length;j++){
if(nums[j]<nums[minIndex]){
minIndex = j;
}
}
temp = nums[i];
nums[i] = nums[minIndex];
nums[minIndex] = temp;
}
}
3. 插入排序
插入排序是一种简单的排序算法，它每次将一个未排序的元素插入到已排序部分的正确位置，直到所有元素都被排序完毕。插入排序的时间复杂度为 O(n^2)。
例如，我们要对下面这个数组排序：
int[] nums = {5,3,8,6,4};
使用插入排序的方法，我们会将 个元素（5）当作已排序部分，然后从第二个元素（3）开始逐个插入到已排序部分的正确位置。插入时，我们从已排序部分的末尾开始查找，如果发现插入的元素比已排序部分的某个元素要小，那么就将这个元素向后移动一位，以便为插入元素腾出位置。最后，将插入元素放到正确位置即可。以此类推，直到所有元素都被排序完毕，得到的数组就是 {3,4,5,6,8}。
下面是插入排序的实现代码：
public static void insertionSort(int[] nums){
int temp, j;
for(int i=1;i<nums.length;i++){
temp = nums[i];
j = i-1;
while(j>=0 && nums[j]>temp){
nums[j+1] = nums[j];
j--;
}
nums[j+1] = temp;
}
}
4. 快速排序
快速排序是一种高效的排序算法，它采用了分治的思想，将一个大问题分成若干个小问题解决。快速排序的时间复杂度为 O(nlogn)。
例如，我们要对下面这个数组排序：
int[] nums = {5,3,8,6,4};
使用快速排序的方法，我们会先选择一个基准元素（比如数组的 个元素），然后将数组中小于基准元素的元素放到左边，大于基准元素的元素放到右边。这个过程叫做分区。然后，将左右两个部分递归地使用相同的方法排序。最终得到的数组就是 {3,4,5,6,8}。
下面是快速排序的实现代码：
public static void quickSort(int[] nums, int left, int right){
if(left>=right){
return;
}
int i = left, j = right, pivot = nums[left];
while(i<j){
while(i<j && nums[j]>=pivot){
j--;
}
if(i<j){
nums[i++] = nums[j];
}
while(i<j && nums[i]<pivot){
i++;
}
if(i<j){
nums[j--] = nums[i];
}
}
nums[i] = pivot;
quickSort(nums, left, i-1);
quickSort(nums, i+1, right);
}
5. 归并排序
归并排序是一种稳定的排序算法，它将一个数组分成两个同样大小的部分，对这两个部分分别排序，然后将它们合并起来。归并排序的时间复杂度为 O(nlogn)。
例如，我们要对下面这个数组排序：
int[] nums = {5,3,8,6,4};
使用归并排序的方法，我们会先将数组分成两个部分，分别为 {5,3,8} 和 {6,4}。然后，对这两个部分递归地使用相同的方法排序。
在合并这两个部分时，我们将两个部分头部的元素进行比较，取出较小的元素放到结果数组中，直到其中一个部分已被遍历完毕。最后，将剩余的元素全部放到结果数组中。得到的数组就是 {3,4,5,6,8}。
下面是归并排序的实现代码：
public static void mergeSort(int[] nums, int left, int right){
if(left>=right){
return;
}
int mid = (left+right)/2;
mergeSort(nums, left, mid);
mergeSort(nums, mid+1, right);
int i = left, j = mid+1, k = 0;
int[] temp = new int[right-left+1];
while(i<=mid && j<=right){
if(nums[i]<=nums[j]){
temp[k++] = nums[i++];
}else{
temp[k++] = nums[j++];
}
}
while(i<=mid){
temp[k++] = nums[i++];
}
while(j<=right){
temp[k++] = nums[j++];
}
for(int m=0;m<temp.length;m++){
nums[left+m] = temp[m];
}
}
总结：
这里我们介绍了几种 Java 数组排序的方法，包括冒泡排序、选择排序、插入