选择排序,二分查找,Arrays类操作数组的各种方法

选择排序:

         数组的0索引依次和后面的索引进行比较,对应的元素小的往前方法,依次比较,就可以得到一个排好序的数组

public class ArrayDemo {
    
    public static void main(String[] args) {
        
        //定义一个数组,静态初始化
        int[] arr = {24,69,80,57,13} ;
        
        //排序前
        System.out.println("排序前:");
        printArray(arr) ;
        
        /*//第一次比较
        int x = 0 ;
        for(int y = x +1 ;y < arr.length ; y ++){
            //判断
            if(arr[y]<arr[x]){//后面的索引对应的元素小于前面索引对应的元素,互换
                //第三方变量
                int temp = arr[x] ;
                arr[x] = arr[y] ;
                arr[y] = temp ;
            }
        }
        
        System.out.println("第一次比较后:");
        printArray(arr) ;
        
        //第二次比较
        x = 1 ;
        for(int y = x +1 ;y < arr.length ; y ++){
            //判断
            if(arr[y]<arr[x]){
                int temp = arr[x] ;
                arr[x] = arr[y] ;
                arr[y] = temp ;
            }
        }
        System.out.println("第二次比较后:");
        printArray(arr) ;
        
        //第三次比较
        x = 2 ;
        for(int y = x +1 ;y < arr.length ; y ++){
            //判断
            if(arr[y]<arr[x]){
                int temp = arr[x] ;
                arr[x] = arr[y] ;
                arr[y] = temp ;
            }
        }
        System.out.println("第三次比较后:");
        printArray(arr) ;
        
        //第四次比较
        x = 3 ;
        for(int y = x +1 ;y < arr.length ; y ++){
            //判断
            if(arr[y]<arr[x]){
                int temp = arr[x] ;
                arr[x] = arr[y] ;
                arr[y] = temp ;
            }
        }
        System.out.println("第四次比较后:");
        printArray(arr) ;*/
        
        //重复度高,代码臃肿,所以循环改进
    /*    for(int x = 0 ;x < arr.length-1 ;x++){
            for(int y = x +1 ; y<arr.length ; y++){
                //判断
                if(arr[y]<arr[x]){
                    int temp = arr[x] ;
                    arr[x] = arr[y] ;
                    arr[y] = temp ;
                }
            }
        }*/
        
        //调用
        selectSort(arr) ;
        System.out.println("排序后:");
        printArray(arr) ;
    }
    
    //将选择排序的代码封装成一个独立的功能
    public static void selectSort(int[] arr){
        for(int x = 0 ;x < arr.length-1 ;x++){
            for(int y = x +1 ; y<arr.length ; y++){
                //判断
                if(arr[y]<arr[x]){
                    int temp = arr[x] ;
                    arr[x] = arr[y] ;
                    arr[y] = temp ;
                }
            }
        }
    }
    
    //遍历数组的功能
    public static void printArray(int[] arr){
        System.out.print("[");
        //遍历数组
        for(int x = 0 ; x < arr.length ; x ++){
            //判断是否最大索引
            if(x==arr.length-1){
                System.out.println(arr[x]+"]");
            }else{
                System.out.print(arr[x]+", ");
            }
        }
    }
}

之前查找元素第一次在数组中出现的索引,基本查找法(从头查到尾)
  二分查找:针对数组一定有序的!

 
      定义一个数组:
             11,22 ,33 ,44 ,55 ,66 ,77
 
 解决思路:
             1)定义最小索引和最大索引
             2)计算出中间索引
              3)拿中间索引对应的元素和要查找的元素进行比较
                  如果相等:直接返回中间索引
                  不相等:
                      大了,左边找
                      小了,右边找
              4)重新获取最小索引和最大索引,计算出中间索引
             5)回到3)继续查找
 
public class ArrayDemo {
    
    public static void main(String[] args) {
        //定义一个数组,静态初始化
        int[] arr = {11,22,33,44,55,66,77} ;
        
        //需求:查找33元素对应的索引
        int index = getIndex(arr, 33) ;
        System.out.println("index:"+index);
        
        //需求:要查找333元素对应的索引
        //如果查找的这个元素在数组中查不到呢?
        int index2 = getIndex(arr, 333) ;
        System.out.println("index2:"+index2);
    }
    
    /**
     * 两个明确:
     *     明确返回值类型:int类型
     * 明确参数类型,几个参数:int[] arr,int value
     */
    public static int getIndex(int[] arr,int value){
        //定义最大索引和最小索引
        int max = arr.length -1 ;
        int min = 0 ;
        
        
        //计算中间索引
        int mid = (max + min)/2 ;
        
        //拿中间索引对应的元素和要查找的value元素进行比较
        while(arr[mid] !=value){
            //当前mid索引对应的元素不等于value元素,分两种情况
            if(arr[mid]>value){
                //重新获取最大索引
                 max = mid -1 ;
            }else if(arr[mid]<value){
                min = mid +1 ;
            }
            
            //如果找不到了应该返回-1
            //判断
            if(min>max){
                return -1 ;
            }
            
            //重新获取最大和最小索引,计算中间索引
            mid = (max+min)/2 ;
            
        }
        return mid ; //如果直接相等,直接返回
    }
}

Arrays:此类包含用来操作数组（比如排序和搜索）的各种方法(针对数组操作的工具类)
     
      常用的几个方法:
              public static String toString(int[] a):将任意类型的数组以字符串形式显示出来!
             public static void sort(int[] a):快速排序:(将给定数组中元素升序排序)
              public static int binarySearch(int[] a, int key):当前int数组一定是有序数组
                使用二分搜索法来搜索指定的 int 型数组，以获得指定的值

public class ArraysDemo {
    
    public static void main(String[] args) {
        
        //定义一个数组
        int[] arr = {24,69,80,57,13} ;
        //讲数组转成字符串的形式
        System.out.println("toString():"+Arrays.toString(arr));
        //[24, 69, 80, 57, 13]
        
        //public static void sort(int[] a):快速排序:(将给定数组中元素升序排序)
        Arrays.sort(arr) ;
        //在调用Arrays.toString(int[] a):将排好序的数组以String形式显示出来
        System.out.println(Arrays.toString(arr) );
        //[13, 24, 57, 69, 80]
        
        //public static int binarySearch(int[] a, int key)
        //查找57元素在数组中的索引
        int index = Arrays.binarySearch(arr, 57) ;
        System.out.println("index:"+index);
        //需求:查找577这个元素的索引
        int index2 = Arrays.binarySearch(arr, 577) ;
        System.out.println("index2:"+index2);//-6
    }
}