Java 冒泡/选择/快速排序及二分查找

冒泡排序
时间复杂度为:O(n^2)

public class BubbleSort {
/**
 * N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i)次，所以可以用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数。
 * @param args
 */
    public static void main(String[] args) {
        int arr[] = {26,15,29,66,99,88,36,77,111,1,6,8,8};
        for(int i=0;i < arr.length-1;i++) {//外层循环控制排序趟数
            for(int j=0; j< arr.length-i-1;j++) {
                        //内层循环控制每一趟排序多少次
                // 把小的值交换到前面
                if (arr[j]>arr[j+1]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            System.out.print("第"+(i+1)+"次排序结果：");
                                //列举每次排序的数据
            for(int a=0;a<arr.length;a++) {
                System.out.print(arr[a] + "\t");
            }
            System.out.println("");
        }
        System.out.println("最终排序结果：");
        for(int a = 0; a < arr.length;a++) {
            System.out.println(arr[a] + "\t");
        }
    }
}

选择排序：（比冒泡排序更快，运行次数更少）
时间复杂度为:O(n^2)

public class SelectSort
{
    public static void main(String[] args)
    {
        int[] arr={20,60,51,81,285,12,165,51,81,318,186,9,70};
        arr=toSort(arr);
        for(int a:arr)
        {
            System.out.print(a+" ");
        }
        
//    排序
    public static int[] toSort(int[] arr)
    {
//遍历数组里除最后一个的其他所有数，因为最后的对象没有与之可以相比较的数（到最后一个元素时顺序已经排好了）
        for(int i=0;i<arr.length-1;i++)
        {
/*遍历数组里没有排序的所有数，并与上一个数进行比较
 *“k=i+1”因为自身一定等于自身，所以相比没有意义
 *而前面已经排好序的数，在比较也没有意义
 */
            for(int k=i+1;k<arr.length;k++)
            {
                if(arr[k]<arr[i])//交换条件（排序条件）
                {
                    int number=arr[i];
                    arr[i]=arr[k];
                    arr[k]=number;
                }//交换
            }
        }
        return arr;
    }
}

快速排序
时间复杂度为:O(nlog2 n) 希尔 堆也是如此

public class QuickSort {
    public static void main(String[] args) {
        int[] nums ={19,97,9,17,1,8};
        quickSort(nums,0,nums.length-1);
        System.out.println(Arrays.toString(nums));
    }
    public static void quickSort(int nums[],int begin,int end){
        if (begin<end){
            int temp=nums[begin];//把第一个数作为基准数
            int i=begin;//左边位置
            int j=end;//右边位置
            //不重复遍历
            while (i<j){
                //当右边的数大于基准数时，略过，继续向左查找
                // 不满足条件时跳出循环，此时的j对应的元素是小于基准元素的
                while (i<j&&nums[j]>temp){
                    j--;
                }
                //将右边小于等于基准元素的数填入右边相应位置
                nums[i]=nums[j];
                //当左边的数小于等于基准数时，略过，继续向右查找
                //(重复的基准元素集合到左区间)
                //不满足条件时跳出循环，此时的i对应的元素是大于等于基准元素的
                while (i<j&&nums[i]<=temp){
                    i++;
                }
                //将左边大于基准元素的数填入左边相应位置
                nums[j]=nums[i];
            }
            //将基准元素填入相应位置
            nums[i] = temp;
            //此时的i即为基准元素的位置
            //对基准元素的左边子区间进行相似的快速排序
            quickSort(nums,begin,i-1);
            //对基准元素的右边子区间进行相似的快速排序
            quickSort(nums,i+1,end);
        }else {
            return;
        }
    }
}

二分查找
    二分查找在最坏的情况下依次是n/2,n/4,n/8。。。。 一直到1为止

时间复杂度为:O(log2 n)

public class twoPoints {
    public static void main(String[] args) {
        int[]arr={4,2,1,3,5,10};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入数字:");
        int value=sc.nextInt();
        int min=0,max=arr.length-1,mid=0;
        int index1=recursionBinarySearch(arr,value,min,max);
        int index2=cycleBinarySearch(arr,value,min,max);
        System.out.println(index1);
        System.out.println(index2);
    }

    private static int cycleBinarySearch(int[] arr, int value, int min, int max) {
     	if (value<arr[min]||value>arr[max]){
            return -1;
        }
        while (min<=max){
            int mid=(max+min)/2;
            if (arr[mid]>value){
                max=mid-1;
            }else if(arr[mid]<value){
                min=mid+1;
            }else {
                return mid;
            }
        }
        return -1;
    }

    private static int recursionBinarySearch(int[] arr, int value, int min, int max) {
        if (value<arr[min]||value>arr[max]||min>max){
            return -1;
        }
        int mid=(max+min)/2;
        if (arr[mid]>value){
            return recursionBinarySearch(arr,value,min,mid-1);
        }else if(arr[mid]<value){
            return recursionBinarySearch(arr,value,min+1,max);
        }else {
            return mid;
        }
    }
}