Javase-8.数组的练习

标签：元素 int 练习 public static 数组 Javase array

1.查找数组中指定元素(二分查找)

以升序数组为例 , 二分查找的思路是先取中间位置的元素 , 然后使用待查找元素与数组中间元素进行比较： 如果相等，即找到了返回该元素在数组中的下标 如果小于，以类似方式到数组左半侧查找 如果大于，以类似方式到数组右半侧查找

public static void main(String[] args) {
    int[] array = {2,4,1,23,65,34,89,76,32};
    Arrays.sort(array);//排完升序:1,2,4,23,32,34,65,76,89
//Arrays.sort();这个工具可以顺序打乱的数组排成正序
    System.out.println(binarySearch(array, 89));
}

public static int binarySearch(int[] array,int key) {
    int left = 0;
    int right = array.length - 1;
    int mid = array.length / 2;
    while(left <= right) {
        if(key > array[mid]) {
            left = mid + 1;
            mid = (left + right) / 2;
        }else if(key < array[mid]) {
            right = mid - 1;
            mid = (left + right) / 2;
        }else{
            return mid;
        }
    }
    return -1;
}

2.数组排序(冒泡排序)

算法思路 假设排升序： 1. 将数组中相邻元素从前往后依次进行比较，如果前一个元素比后一个元素大，则交换，一趟下来后最大元素就在数组的末尾 2. 依次进行上述过程,直到数组中所有的元素都排列好

public static void main(String[] args) {
    int[] array = {3,5,1,30,10};
    bubble(array);
    System.out.println(Arrays.toString(array));
}

public static void bubble(int[] array) {
    for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array.length-1; j++) {
            if(array[j] > array[j+1]) {
                int tmp = array[j];
                array[j] = array[j+1];
                array[j+1] = tmp;
            }
        }
    }
}

上述代码已能成功实现数组的排序,但仍能进一步优化,如下图,可以发现当i = 1时,j只从j = 0比较到

j = 2(array.length - 1 - i),下图所示过程不完整,可以自行补充完整,到时就一目了然了.同样是当 i = 1时, i = 1这一趟排序排完之后的顺序就已经排好了, 那么我们其实可以定义一个flg来标记,可能某一趟就把顺序排好直接跳出循环,提高效率.

于是有了如下优化过的代码:

public static void bubble(int[] array) {
    for (int i = 0; i < array.length; i++) {
        boolean flg = false;//排序前将flg赋值为false
        for (int j = 0; j < array.length-1-i; j++) {
            if(array[j] > array[j+1]) {
                int tmp = array[j];
                array[j] = array[j+1];
                array[j+1] = tmp;
                flg = true;//有发生交换就给flg赋为true,说明顺序还没排好
            }
        }
        if(flg == false) {
            break;
        }
    }
}

3.数组逆序

给定一个数组 , 将里面的元素逆序排列 . 思路: 设定两个下标 , 分别指向第一个元素和最后一个元素 . 交换两个位置的元素 . 然后让前一个下标自增 , 后一个下标自减 , 循环继续即可 . 代码示例

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

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

4.奇数位于偶数之前

调整数组顺序使得奇数位于偶数之前。调整之后，不关心大小顺序。

如数组：[1,2,3,4,5,6]

调整后可能是：[1, 5, 3, 4, 2, 6]

本题可以使用2个下标，一个从0下标开始，一个从最后一个下标开始。

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

public static void func(int[] array) {
    int i = 0;
    int j = array.length-1;
    while(i < j) {
        while(i < j && array[i] % 2 != 0) {
            i++;
        }
        while(i < j && array[j] % 2 != 1) {
            j--;
        }
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }
}

5.两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9

输出：[0,1]

解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1]

public static void main(String[] args) {
    int[] array = {2,7,11,15};
    int[] array1 = func(array,9);
    System.out.println(Arrays.toString(array1));
}

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

6.给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

注意:

1、n ^ n = 0；即两个相同的数字异或是0

2、0 ^ n = n；即0和任何数字进行异或，结果就是那个任何数字。

public static void main(String[] args) {
    int[] array = {1,3,3,1,4,8,4};
    int ret = func(array);
    System.out.println(ret);
}

public static int func(int[] array) {
    int ret = array[0];
    for (int i = 1; i < array.length; i++) {
        ret ^= array[i];
    }
    return ret;
}

7.存在连续三个奇数的数组

给你一个整数数组 arr，请你判断数组中是否存在连续三个元素都是奇数的情况：如果存在，请返回 true ；否则，返回 false 。

示例 1：

输入：arr = [2,6,4,1]

输出：false

解释：不存在连续三个元素都是奇数的情况。

示例 2：

输入：arr = [1,2,34,3,4,5,7,23,12]

输出：true

解释：存在连续三个元素都是奇数的情况，即 [5,7,23] 。

思路:数字是连续出现的，所以我们只需要定义一个计数器，如果连续出现的次数超过3，则返回true。

public static void main(String[] args) {
    int[] arr = {2,6,4,1};
    boolean ret = func(arr);
    System.out.println(ret);
    int[] arr1 = {1,2,34,3,4,5,7,23,12};
    boolean ret1 = func(arr1);
    System.out.println(ret1);
}

public static boolean func(int[] array) {
    int count = 0;
    for (int i = 0; i < array.length; i++) {
        if(array[i] % 2 != 0) {
            count++;
        }
        if(count == 3) {
            return true;
        }
    }
        return false;
}

标签：元素,int,练习,public,static,数组,Javase,array
From： https://blog.csdn.net/2302_81886858/article/details/140522250