Java中常见的数组排序算法(包括冒泡，选择，插入，快速排序)

1、直接排序：　　

public static void selectSort(int[] arr) {
for (int x = 0; x < arr.length - 1; x++) {
for (int y = x + 1; y < arr.length; y++) {
if (arr[x] > arr[y]) {
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
}

 

说明：双重for循环，数组的第一个数a[0]和后面所有的数进行比对，得到最小的数，然后第二个数a[1]和后面所有的数进行比对，得到次小的数。。。反复后得到排序后的结果。

2、冒泡排序

　　（1）、

1 public static void bubbleSort(int[] arr) {
2
3       　　 for(int x=0; x<arr.length-1; x++) {
4
5           　　 for(int y=0; y<arr.length-x-1; y++) {
6
7              　　 if(arr[y]>arr[y+1]){
8
9                 　　  int temp = arr[y];
10
11                  　　 arr[y] = arr[y+1];
12
13                  　　 arr[y+1] = temp;
14
15               　　}
16
17            　　}
18
19        　　}
20
21 　　}

　　(2)、

1 public static void sort(int[] a) {
2 　　　　int temp = 0;
3 　　　　for (int i = a.length - 1; i > 0; --i){
4 　　　　　　for (int j = 0; j < i; ++j){
5 　　　　　　　　if (a[j + 1] < a[j]){
6 　　　　　　　　　　temp = a[j];
7 　　　　　　　　　　a[j] = a[j + 1];
8 　　　　　　　　　　a[j + 1] = temp;
9 　　　　　　　　}
10 　　　　　　}
11 　　　　}
12 　　}

说明：冒泡排序是两两之间进行对比，   如：4.2.5.1.7   ：第一次内循环、4和2比-->2,4 、4和5比-->4,5、5和1比-->5,1、5和7比-->5,7。

　　这样最大的一个数就到了数组的最后，第二次进行比对的时候只要比数组长度-2次，就是<arr.length-1，即可得到次大的数，放在倒数第二的位置，如此反复得到排序后的数组。

3、插入排序：

public static void insertSort(int[] a) {
for (int i = 1; i < a.length; i++) {
for (int j = i; j > 0; j--) {
if (a[j] < a[j - 1]) {
int temp = a[j - 1];
a[j - 1] = a[j];
a[j] = temp;
}else break;
}
}
}

说明：插入排序和打牌一样，拿到一个数和前面已有的数进行对比，比前面的数小就放到前面，举例：4,2,5,1,7 :  

　　第一次内循环、拿到数a[1]=2,和a[0]=4进行对比，2小，换位置;

　　第二次内循环、拿到数5，和4比，位置不变，if判断为false，则break，跳出内循环，进行下一次;

　　第三次内循环、拿到数1，和5比，交换位置，1在和4比，交换位置，最后和2比，再次交换位置，得到结果，1,2,4,5,7;

　　...

4、直接选择排序：

private static void xuanZePaiXu() {
int[]  nums = new int[]{4,13,-1,2,0,5,30};
for (int i = 0; i < nums.length; i++) {
int tem = i;
for (int j = i; j < nums.length; j++) {
if (nums[j]<nums[tem]) {
tem = j;
}
}
int tem2 = nums[i];
nums[i] = nums[tem];
nums[tem] = tem2;
}
System.out.println(Arrays.toString(nums)); //循环遍历数组的新技巧
}