排序算法

Java常用排序算法/程序员必须掌握的 8大排序算法

自定义方法实现冒泡排序算法

//冒泡排序
    public static void bubble(int[] arr){
        //1.使用外层循环控制比较的轮数
        for(int i = 1; i < arr.length; i++){
            //使用变量作为当前轮是否发生交换的标志
            boolean flag = true;
            //2.使用内层循环控制比较的元素下标范围
            for(int j = 0; j < arr.length-i; j++){
                //3.如果左边元素大，则交换
                if(arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    flag = false;
                }
            }
            //到这个位置flag还是true，证明当前轮没有发生任何的交换
            if(flag){
                break;
            }
        }
    }

插入排序

public static void insert(int[] arr){
        //1.使用外层循环负责一个个取出元素
        for(int i = 1; i < arr.length; i++){
            //2.单独保存每一次取出的元素，防止被覆盖
            int temp = arr[i];
            //3.使用内层循环负责让取出的元素与左边的元素一个个比较，
            //如果左边有元素并且大于取出的元素则左边元素右移
            int j = 0;
            for(j = i; j >= 1 && arr[j-1] > temp; j-- ){
                arr[j] = arr[j-1];
            }
            //4.直到左边元素不再大于取出的元素，则将取出的元素插入到左边元素
            //  的右边
            // 避免自己给自己赋值
            if(j != i){
                arr[j] = temp;
            }
        }
    }

选择排序

public static void choose(int[] arr){
        //1.使用外层循环负责将元素一个个取出来
        for(int i = 0; i < arr.length - 1; i++){
            //2.假定取出的元素是最小值，使用min记录下标
            int min = i;
            //3.使用内层循环让min记录的元素与后续元素依次比较，
            //  如果后续元素中有比min记录的元素还小的元素，则重新记录该元素下标
            for(int j = i+1; j < arr.length; j++){
                if(arr[j] < arr[min]){
                    min = j;
                }
            }
            //4.直到min记录的元素与后续所有元素比较完毕，此时交换min记录的元素
            //  和最开始假定的元素
            if(min != i){
                int temp = arr[min];
                arr[min] = arr[i];
                arr[i] = temp;
            }
        }
    }

快速排序

//自定义方法实现快速排序算法
    public static void quick(int[] arr, int left, int right) {
        //1.计算中间元素的下标作为基准值，并单独保存起来
        //2.分别让左右两边的元素依次和基准值进行比较
        //2.1 将所有比基准值小的元素放在基准值的左边
        //2.2 将所有比基准值大的元素放在基准值的右边，相等的任意一遍
        //3.直到三个坐标重合时将基准值放在重合的位置上
        //4.分别对左右两边的分组进行再次分组，使用递归

        if (left < right) {
            //Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1
            int i = left, j = right, x = arr[left];
            while (i < j) {
                while (i < j && arr[j] >= x) // 从右向左找第一个小于x的数
                    j--;
                if (i < j)
                    arr[i++] = arr[j];

                while (i < j && arr[i] < x) // 从左向右找第一个大于等于x的数
                    i++;
                if (i < j)
                    arr[j--] = arr[i];
            }
            arr[i] = x;
            quick(arr, left, i - 1); // 递归调用
            quick(arr, i + 1, right);
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] arr = {20, 8, 18, 5, 15, 30, 10, 25, 8};
        TestSort.quick(arr,0,arr.length-1);
        //打印最终的排序结果
        System.out.print("排序后的结果是：");
        for(int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

二分查找算法

//自定义一个方法实现二分查找算法
    public static int findBinary(int[] arr, int left, int right, int data){
        if(left <= right){
        
            //1.计算并找出中间元素
            int p = (left + right) / 2;
            //2.如果目标元素与中间元素相等，则返回对应下标
            if(data == arr[p]){
                return p;
            }
            //3.如果目标元素小于中间元素，则去左边查找，重复以上过程，使用递归
            else if(data < arr[p]){
                return findBinary(arr, left, p-1, data);
            }
            //4.如果目标元素大于中间元素，则去右边查找，重复以上过程，使用递归
            else{
                return findBinary(arr, p+1, right, data);
            }
        }
        
        return -1;
    }
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] arr = {10,20,30,40,50,60,70,80,90};
        int res = TestFind.findBinary(arr, 0, arr.length-1, 100);
        System.out.println("该元素的下标是：" + res);
        
    }