超实用：数组练习（一）

1.求数组的平均值

实现一个方法 avg，以数组为参数，求数组中所有元素的平均值(注意方法的返回值类型）

public class Exercise {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        System.out.println(avg(arr));
    }

    public static double avg(int[] arr) {
        int sum = 0;
        for (int i : arr) {
            sum += i;
        }
        return sum / (double) arr.length;
    }
}

//执行结果为
5.5

2.求数组元素之和

实现一个方法 sum，以数组为参数，求数组所有元素之和

public class Exercise {
    public static void main(String[] args) {
        int[] arr = {2,4,5,6,7,8};
        System.out.println(sum(arr));
    }

    public static int sum(int[] arr) {
        int num = 0;
        for (int i : arr) {
            num += i;
        }
        return num;
    }
}

//执行结果为
32

3.判断数组是否有序

给定一个整型数组，判定数组是否有序（默认升序）

public class Exercise {
    public static void main(String[] args) {
        int[] arr1 = {1,3,5,6,7,9};
        int[] arr2 = {4,3,5,2,7,9};
        System.out.println(isSorted(arr1));
        System.out.println(isSorted(arr2));
    }

    public static boolean isSorted(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                return false;
            }
        }
        return true;
    }
}

//执行结果为
true
false

4.二分查找（****）

给定一个有序整型数组，实现二分查找

public class Exercise {
    public static void main(String[] args) {
        int[] arr = {1,4,6,7,8,9,13,15};
        System.out.println(binarySearch(arr,13));
        System.out.println(binarySearch(arr,16));
    }

    public static int binarySearch(int[] arr,int toFind) {
        int left = 0;
        int right = arr.length - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (toFind < arr[mid]) {
                right = mid - 1;
            }else if (toFind > arr[mid]) {
                left = mid + 1;
            }else {
                System.out.println("找到元素");
                return mid;
            }
        }
        return -1;
    }
}

//执行结果为
找到元素
6
-1

注意：在有序的集合上才能用二分查找。 

思想：在有序区间中查找一个元素，不断比较待查找元素和区间中间位置元素的大小关系，如果待查找元素小于中间元素，说明待查找元素在中间位置的左边即左区间，使right=mid-1后继续在左区间判断查找；如果待查找元素大于中间元素，说明待查找元素在右边即右区间，使left=mid+1后继续在右区间判断查找；如果刚好等于即找到元素。

二分查找的递归写法： 

public class Exercise {
    public static void main(String[] args) {
        int[] arr = new int[] {1,3,2,4,6,5,8,7};
        System.out.println(binarySearchRecursion(arr,6,1,7));
    }
    public static int binarySearchRecursion(int[] arr,int toFind,int left,int right) {
        if (left > right) {
            //空区间
            return -1;
        }
        int mid = (left + right) / 2;
        if (arr[mid] == toFind){
            return mid;
        }else if (toFind < arr[mid]) {
            return binarySearchRecursion(arr,toFind,left,mid - 1);
        }
        return binarySearchRecursion(arr,toFind,mid + 1,right);
    }

//执行结果为
4

5.数组转字符串

实现一个方法 toString，把一个整型数组转换成字符串。例如数组 {1, 2, 3} , 返回的字符串为 "[1, 2, 3]"，注意逗号的位置和数量

public class Exercise {
    public static void main(String[] args) {
        int[] arr = {1,4,6,7,8,9};
        System.out.println(toString(arr));
    }

    public static String toString(int[] arr) {
        String ret = "[";
        for (int i = 0; i < arr.length; i++) {
            ret += arr[i];
            if (i != arr.length - 1) {
                ret += ",";
            }
        }
        ret += "]";
        return ret;
    }
}


//执行结果为
[1,4,6,7,8,9]

6.求两数之和（****）

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

示例 1：输入：nums = [2,7,11,15], target = 9     输出：[0,1]

public class Exercise {
    public static void main(String[] args) {
        int[] nums = {2,7,11,15};
        int[] ret = find(nums,9);
        System.out.println(Arrays.toString(ret));
    }

    public static int[] find(int[] nums,int target) {
        int[] ret = new int[2];
        for (int i = 0; i < nums.length; i++) {
            for (int j = nums.length - 1; j > i; j--) {
                if (nums[i] + nums[j] == target) {
                    ret[0] = i;
                    ret[1] = j;
                }
            }
        }
        return ret;
    }
}

//执行结果为
[0, 1]

7.冒泡排序（****）

给定一个整型数组, 实现冒泡排序(升序排序)

public class Exercise {
    public static void main(String[] args) {
        int[] arr = new int[] {1,3,2,4,5,8,6,9,3,6,10};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void bubbleSort(int[] arr) {
        //外层循环表示一共要遍历的次数，每进行一次遍历就有一个元素到达了最终位置
        for (int i = 0; i < arr.length; i++) {
            //内层循环表示相邻的两两元素之间的大小关系，若前一个大于后一个则交换两者顺序
            for (int j = 0; j < arr.length - 1 -i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

//执行结果为
[1, 2, 3, 3, 4, 5, 6, 6, 8, 9, 10]

代码解释：内层循环 j < arr.length -1 - i

j < arr.length-1：内层循环表示前一个元素和后一个元素进行比较，由于数组中最后一个元素它没有后一个元素，为防止发生越界，j + 1最大可以取到arr.length-1(索引)，所以 j 是小于arr.length - 1的

j < arr.length - 1- i：之所以减 i，是因为外层表示每进行一次遍历就有一个元素到达了最终位置（即该元素已经有序不再进行比较），这样内层循环就会少一次比较，已经有几个元素有序就会少几次比较。当然也可以不减 i，只是又重复比较了已经有序的元素，所以推荐减 i，减少无用的操作。

优化一：当待排序的数组中只剩下一个元素时，整个数组已经有序，外层循环不需要再进行遍历

for（int i = 0; i < arr.length - 1; i ++）{

}

优化二：判断内层循环有没有进行元素的交换，这样对接近有序的数组很有效

public static void bubbleSort(int[] arr) {
        //外层循环表示一共要遍历的次数，每进行一次遍历就有一个元素到达了最终位置
        for (int i = 0; i < arr.length; i++) {
            boolean isSwapped = false;
            //内层循环表示相邻的两两元素之间的大小关系，若前一个大于后一个则交换两者顺序
            for (int j = 0; j < arr.length - 1 -i; j++) {
                if (arr[j] > arr[j + 1]) {
                    isSwapped = true;
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            if (!isSwapped) {
                //内层循环已经没有元素交换，整个数组已经有序，提前退出循环
                break;
            }
        }
    }

---

今天是数组题目练习分享哦~~

谢谢大家~