【java常见的排序算法】

第一种排序算法：冒泡排序(两两比较排大小)
 //冒泡排序：两两比较排大小
        int[] nums={20,10,5,30,70};
        //第一轮 保证 倒数第一位是第一大的
        //第1次 10 20 5 30 70
        //第2次 10 5 20  30 70
        //第3次 10 5 20 30 70
        //第4次 10 5 20 30 70
        //第二轮 保证 倒数第二位是第二大的
        //第1次 5 10 20 30 70
        //第2次 5 10 20 30 70
        //第3次 5 10 20 30 70
        //第三轮 保证 倒数第三位是第三大的
        //第1次 5 10 20 30 70
        //第2次 5 10 20 30 70
        //第四轮 保证 倒数第四位是第四大的
        //第1次 5 10 20 30 70
        System.out.println(Arrays.toString(nums));
        for(int i=0;i<nums.length-1;i++){//外层控制比较轮数
            for(int j=0;j<nums.length-1-i;j++){//内层控制比较次数
               if(nums[j]>nums[j+1]) {//值的互换
                   nums[j]=nums[j]^nums[j+1];
                   nums[j+1]=nums[j]^nums[j+1];
                   nums[j]=nums[j]^nums[j+1];
               }
            }
        }
        System.out.println(Arrays.toString(nums));

第二种排序算法：选择排序
规则：第一个元素  和其他元素比较，在拿第二个和其他元素比较...
int[] nums={89,76,65,64,13};
        //第一轮：保证第一个是最小的
        //第1次： 89-->77  记录下标
        //第2次： 77-->99
        //第3次： 77-->65  记录下标
        //第4次： 65-->13  记录下标
        //结果  13 77 99 65 89
        //第二轮：保证第二个是第二小的
        //第1次：
        //第2次：
        //第3次：
        //结果  13 65 99 77 89
        //第三轮：保证第三个是第三小的
        //第1次：
        //第2次：
        //结果  13 65 77 99 89
        //第四轮：保证第四个是第四小的
        //第1次：
        //结果  13 65 77 89 99
        for(int i=0;i<nums.length-1;i++){//外层控制轮数
            int index=i;
            for(int j=i+1;j<nums.length;j++){//里层控制每轮比较次数
                if(nums[index]>nums[j]){//可以互换 没有必要  会降低效率
                    //记录下标
                    index=j;
                }
            }
            //值的互换
            if(i!=index){
                nums[i]=nums[i]^nums[index];
                nums[index]=nums[i]^nums[index];
                nums[i]=nums[i]^nums[index];
            }
        }
        System.out.println("排序后："+ Arrays.toString(nums));

第三种排序算法：插入排序
规则：要将数组分成两个部分(一个是有序部分，另一个是待插入元素)
待插入部分和前面有序部分比较，但遇见了第一个比插入元素大的元素，那么这个位置就是插入的位置。
 int[] num={50,10,30,5,77};
        /*
        * 第一轮：有序50  插入10
        * 第一次：10 50
        * 第二轮：有序 10 50  插入30
        * 第一次：10 30 50
        * 第二次：10 30 50
        * 第三轮：有序10 30 50   插入：5
        * 第一次：10 30 5 50
        * 第二次：10 5 30 50
        * 第三次：5 10 30 50
        * 第四轮：有序 5 10 30 50 插入77
        * 第一次：5 10 30 50 77
        * 第二次：5 10 30 50 77
        * 第三次：5 10 30 50 77
        * 第四次：5 10 30 50 77
        * */
        for(int i=0;i<num.length-1;i++){//外层控制轮数
            for(int j=i+1;j>0;j--){//内层控制比较次数
                if(num[j]<num[j-1]){
                    num[j]=num[j]+num[j-1];
                    num[j-1]=num[j]-num[j-1];
                    num[j]=num[j]-num[j-1];
                }
            }
        }

第四种查找算法：二分查找
规则如下：前提时必须在一个有序数组基础上
进行折半查找  指定元素
public static void main(String[] args) {
//        Arrays.binarySearch();//底层实现就是二分查找
        int[] nums={10,30,40,50,60,70,80,90};
        int number=70;
       int result= mySearch(nums,number);
        System.out.println(result);
    }
    //nums 有序数组  number：查找的元素
    public static int mySearch(int[] nums,int number){
        //求中间值下标
        int min=0;//最小值下标
        int max=nums.length-1;//最大值下标
        while (max>=min) {//最小值  大于最大值下标 不用循环
            int mid=(min+max)/2;//求中间值的下标
            if(number<nums[mid]){
                max=mid-1;
            }else if(number>nums[mid]){
                min=mid+1;
            }else {
                return mid;//查到元素下标
            }
        }
        return -1;//表示没有找到，返回-1；

    }
    

 给个小星星支持一下！下期更新快速排序。