Java基础的三种排序

Java基础的三种排序

目录

冒泡排序

选择排序

快速排序

---

冒泡排序

冒泡排序时间复杂度为O（n^2） 最好情况是O（n）即数组就是有序的 遍历一边没有交换元素。空间复杂度为O（1）

稳定性：稳定

import java.util.Arrays;
public class bubbleSort {
    public static void main(String[] args) {
        //创建需要排序的数组
        int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};

        //调用排序方法
        bubbleSort(arr);
        
        //打印排序结果
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 冒泡排序
     * @param arr  需要排序的 int 类型目标数组
     */
    public static void bubbleSort(int[] arr) {
        //确定循环轮数
        for (int i = 0; i < arr.length - 1; i++) {
            //遍历数组
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //找到比前一个大的进行交换
                if (arr[j] > arr[j + 1]) {
                    //交换
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

选择排序

选择排序的时间复杂度最好最坏情况都是O（n^2）

空间复杂度为O（1），

 

稳定性：不稳定

/**
 * 针对于 int 类型数组选择排序算法实现
 *
 * @param arr int 类型数组
 */
public static void selectSort(int[] arr) {
    // 完成排序算法操作，执行的核心模块次数是当前数组有效元素个数 - 1
    for (int i = 0; i < arr.length - 1; i++) {
        
        // 按照排序规则要求，找极值对应的下标位置
        int index = i;
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[index] < arr[j]) {
                index = j;
            }
        }
        
        // 进行数据交换操作，和目标存储极值对应的下标数据进行交换
        if (index != i) {
            int temp = arr[index];
            arr[index] = arr[i];
            arr[i] = temp;
        }
    }
}

快速排序

快速排序时间复杂度最好情况是都能分割成较完美的两部分 O（nlog(n)）,最坏情况是数组是有序的每次分割只有一边 O（n^2）
空间复杂度为O（nlog(n)）

稳定性：不稳定

import java.util.Arrays;
import java.util.Random;

public class QuickSort {
    public static void main(String[] args) {

//        int[] arr = {6,1,2,7,9,3,4,5,10,8};
        int[] arr = new int[10000];
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = r.nextInt();
        }

        //打印未排序前的数组
//        System.out.println(Arrays.toString(arr));

        //记录排序开始的时间
        long start = System.currentTimeMillis();
        quickSort(arr,0,arr.length-1);

        //记录排序结束的时间
        long end = System.currentTimeMillis();
        //打印排序用时
        System.out.println(end - start);

        //打印排序结束数组
//        System.out.println(Arrays.toString(arr));


    }
    public static void quickSort(int[] arr,int i, int j){
        //定义两个变量记录要查找的范围
        int start = i;
        int end = j;

        if (start > end){
            //递归出口
            return;
        }

        //记录基准数
        int baseNumber = arr[i];

        //利用循环找到要交换的数字
        while (start != end){
            //利用end从后往前遍历找到比基准数小的数字
            while (true){
                if (end <= start || arr[end] < baseNumber){
                    break;
                }
                end--;
            }
            //利用start 从前往后遍历，找到比基准数大的数字
            while (true){
                if (end <= start || arr[start] > baseNumber){
                    break;
                }
                start++;
            }
            //把end和start指向元素交换
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
        //start和end指向同一个元素的时候表示找到了基准数因该存在的位置
        //基准数归位
        //拿着这个范围的第一个数字跟start指向元素进行交换
        int temp = arr[i];
        arr[i] = arr[start];
        arr[start] = temp;
        //确定基准数左边的范围，重复刚刚的操作
        quickSort(arr, i,start - 1);
        //确定基准数右边的范围，重复刚刚的操作
        quickSort(arr, start + 1, j);
    }
}