常见排序算法

常见排序算法

import org.junit.Test;

import java.util.Arrays;

public class Sort {

    @Test
    public void testSort() {

        int[] arr1 = {4, 6, 3, 1, 5, 9};
        int[] arr2 = {4, 6, 3, 1, 5, 9};
        int[] arr3 = {4, 6, 3, 1, 5, 9};
        int[] arr4 = {4, 6, 3, 1, 5, 9, 0, 2};
        int[] arr5 = {4, 6, 3, 1, 5, 9};
        int[] arr6 = {4, 8, 3, 1, 5, 9, 7, 2, 6};
        //冒泡排序
        System.out.println("冒泡排序***********************************");
        bubbleSort(arr1);
        System.out.println(Arrays.toString(arr1));
        System.out.println("******************************************");

        //选择排序
        System.out.println("选择排序***********************************");
        selectSort(arr2);
        System.out.println(Arrays.toString(arr2));
        System.out.println("******************************************");

        //插入排序
        System.out.println("插入排序***********************************");
        insertSort(arr3);
        System.out.println(Arrays.toString(arr3));
        System.out.println("******************************************");

        //希尔排序
        System.out.println("希尔排序***********************************");
        shellSort(arr4);
        System.out.println(Arrays.toString(arr4));
        System.out.println("******************************************");

        //快速排序
        System.out.println("快速排序***********************************");
        quickSort(arr5, 0, arr5.length - 1);
        System.out.println(Arrays.toString(arr5));
        System.out.println("******************************************");

        //二分查找
        System.out.println("二分查找***********************************");
        Arrays.sort(arr6);
        System.out.println(Arrays.toString(arr6));
        int aim = binarySearch(arr6, 1);
        System.out.println("目标在数组中位置：" + aim);
        System.out.println("******************************************");

    }

    //冒泡排序
    public void bubbleSort(int[] arr) {

        //外层：遍历次数
        for (int i = arr.length - 1; i > 0; i--) {
            //内层：比较，将较大的数排在后面
            for (int j = 0; j < i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int tmp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = tmp;
                }
            }
        }
    }

    //选择排序
    public void selectSort(int[] arr) {

        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < arr.length - 1; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            if (minIndex != i) {
                int tmp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = tmp;
            }
        }
    }

    //插入排序
    public void insertSort(int[] arr) {

        for (int i = 0; i < arr.length; i++) {
            for (int j = i - 1; j >= 0; j--) {
                if (arr[j] > arr[j + 1]) {
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                }
            }
        }
    }

    //希尔排序
    public void shellSort(int[] arr) {
        //两个一组
        int group = arr.length / 2;
        int cur = 0;
        //循环遍历
        while (group > 0) {
            //对小组内的数据进行插入排序
            for (int j = group; j < arr.length; j++) {

                cur = arr[j];
                int preIndex = j - group;

                while (preIndex >= 0 && cur < arr[preIndex]) {

                    arr[preIndex + group] = arr[preIndex];
                    preIndex -= group;
                }
                arr[preIndex + group] = cur;
            }
            group = group / 2;
        }
    }

    //快速排序
    public void quickSort(int[] arr, int left, int right) {

        if (left > right) {
            return ;
        }
        //左右两边位置
        int i = left, j = right;
        //基准数字为最左端数字
        int base = arr[left];

        while (i != j) {
            //右侧向左查找比基准小的数，记录位置
            while (j > i && arr[j] >= base) {
                j--;
            }
            //左侧向右查找比基准大的数
            while (i < j && arr[i] <= base) {
                i++;
            }
            //找到的两个数交换位置
            if (i < j) {
                int tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
            }
        }

        //基准与i位交换
        arr[left] = arr[i];
        arr[i] = base;

        //左侧二次排序
        quickSort(arr, left, i - 1);
        //右侧二次排序
        quickSort(arr, i + 1, right);
    }

    //二分查找
    public int binarySearch(int[] arr, int aim) {

        int low = 0;
        int high = arr.length - 1;
        int mid;
        while (low <= high) {
            //中间位置
            mid = (high - low) / 2 + low;
            if (arr[mid] == aim) {
                return mid;
                //向右查找
            } else if (arr[mid] < aim) {
                low = mid + 1;
                //向左查找
            } else {
                high = mid - 1;
            }
        }

        return -1;
    }
}

排序结果

冒泡排序***********************************
[1, 3, 4, 5, 6, 9]
******************************************
选择排序***********************************
[1, 3, 4, 5, 6, 9]
******************************************
插入排序***********************************
[1, 3, 4, 5, 6, 9]
******************************************
希尔排序***********************************
[0, 1, 2, 3, 4, 5, 6, 9]
******************************************
快速排序***********************************
[1, 3, 4, 5, 6, 9]
******************************************
二分查找***********************************
[1, 2, 3, 4, 5, 6, 7, 8, 9]
目标在数组中位置：0
******************************************