数组---拷贝 查找 排序 冒泡排序（5）

数组转成字符串

//         查看数组的内容，希望可以更方便的查看
//         就可以把数组内容按照一定格式组织成一个字符串
          int[] arr = {1, 2, 3, 4};
          System.out.println(Arrays.toString(arr));

[1, 2, 3, 4]

Process finished with exit code 0

数组拷贝

        int[] arr = {1, 2, 3, 4};
        int[] result = copyOf(arr);
        System.out.println(Arrays.toString(result));


    }

    public static int[] copyOf(int[] arr) {
        int[] newArr = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            newArr[i] = arr[i];

        }
        return newArr;

    }

       int[] arr = {1, 2, 3, 4};
//        int[] result = copyOf(arr);
        int[] result  = Arrays.copyOf(arr,arr.length);
        System.out.println(Arrays.toString(result));

找数组的最大元素/最小元素

        int[] arr = {5, 3, 7, 8, 9, 6};
        int maxValue = max(arr);
        System.out.println(maxValue);
    }

    public static int max(int[] arr) {
        int result = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > result) {
                result = arr[i];
            }
        }
              return result;

求平均值

        int[] arr = {5, 3, 7, 8, 9, 6};
        double avgValue = avg(arr);
        System.out.println(avgValue);
    }

    public static double avg(int[] arr) {
        int sum = 0 ;
        for(int x : arr){
//            将数组arr的值循环赋值给x
            sum+=x;

        }
//        强制类型转换
      return (double)sum/arr.length;
    }

查找数组中的指定元素

        int[] arr = {5, 3, 7, 8, 9, 6};
        int pos = search(arr,3);
        System.out.println(pos);
    }

     public static int search(int[] arr, int toSearch){
//        需要依次遍历访问元素
         for (int i = 0 ;i < arr.length;i++){
             if(arr[i]==toSearch){
                 return i ;
             }
         }

         return -1;
     }

二分查找/折半查找

必须保证数组是有序的

本质在于，拿待查找区间的中间元素，和待查找元素进行比较，每次比较都能够砍掉一半的区间

代码👇

        int[] arr = {3,4,5,6,9,10,11};
        int pos = binarySearch(arr,3);
        System.out.println(pos);
    }

    public static int binarySearch(int[] arr, int toSearch) {
//        [left right]
        int left = 0;
        int right = arr.length - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (toSearch < arr[mid]) {
//                在左侧区间中查找 排除右侧区间
                right = mid - 1;
            } else if (toSearch > arr[mid]) {
//                在右侧区间查找 排除左侧区间
                left = mid + 1;
            } else {
//                相等的情况
                return mid;
            }
        }
        return -1;
    }

检查数组是否有序

           int[]arr={2,3,5,8,10,13,19};
        System.out.println(isSortde(arr));

    }

    public static boolean isSortde(int[] arr) {
        for (int i = 0; i < arr.length-1; i++) {
//            i+1<arr.length = i< arr.length-1
            if (arr[i] > arr[i + 1]) {
//                反例 不符合升序
                return false;
            }

        }
        return true;

冒泡排序

       int[] arr = {9,5,2,7,3,6};
       bubbleSort(arr);
//        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));

    }

    public static void bubbleSort(int[] arr) {
//        从后往前遍历的版本
//        外层循环控制遍历次数
//        已排序区间：[0,bound)
//        待排序区间：[bound,length)
        for (int bound = 0; bound<arr.length;bound++){
//            里层循环控制比较交换
            for(int cur = arr.length-1; cur>bound;cur--){
                if(arr[cur-1] > arr[cur]) {
//                    不符合排序要求 交换
                    int tmp = arr[cur-1];
                    arr[cur-1] = arr[cur];
                    arr[cur] = tmp;

数组逆序 

逆序是要修改数组的内容，而不是反向打印   

代码如下👇

       int[] arr = {9,5,2,7,3,6};
       reverse(arr);
        System.out.println(Arrays.toString(arr));
        
    }

    public static void reverse(int[] arr) {
        int left = 0;
        int right =arr.length-1;
        while(left < right){
            int tmp = arr[left];
            arr[left]=arr[right];
            arr[right]=tmp;

            left++;
            right--;

        }
    }

[6, 3, 7, 2, 5, 9]

奇偶排序 偶数放左边 奇数放右边  代码如下👇

       int[] arr = {9,5,2,7,3,6};
       transform(arr);
        System.out.println(Arrays.toString(arr));

    }

    public static void transform(int[] arr) {
        int left = 0;
        int right = arr.length-1;
        while(left<right){
//            先从左往右找到一个奇数
            while(left < right && arr[left]%2==0){
                left++;
            }
//            再从右往左找一个偶数
            while (left < right && arr[right]%2!=0){
                right--;
            }
//            交换left 和 right
            int tmp = arr[left];
            arr[left] = arr[right];
            arr[right]=tmp;

[6, 2, 5, 7, 3, 9]