bilibiliJava学习数组（完）+有点难度的练习（比昨天难）

郭源潮859

已于 2023-08-01 11:29:46 修改

阅读量55

点赞数

文章标签：学习

于 2023-07-28 13:06:35 首次发布

本文链接：https://blog.csdn.net/weixin_74385523/article/details/131975005

版权

上节的东西

1.冒泡排序

初始

第一趟

第二趟

第三趟，其实已经有序了，但是程序不知道

比较最后一趟

总共有五个数据，比较四趟

public static void bubbleSort(int[] array) {
    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 tmp = array[j];
                array[j] = array[j+1];
                array[j + 1] = tmp;
            }
        }
    }
}
public static void main(String[] args) {
    int[] array = {12,15,95,874,5562,15,3565};
    bubbleSort(array);
    System.out.println(Arrays.toString(array));
}

假设在第二趟已经有序了，进行第三趟以后咋让她不进行第四趟多出来的呢？

加入boolean，进行优化

public static void bubbleSort(int[] array) {
    for (int i = 0; i < array.length - 1; i++) {
        boolean 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;
            }
        }
        if(flg == false){
            return;
        }
    }
}

2.二维数组

定义二维数组

打印二维数组

public static void main(String[] args) {
    //两行三列的二维数组
    int[][] array1 = new int[2][3];
    for(int i = 0; i < 2; i++){
        for (int j = 0; j < 3; j++) {
            System.out.print(array1[i][j] + " ");
        }
        System.out.println( );
    }

------------------------------------------------------------------------------------------

System.out.println(Arrays.toString(array1));
结果[[I@312b1dae, [I@7530d0a]

这样打印是不行的，需要用到

System.out.println(Arrays.deepToString(array1));

在java中的二维数组其实是特殊的一维数组

之前学过当直接打印一个一维数组的时候，就会出来它的地址

相应的我要是打印二维数组的某一行一列

System.out.println(Arrays.toString(array1[1]));
[0, 0, 0]

就会出来结果

在java中的二维数组其实是特殊的一维数组

那么根据这个道理就不需要去数这个二维数组的行数列数了，打印的时候直接这样

public static void main(String[] args) {
    //两行三列的二维数组
    int[][] array1 = new int[2][3];
    for(int i = 0; i < array1.length; i++){
        for (int j = 0; j < array1[i].length; j++) {
            System.out.print(array1[i][j] + " ");
        }
        System.out.println( );
    }

------------------------------------------------------------------------------------------------------------------

用for each来打印

for (int[] arr:
     array1) {
    for (int x:
         arr) {
        System.out.print(x + " ");
    }
    System.out.println();
}

不规则数组

int[][] array2 = new int[2][];
array2[1] = new int[2];
array2[2] = new int[5];

行必须指定，列可以不指定

当这个时候输出的时候，他们的值就是null

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

public static void transform(int[] array){
    for (int i = 0; i < array.length; i++) {
        array[i] = 2*array[i];

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

优化，array别让他变

public static int[] transform(int[] array){
    int[] tmp = new int[array.length];
    for (int i = 0; i < array.length; i++) {
        tmp[i] = 2*array[i];

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

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

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

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

public static int[] reverse1(int[]array){
    int left = 0;
    int right = array.length - 1;
    int[] tmp = new int[array.length];
    for (int i = 0; i < array.length -1; i++) {

            if(array[i]%2 == 0){
                tmp[left] = array[i];
                left++;
            }else{
                tmp[right] = array[i];
                right--;
            }
        }
    return tmp;

    }

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

}

博哥的

public static void fun1(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 == 0){
            j--;
        }
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }
}

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

}

思路就是前面找偶数，不符合的；后面找奇数，不符合的，找见了交换

i遇到偶数停止，j遇到奇数停止，都停止了就交换。

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

public static int[] twoSum(int[] nums, int target) {
        int[] ret = new int[2];
        int[] tmp = null;
        for (int i = 0; i < nums.length; i++) {
            for (int j = i+1; j < nums.length; j++) {
                if (nums[i] + nums[j] == target) {
                    ret[0] = i;
                    ret[1] = j;
                    return ret;

                }
            }
        }
        return tmp;
    }



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

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

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

相同的数与自己异或（^）得零

要是两个单身狗咋办

1 2 3 4 2 1

把二进制从右往左的第i个为1的分到一组

好处：一定会把两个不同的数字分到不同的组中

吧所有数异或出来，因为异或结果当中的1一定是两个数当中位置不同的1

class Solution {
public int[] singleNumber(int[] nums) {
int xorsum = 0;
for (int num : nums) {
xorsum ^= num;
}
// 防止溢出
int lsb = (xorsum == Integer.MIN_VALUE ? xorsum : xorsum & (-xorsum));
int type1 = 0, type2 = 0;
for (int num : nums) {
if ((num & lsb) != 0) {
type1 ^= num;
} else {
type2 ^= num;
}
}
return new int[]{type1, type2};
}
}

作者：LeetCode-Solution
链接：https://leetcode.cn/problems/single-number-iii/solution/zhi-chu-xian-yi-ci-de-shu-zi-iii-by-leet-4i8e/
来源：力扣（LeetCode）
看不太懂，先往后学

五。查找数组中指定元素

public static int find5(int[] array,int key) {
    int left = 0;
    int right = array.length - 1;
    int mid = (left + right) >>> 1;
    while (left <= right) {
        if (array[mid] < key) {
            left = mid + 1;
        } else if (array[mid] > key) {
            right = mid - 1;
        } else {
            return mid;
        }
    }return -1;
}
public static int find4(int[] array,int key){
    for (int i = 0; i < array.length; i++) {
        if(key == array[i]){
            return i;
        }
    }
    return -1;
}
public static void main(String[] args) {
    int[] array = {1,2,3,4,5,6};
    System.out.println(find4(array,5));
    Arrays.sort(array);
    System.out.println(find5(array,5));

}

六。给定一个大小为n的数组nums，返回其中的多数元素。多数元素是指在数组中出现次数大于[n/2]的元素。你可以假设数组是非空的，并且给定的数组总是存在多数元素。

//方法一
public static int find6(int[] nums) {
    Arrays.sort(nums);
    return nums[nums.length / 2];
}
//方法二
public static int find7(int[] array){
    for (int i = 0; i < array.length; i++) {
        int count = 0;
        for (int j = i; j < array.length; j++) {
            if(array[i] == array[j]){
                count ++;
            }
        }
        if(count > array.length / 2) {
            return array[i];
        }


    }
    return -1;
}

//方法三
public static int majorityElement(int[] array){
    int ret = array[0];
    int count = 0 ;
    for (int i = 0; i < array.length; i++) {
        if(array[i] == ret){
            count++;
        }else {
            count--;
        }
        if(count == 0){
            ret = array[i + 1];
        }
    }
    return ret;
}

public static void main(String[] args) {
    int[] array = {1,1,1,1,2,3,3,3,3,3,3,3,3};
    int ret = find6(array);
    System.out.println(ret);
    int rett = find7(array);
    System.out.println(rett);

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

public static boolean olg(int[] arr){
    int n = arr.length;
    for (int i = 0; i <= n - 3; i++) {
        if((arr[i] & 1)!= 0 && (arr[i + 1]&1 )!= 0 && (arr[i + 2] &1)!= 0)){
            return true;
        }
    }return false;
}//方法1

public static boolean olg2(int[] arr){
    for (int i = 0; i < arr.length; i++) {
        int count = 0 ;
        if ((arr[i] & 1) != 0){
            count ++;
            if(count == 3){
                return true;
            }else{
                count = 0;
            }
        }
    }
    return false;
}//方法2