JavaSE——数组习题
作者：敲代码の流川枫
博客主页：流川枫的博客
专栏：和我一起学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
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 代码： 实现一个方法 avg, 以数组为参数, 求数组中所有元素的平均值(注意方法的返回值类型). 需要注意，平均值可能是小数 代码： 实现一个方法 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,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. 求数组的平均值
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. 改变原有数组元素的值
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;
}
}