Java必备-冒泡排序,选择排序,快速排序(纯代码实现)

---

冒泡排序: 

import java.util.Arrays;

/**
 * 是将无序a[0],a[1]...a[n],将其升序排序,比较a[0].a[1]的值,若结果为1,则交换两者的值,否则不变,接着继续向下比较.最后比较a[n-1].a[n]的结果,结束后,a[n]的值为当前数组中最大值.接着继续将a[1]~a[n-1]进行比较.一共处理n-1轮后, 就是以升序排列
 *
 * 优点: 稳定
 * 缺点: 耗时长,每次只是移动两个相邻的数据做对比
 * @Description Java冒泡排序
 * @Author : Dy yimting@yeah.net
 * @Date : 2019/3/26,14:06
 * @Project : Java_Sort
 * @Version : 1.0
 **/
public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {34, 2, 146, 76, 45, 3, 6, 7};
        long start = System.nanoTime();
        sort(arr);
        long end = System.nanoTime();
        System.out.println("排序后 : " + Arrays.toString(arr));
        System.out.println("运行时间:" + (end - start) + " ns");
    }

    /**
     * @param arr 传入的数组
     *            第一次外层循环 ,和第一层内层循环内部结果
     *            34 2 146 76 45 3 6 7
     *            2 34 146 76 45 3 6 7
     *            2 34 146 76 45 3 6 7
     *            2 34 76 146 45 3 6 7
     *            2 34 76 45 146 3 6 7
     *            2 34 76 45 3 146 6 7
     *            2 34 76 45 3 6 146 7
     *            2 34 76 45 3 6 7 146
     *            .....................
     */
    public static void sort(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]) {
                    arr[j] = arr[j] ^ arr[j + 1];
                    arr[j + 1] = arr[j] ^ arr[j + 1];
                    arr[j] = arr[j] ^ arr[j + 1];
                }
            }
        }
    }
}

选择排序 : 

import java.util.Arrays;

/**
 * 从所有序列中先找到最小的，然后放到第一个位置。之后再看剩余元素中最小的，放到第二个位置……以此类推，就可以完成整个的排序工作。
 * 选择排序是不稳定的排序方法
 *
 * @Description Java选择排序
 * @Author : Dy yimting@yeah.net
 * @Date : 2019/3/26,14:47
 * @Project : bigdata
 * @Version : 1.0
 **/
public class SelectSort {
    public static void main(String[] args) {
        int[] arr = {34, 2, 146, 76, 45, 3, 6, 7, 6, 6};
        long start = System.nanoTime();
        sort(arr);
        long end = System.nanoTime();
        System.out.println("排序后 : " + Arrays.toString(arr));
        System.out.println("运行时间:" + (end - start) + " ns");
    }

    public static void sort(int[] arr) {
        //第一轮循环
        for (int i = 0; i < arr.length - 1; i++) {
            int small = i;
            //取出数组中的最小值
            for (int j = small + 1; j < arr.length; j++) {
                //判断循环到的值进行对比, 取出最小值的下标
                if (arr[small] > arr[j]) {
                    small = j;
                }
            }
            //最小值与循环到的值的位置进行交换
            if (i != small) {
                arr[small] = arr[small] ^ arr[i];
                arr[i] = arr[small] ^ arr[i];
                arr[small] = arr[small] ^ arr[i];
            }
        }
    }
}

 

快速排序 : 

import java.util.Arrays;

/**
 * @Description 经典快排: 拿出一个值作为基准值, 与基准值做比较
 * @Author : Dy yimting@yeah.net
 * @Date : 2019-03-08 10:01:48
 * @Project : Java_Sort
 * @Version : 1.0
 **/
public class QuickSort {
    public static void main(String[] args) {

        int[] arr = {12, 4, 2, 5, 79, 6, 6, 6};

        long start = System.nanoTime();
        sort(arr, 0, arr.length - 1);
        System.out.println("排序结果 :" + Arrays.toString(arr));
        long end = System.nanoTime();

        System.out.println("运行时间:" + (end - start) / 100000 + " ms");
    }

    /**
     * 对arr[first] - arr[last] 进行排序
     *
     * @param arr   需要排序的数组
     * @param first 数组中的起始值
     * @param last  数组中的最后
     */
    private static void sort(int[] arr, int first, int last) {
        //判断下标是否存在有问题
        if (first >= last) {
            return;
        }
        //赋予变量, 接收,便于更改
        int i = first;
        int j = last;
        while (i < j) {
            //取出第一个元素作为基准值
            int one = arr[i];
            /*-----------右侧的轮询------------*/
            //如果 最后一个值大于等于基准值 或者 i坐标 小于 j坐标 (防止坐标冲突)
            while (arr[j] >= one && i < j) {
                //如果满足条件的话, 需要将指针,向左移动
                j--;
            }
            //进行交换
            swap(arr, i, j);
            /*-----------左侧的轮询------------*/
            //如果 第一个值 小于等于基准值或者 i坐标 小于 j坐标 (防止坐标冲突)
            while (arr[i] <= one && i < j) {
                //如果满足条件的话, 需要将指针,向右移动
                i++;
            }
            //进行交换
            swap(arr, i, j);
        }

        /*-----------进行递归操作------------*/
        //对于基准左侧的集合 重复操作
        sort(arr, first, i - 1);
        //对于基准右侧的集合 重复操作
        sort(arr, i + 1, last);
    }

    /**
     * 单独提出一个方法用来进行数值的交换
     * 这个方式会使运行速度降低
     *
     * @param arr 调用方法时需要进行交换的数组
     * @param i   坐标
     * @param j   坐标
     */
    static void swap(int[] arr, int i, int j) {
        if (i < j) {
            arr[i] = arr[i] ^ arr[j];
            arr[j] = arr[i] ^ arr[j];
            arr[i] = arr[i] ^ arr[j];
        }
    }

}