java中四种排序排序:选择排序、快速排序、冒泡排序、快速排序。
1、选择排序
进行两层for循环,第一轮找出一个最小的数,第二轮找出一个第二小的数,即除去已经找出的第一个数,剩下的所有数中最小的数。以此类推。
public static void selectSort(int[] a) {
for (int i = 0; i < a.length; i++) {
for(int j = i; j < a.length; j++) {
if(a[i] > a[j]) {
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
//这里的打印是为了从控制台输出,可以看的更清楚
for (int s : a) {
System.out.print(s + " ");
}
System.out.println();
}
}
输入的数据为:
int[] a= {2,4,1,7,9,3,6,5,8};
排序每一轮打印的结果:
1 4 2 7 9 3 6 5 8
1 2 4 7 9 3 6 5 8
1 2 3 7 9 4 6 5 8
1 2 3 4 9 7 6 5 8
1 2 3 4 5 9 7 6 8
1 2 3 4 5 6 9 7 8
1 2 3 4 5 6 7 9 8
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
2、插入排序
把一个数插入到一个有序的数组当中。默认数组a[0]是一个当前有序的数组,从a[1]开始,拿当前的数与之前的数组两两挨个比较,若当前数据比前一个数据小,那么就进行交换,以此类推。
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;
}
}
System.out.print("i = " + i + " 每次排序结果是 ");
for (int s : a) {
System.out.print(s + " ");
}
System.out.println();
}
}
使用上面的数据,进行排序的过程如下:
i = 1 每次排序结果是 2 4 1 7 9 3 6 5 8
i = 2 每次排序结果是 1 2 4 7 9 3 6 5 8
i = 3 每次排序结果是 1 2 4 7 9 3 6 5 8
i = 4 每次排序结果是 1 2 4 7 9 3 6 5 8
i = 5 每次排序结果是 1 2 3 4 7 9 6 5 8
i = 6 每次排序结果是 1 2 3 4 6 7 9 5 8
i = 7 每次排序结果是 1 2 3 4 5 6 7 9 8
i = 8 每次排序结果是 1 2 3 4 5 6 7 8 9
3、冒泡排序
两两比较,若当前数比后一个数大,那么就进行交换。第一轮最大的数像泡泡一样落到最后,第二轮次大的数落到倒数第二。以此类推。
public static void bubbleSort(int[] a) {
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a.length - 1 - i; j++) {
if (a[j] > a[j + 1]) {
int temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
System.out.print("i = " + i + " 每次排序结果是 ");
for (int s : a) {
System.out.print(s + " ");
}
System.out.println();
}
}
仍旧使用上面的数据,其排序过程如下:
i = 0 每次排序结果是 2 1 4 7 3 6 5 8 9
i = 1 每次排序结果是 1 2 4 3 6 5 7 8 9
i = 2 每次排序结果是 1 2 3 4 5 6 7 8 9
i = 3 每次排序结果是 1 2 3 4 5 6 7 8 9
i = 4 每次排序结果是 1 2 3 4 5 6 7 8 9
i = 5 每次排序结果是 1 2 3 4 5 6 7 8 9
i = 6 每次排序结果是 1 2 3 4 5 6 7 8 9
i = 7 每次排序结果是 1 2 3 4 5 6 7 8 9
i = 8 每次排序结果是 1 2 3 4 5 6 7 8 9
4、快速排序
快速排序(Quick Sort)是一种常用的排序算法,基于分治的思想。它的基本思路是选择一个基准元素,将数组划分为两个子数组,使得左子数组中的元素都小于等于基准元素,右子数组中的元素都大于等于基准元素,然后递归地对子数组进行排序。
递归的方式处理,递归的停止条件不能写错。
public static void quickSort(int[] a, int start, int end) {
if(a == null || a.length == 0 || start > end)
{
return;
}
int k = quickSortHelper(a, start, end);
quickSort(a, start, k - 1);
quickSort(a, k + 1, end);
}
private static int quickSortHelper(int[] a, int start, int end) {
if(a == null || a.length == 0 || start > end)
{
return -1;
}
int keyValue = a[start];
while (start < end) {
while (start < end && a[end] > keyValue) {
end--;
}
a[start] = a[end];
while (start < end && a[start] <= keyValue) {
start++;
}
a[end] = a[start];
}
a[start] = keyValue;
return start;
}
处理过程如下
1 2 4 7 9 3 6 5 8
1 2 4 7 9 3 6 5 8
1 2 3 4 9 7 6 5 8
1 2 3 4 9 7 6 5 8
1 2 3 4 8 7 6 5 9
1 2 3 4 5 7 6 8 9
1 2 3 4 5 7 6 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9