Java数组练习题

---

前言

本章是一些基础的数组练习题，由Java进行编译。

1、求数组中元素的平均值

给定一个整型数组, 求平均值

代码展示：

public static double avg(int[] array) {
       int sum = 0;
       for (int i = 0;i < array.length;i++) {   //array.length --> 数组长度
           sum = sum+array[i];
       }
       return sum*1.0 / array.length;
   }  ////此处1.0要注意   也可强制类型转换  return(double)sum / (double)arr.length

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

运行结果：

2、查找数组中指定元素

1.顺序查找

给定一个数组, 再给定一个元素, 找出该元素在数组中的位置.

代码展示：

public static int search(int[] array,int key) {
        for (int i = 0; i < array.length; i++) {  
            if (array[i] == key) {
                return i;
            }
        }
        return -1;  //返回值 因为数组下标没有负数
    }
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        int index = search(array,4);   //（array,数字）输入你想找的数字的下标
        if (index == -1) {
            System.out.println("没有你要找的关键字！");
        }else {
            System.out.println("找到了你要的关键字，下标是："+index);
        }
    }

运行结果：

2.二分查找

针对有序数组, 可以使用更高效的二分查找.

啥叫有序数组?
有序分为 “升序” 和 “降序”
如 1 2 3 4 , 依次递增即为升序
如 4 3 2 1 , 依次递减即为降序
以升序数组为例, 二分查找的思路是先取中间位置的元素, 然后使用待查找元素与数组中间元素进行比较：
1.如果相等，即找到了返回该元素在数组中的下标
2.如果小于，以类似方式到数组左半侧查找
3.如果大于，以类似方式到数组右半侧查找

代码展示：

public static int binarySearch(int[] array, int key) {
        int left = 0;
        int rigth = array.length - 1;
        while (left <= rigth) {
            int mid = (left + rigth) / 2;   
            if (array[mid] < key) {     
                left = mid + 1;        //从右侧区间继续找    
            }else if (array[mid] == key) {
                return mid;           //找到了
            }else {
                rigth = mid - 1;      //从左侧区间继续找
        }
    }
    return-1;     //返回值 因为数组下标没有负数
}

    public static void main(String[] args) {
        int[] array = {12,24,3,8,6};
        int index = binarySearch(array,8);  //输入数组中你想要找的数
        if (index == -1) {
            System.out.println("没有你要找的关键字！");
        }else {
            System.out.println("找到了你要的关键字，下标是："+index);
        }
    }

运行结果：

如果是无序数组，可先将无序数组变为有序数组再使用二分法，这里用到的是Array.sort方法。

代码展示：

public static int binarySearch(int[] array, int key) {
        for (int i = 0; i < array.length; i++) {
            if (array[i] == key) {
                return i;
            }
        }
        return -1;  
    }

    public static void main(String[] args) {
        int[] array = {12,24,3,8,6};
        Arrays.sort(array);     //该方法排序主要为快速排序和优化的归并排序。
        System.out.println("排序之后的数组"+Arrays.toString(array));
        int index = binarySearch(array,8);
        if (index == -1) {
            System.out.println("没有你要找的关键字");
        }else {
            System.out.println("找到了你要的关键字，下标是"+index);
        }
    }

运行结果：

3、数组排序(完整冒泡排序逐级优化)

给定一个数组, 让数组升序 (降序) 排序.

动态图：

1.初级

代码展示：

public static void main(String[] args) {
        int[] array = {12, 24, 3, 8, 6};
        for (int i = 0; i < array.length - 1; i++) {     //[0--length-1)  i表示趟数
            for (int j = 0; j < array.length - 1 - i; j++) {  // -i表示了优化 可以不减
                if (array[j] > array[j + 1]) {    //判断大小
                    int temp = array[j];
                    array[j] = array[j + 1];    //这三条语句实现交换
                    array[j + 1] = temp;
                }
            }
        }
        System.out.println("从小到大排序的结果是");
        for (int i = 0; i < array.length; i++) {   //for循环实现依次打印每个数
            System.out.print(array[i] + " ");
        }

运行结果：

2.使用Array.toString简化

最后实现打印可以使用Array.toString方法
System.out.println("从小到大排序后的结果是: "+Arrays.toString(array));
使用时要在开头加 import java.util.Arrays; 自动导包不计
Array.toString方法实现的功能： （打印字符串）

代码展示：

public static void main(String[] args) {
        int[] array = {12, 24, 3, 8, 6};
        for (int i = 0; i < array.length - 1; i++) {    
            for (int j = 0; j < array.length - 1 - i; j++) {   
                if (array[j] > array[j + 1]) {   
                    int temp = array[j];
                    array[j] = array[j + 1];    
                    array[j + 1] = temp;
                }
            }
        }
       System.out.println("从小到大排序后的结果是: "+Arrays.toString(array));

运行结果：

3.完整冒泡排序

由于一些数组中的数字经过一次或者两次交换排序之后就结束了，所以就可以省略后面的交换比较过程。接下来使用一个if语句完成最佳的冒泡排序。

代码展示：

public static void main(String[] args) {
        int[] array = {12, 24, 3, 8, 6};
        for (int i = 0; i < array.length - 1; i++) {    
            boolean flg = false;    //布尔型（boolean）它的取值只能是常量true或者false
            for (int j = 0; j < array.length - 1 - i; j++) {    
                if (array[j] > array[j + 1]) {      
                    int temp = array[j];
                    array[j] = array[j + 1];  
                    array[j + 1] = temp;
                    flg = true; //打个比方 2 1 3 4 5 最开始flg=false 2大于1进行了一次交换之后
                }             //flg=true  之后2不大于3  不再进行交换
            }
            if (flg == false){
                break;
            }
        }
       System.out.println("从小到大排序后的结果是: "+Arrays.toString(array));

运行结果：

4、数组的逆序

给定一个数组, 将里面的元素逆序排列

设定两个下标, 分别指向第一个元素和最后一个元素. 交换两个位置的元素.
然后让前一个下标自增, 后一个下标自减, 循环继续即可

代码展示：

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

    public static void main(String[] args) {
        int[] array1 = {12,24,3,8,6};
        System.out.println("逆置之前的数组："+ Arrays.toString(array1));
        reverse(array1);
        System.out.println("逆置之后的数组："+ Arrays.toString(array1));

    }

代码过程：

运行结果：