作者：敲代码の流川枫

博客主页：流川枫的博客

专栏：和我一起学java

语录：Stay hungry stay foolish

工欲善其事必先利其器，给大家介绍一款超牛的斩获大厂offer利器——牛客网

点击免费注册和我一起刷题吧  

文章目录

1. 二分查找

2. 两数之和

3. 只出现一次的数字

4. 多数元素

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

6. 奇数位于偶数之前

7. 求数组的平均值

8. 改变原有数组元素的值

---

1. 二分查找

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

 解题思路：

 

代码：

public class Test {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6,7,8,9,10};
        int ret = binarySearch(array,9);
        System.out.println("找到了下标为："+ret);
    }
    public static int binarySearch(int[] array,int key){
        int right = array.length-1;
        int left = 0;
 
        while(left<=right){
            int mid = (left+right)/2;
            if(array[mid] == key){
                return mid;
            } else if (mid
                left = mid+1;
            }else {
                right = mid-1;
            }
        }
        return -1;
    }
}

2. 两数之和

给定一个整数数组 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={1,3,6,7,9};
        int a = 8;
        sumnums(array,a);
        System.out.println(Arrays.toString(sumnums(array,a)));
    }
    public static int[] sumnums(int[] array,int target){
            int[] result = new int[2];
            for (int i=0;  i < array.length-1 ; i++) {
                for (int k = array.length-1; k>i; k--) {
                    if((array[i]+array[k])==target){
                       result[0] = i;
                       result[1] = k;
                    }
                }
            }
        return result;
    }
}

3. 只出现一次的数字

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

示例 1:
 
输入: [2,2,1]
输出: 1

示例 2:
 
输入: [4,1,2,1,2]
输出: 4

 解题思路：

异或的特点是：

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

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

用异或运算的性质可以巧妙的解决这个问题，因为数组中只有一个数字出现一次

其他出现两次的数字用异或运算后都是0，最终整个数组异或运算的结果即为所求

代码：

public class Test {
    public static void main(String[] args) {
 
        int[] array = {2,2,1,1,3};
        int ret1 = onlynum(array);
        System.out.println(ret1);
    }
    public static int onlynum(int[] array){
        int ret=0;
        for (int i:array
             ) {
            ret^=i;
        }
        return ret;
    }
}

4. 多数元素

给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

示例 1：
 
输入：[3,2,3]
输出：3

示例 2：
 
输入：[2,2,1,1,1,2,2]
输出：2

解题思路：

给定的数组总是存在多数元素，意味着排好序之后，中间位置的数字一定是出现了大于 ⌊ n/2 ⌋ 的元素

import java.util.Arrays;
 
public class Test {
 
    public static void main(String[] args) {
        int[] array = {1,1,1,1,2,3};
        int ret = majorityElement(array);
        System.out.println(ret);
    }
    public static int majorityElement(int[] nums) {
        Arrays.sort(nums);
        return nums[nums.length/2];
    }
}
 

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

给你一个整数数组 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 ，注意这里count在遇见是偶数的情况时进行置零，不然判断的时整个数组有没有三个奇数

代码：

public class Test {
    public static void main(String[] args) {
        int[] array = {1,2,3,5,7};
        boolean a = threenumisOdd(array);
        System.out.println(a);
    }
    public static boolean threenumisOdd(int[] array){
        int count = 0;
        for (int i = 0; i < array.length; i++) {
            if(isOdd(array[i])) {
                count++;
                if (count == 3) {
                    return true;
                }
            }
            else {
                count = 0;
            }
        }
        return false;
    }
    public static boolean isOdd(int num){
        return (num%2!=0);
    }
 
}

6. 奇数位于偶数之前

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

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

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

解题思路：

使用2个下标，一个从0下标开始，一个从最后一个下标开始，左边下标寻找偶数，找到后右边下标寻找奇数，然后交换

为了防止出现全为奇数的情况，i>j越界，要注意循环条件加上i

 代码：

 
import java.util.Arrays;
 
public class Test {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6};
       fun(array);
        System.out.println(Arrays.toString(array));
    }
    public static void fun(int[] array){
        int i = 0;
        int j = array.length - 1;
        while(i < j){
            int tmp=0;
            while(i < j && array[i] % 2 != 0){
                i++;
            }
            while(i < j && array[j] % 2 == 0){
                j--;
            }
            tmp = array[j];
            array[j] = array[i];
            array[i] = tmp;
        }
    }
}

7. 求数组的平均值

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

需要注意，平均值可能是小数

代码：

public class Test {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6,7};
        System.out.println(avg(array));
    }
    public static double avg(int[] array){
        int sum=0;
        for (int i = 0; i < array.length; i++) {
            sum+=array[i];
        }
        return (sum*1.0/array.length);
    }
}

8. 改变原有数组元素的值

实现一个方法 transform, 以数组为参数, 循环将数组中的每个元素 乘以 2 , 并设置到对应的数组元素上. 例如 原数组为 {1, 2, 3}, 修改之后为 {2, 4, 6}

两种方式，一种是在自己本身上进行扩大，一种是新的数组中扩大

import java.util.Arrays;
 
public class Test {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        func1(array);
        System.out.println(Arrays.toString(array));
    }
 
//方式一：扩大的还是原来的数组，这样做的不好的地方是，改变了原来数组的值
    public static void func1(int[] array) {
 
          for (int i = 0; i < array.length; i++) {
 
              array[i] = array[i]*2;
 
          }
 
      }
 
 
//方式二：扩大的新的数组，没有修改原来的值
    public static int[] func2(int[] array) {
 
        int[] tmp = new int[array.length];//
 
        for (int i = 0; i < array.length; i++) {
 
            tmp[i] = array[i]*2;
     
        }
        return tmp;
    }
 
}

 “ 本期的分享就到这里了， 记得给博主一个三连哈，你的支持是我创作的最大动力！