Java基础练习（十二）集合与数组工具类使用，BigDecimal使用，实现二分查找，快速排序

1、使用Collections中的方法，完成List集合的排序，然后反转。

public class Test {
    public static void main(String[] args) {
        List list= Arrays.asList(1,2,5,9,0,6,8,44,1);
        Collections.sort(list);
        Collections.reverse(list);
        System.out.println(list);
        for(Object o:list){
            System.out.print(o+",");
        }
    }
}

2、已知：

数字1：3.141872872637276738268736872
数字2：4.287827398278372873982732998
（1）求和
（2）求差
（3）求积
（4）相除，保留5位小数，采用四舍五入的方式舍入。

public class Test02 {
    public static void main(String[] args) {
        BigDecimal bigDecimal = new BigDecimal("3.141872872637276738268736872");
        BigDecimal bigDecimal1 = new BigDecimal("4.287827398278372873982732998");

        System.out.println(bigDecimal.add(bigDecimal1));//加
        System.out.println(bigDecimal.subtract(bigDecimal1));//减
        System.out.println(bigDecimal.multiply(bigDecimal1));//乘
        System.out.println(bigDecimal.divide(bigDecimal1, 5, BigDecimal.ROUND_HALF_UP));//除

    }
}

3、编写方法，实现二分查找法。

（1）使用二分查找法，从一个int数组中查找目标元素，最后返回元素的下标。如果没有返回-1。
（2）使用二分查找法，从一个List中查找目标元素，最后返回元素的下标。如果没有返回-1。

错误案例：最后返回的是查找的数单独成的数组，下标当然一直为0了；

public class Erfenchazhao {
    public static void main(String[] args) {
        int[] a={1,2,3,4,5,6};
        System.out.println(erfenSearch(a, 6));
    }

    public static int erfenSearch(int[] a,int num){
        boolean blag=true;
        for (int i:a){
            if(num==i){
                blag=false;
                break;
            }
        }
        if(blag){
            return -1;
        }
       return  erfen(a, num)[0];
    }

    //使用新的数组接收到一半的一半，。。。找到了目标，丢掉了其他数据，返回的是一个值、、丢了N-1个数据
    //重点是二分查找（折半查找）没有改变集合或者数组中的东西，只是查找元素对应下标
    public static   int[] erfen(int[] a,int num){
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        int i=0;

        i=a.length/2;

        int b[];
        b=new int[a.length/2];

        if (i==0){
            b=new int[1];
        }


        int[] c=new  int[1];
        int bi=0;
        if(num>a[i]){
            if (i%2==0){
                for (int j = a.length/2+1; j <a.length ; j++) {
                    b[bi]=a[j];
                    bi++;
                }
                return erfen(b,num);
            }else {
                for (int j = a.length/2; j <a.length ; j++) {
                    b[bi]=a[j];
                    bi++;
                }
                return erfen(b,num);
            }

        }else if(num<a[i]){
            for (int j = 0; j <a.length/2 ; j++) {
                b[bi]=a[j];
                bi++;
            }
            return erfen(b,num);
        }else  if(num==a[i]){
            c[0]=i;
            return c;
        }
        return erfen(b,num);
    }
}

（1）：

import java.util.Arrays;

public class ErfenInt {

    public static void main(String[] args) {
        ErfenInt erfenInt = new ErfenInt();

        int[] nums={9,1,1,1};
        Arrays.sort(nums);
        //排序后查找
        System.out.println(erfenInt.binarySearch(nums, 1));
        System.out.println(erfenInt.left_bound(nums, 1));
        System.out.println(erfenInt.right_bound(nums, 1));
    }
    //二分查找建立在已经排好序之后
    //查找思路：取数组中间值与目标值比较，目标大于中间值则在这个数组中间值下标加1到最后找
    //小于则在则在这个数组中间值下标减1到前面找，重复这个过程，
    //两端为闭区间，每次在[left,right]中查找,改变的是数组元素下标，数组长度没变

    int binarySearch(int[] nums,int target){
        int left=0;//
        int right=nums.length-1;

        while (left<=right){

            //mid（索引）需要加上left，防止图书馆丢了n-1本书
            int mid =(right-left)/2+left;

            if(nums[mid]==target){
                return mid;
            }else if(nums[mid]<target){
                left=mid+1;
            }else if (nums[mid]>target){
                right=mid-1;
            }
        }
        return -1;
    }

    //每次在[left,right)中查找,（1,2,2,2），找第一个2，最左边的
    int left_bound(int[] nums,int target){
        int left=0;//
        int right=nums.length-1;

        while (left<=right){

            int mid=(right-left)/2+left;

            if(nums[mid]==target){
               right=mid-1;
            }else  if (nums[mid]>target){
                right=mid-1;
            }else  if(nums[mid]<target){
                left=mid+1;
            }
        }
        System.out.println(left);
        if(left>=nums.length || nums[left]!=target)
            return -1;

        return left;
    }
//每次在（left,right]中查找,（1,2,2,2），找最后一个2，最右边的
    int right_bound(int[] nums,int target){
        int left=0;
        int right=nums.length-1;

        while (left<=right){
            int mid=(right-left)/2+left;

            if(nums[mid]==target){
                left=mid+1;
            }else  if (nums[mid]>target){
                right=mid-1;
            }else  if(nums[mid]<target){
                left=mid+1;
            }
        }
        if(right<0||nums[right]!=target){
            return -1;
        }
        return right;
    }
}

（2）：

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class ErfenString {
    int binarySearch(List<String> list, String target){
        int left=0;
        int right=list.size()-1;

        while (left<=right){
            int mid=left+(right-left)/2;
            if (list.get(mid).equals(target)){
                return mid;
            }else if(list.get(mid).compareTo(target)>0){
                right=mid-1;
            }else {
                left=mid+1;
            }
        }
        return  -1;
    }

    public static void main(String[] args) {
        String[] strings={"1","2","4","3"};

        List<String> list = Arrays.asList(strings);
        Collections.sort(list);
        list.forEach((o)->{
            System.out.println(o);
        });
        System.out.println(new ErfenString().binarySearch(list, "3"));
    }
}

4、编写方法，实现快速排序。

（1）使用快速排序，对int数组进行由小到大排序。
（2）使用快速排序，对List进行由大到小排序。

（1）

public class IntQuickSort {
    public static void main(String[] args) {
        IntQuickSort intQuickSort = new IntQuickSort();

        int[] nums={9,1,1,1};

        intQuickSort.quickSort(nums);
        for(int i:nums){
            System.out.println(i);
        }

    }
    //寻找基点
    int partition(int[] nums, int start, int end) {

        int temp = nums[start];

        while (start < end) {
            while (start < end && nums[end] >= temp) {
                end--;
            }
            nums[start] = nums[end];
            while (start < end && nums[start] <= temp) {
                start++;
            }
            nums[end] = nums[start];
        }

        nums[start] = temp;
        return start;
    }

    //递归
    void quick(int[] nums, int start, int end) {

        if (start >= end) {
            return;
        }

        int parvio = partition(nums, start, end);

        quick(nums, 0, parvio - 1);
        quick(nums, parvio + 1, end);
    }
 
    void quickSort(int[] nums){
        quick(nums,0,nums.length-1);
    }
}

(2)

import java.util.Arrays;
import java.util.List;

public class StringQuickSort {
    public static void main(String[] args) {
        String[] s={"b","a","c"};
        List<String> list = Arrays.asList(s);
        new StringQuickSort().quickSort(list);

        list.forEach((o)->{
            System.out.println(o);
        });
    }
    int partition(List<String> list,int start,int end){
        String s=list.get(0);

        while (start<end){
            while (start<end && list.get(end).compareTo(s)>=0){
                end--;
            }
            list.set(start,list.get(end));
            while (start<end && list.get(start).compareTo(s)<=0 ){
                start++;
            }
            list.set(end,list.get(start));
        }

        list.set(start,s);
        return  start;
    }

    void quick(List<String> list,int start,int end){
        if(start>=end){
            return;
        }

       int parvio = partition(list, start, end);

        quick(list, 0, parvio - 1);
        quick(list, parvio + 1, end);
    }
    void quickSort(List<String> list){
        quick(list,0,list.size()-1);
    }
}