用Java语言简单做几个数组相关的练习题吧

念君思宁

已于 2023-03-01 12:25:03 修改

阅读量1.4k

点赞数 6

分类专栏： java要笑着学文章标签： java 开发语言学习

于 2022-11-07 21:11:02 首次发布

本文链接：https://blog.csdn.net/weixin_64308540/article/details/127737776

版权

java要笑着学专栏收录该内容

210 篇文章 8 订阅

订阅专栏

到现在为止，想象各位老铁已经接触过Java数组部分的简单知识了！那么，就跟着笔者做几个简单的数组有关的练习题吧！！（Java语言）

数组转成字符串（前提不为null)
数组拷贝！（多种方法）
查找数组中的指定元素
二分查找：给定一共有序数组，实现二分查找
将一个数组奇数放在偶数之前
冒泡排序：给定一个整型数组，实现冒泡排序（升序排序）
给定一个整数nums和一个整数目标target,请你再该数组中找出，和为目标值target的那两个数，并返回它们的数组下标！（假设每种输入只会有一个答案！但是数组中，同一个元素，再数组中，不能重复出现）
给定一个非空数组，除了某个元素只出现依次之外，其余全部每个元素均出现两次，找出那个只出现一次的元素！
给定一共大小为n的数组，找到其中的多数元素（多数元素是指：在数组中，出现次数大于n/2的元素
给你一共整数arr，请你判断数组中是否存在连续三个元素，都是奇数的情况？？如果存在，就返回true ,否则返回false
数组逆序

1.数组转成字符串（前提不为null)

方法1：

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

代码的运行结果为：

方法2：


    public static String myToString(int[] array) {
        String ret="[";
        for (int i = 0; i < array.length; i++) {
            ret=ret+array[i];
            if(i!=(array.length-1)) {
                ret=ret+",";
            }
        }
        ret=ret+"]";
        return ret;
    }


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

代码的运行结果为：

2，数组拷贝！（多种方法）

方法1：

  public static void main(String[] args) {
        int[] array={1,2,3,4};
        int[] array2 =new int[array.length];
        for (int i = 0; i < array.length; i++) {
            array2[i]=array[i];
        }
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(array2));

    }

代码的运行结果为：

方法2：

public class Main {

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

代码的运行结果为：

3.查找数组中的指定元素

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

    public static void main(String[] args) {
        int[] array1={11,22,33,44,55,66};
        int ret=find(array1,44);
        System.out.println(ret);
    }

代码的运行结果为：

4.二分查找：给定一共有序数组，实现二分查找

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

    public static void main(String[] args) {
        int[] array={2,4,6,8,10,12,14,16,18,20};
        Arrays.sort(array); //对乱序的数组进行排序
        System.out.println(binarySearch(array,10));
    }

代码的运行结果为：

5.将一个数组奇数放在偶数之前

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

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

代码的运行结果为：

6.冒泡排序：给定一个整型数组，实现冒泡排序（升序排序）

   public static void bubblesort(int[] array ) {
        //趟数
        for (int i = 0; i < array.length; i++) {
            //每趟执行的次数
            boolean flg=false;
            for(int j=0;j<array.length-1-i;j++) {
                if(array[j]>array[j+1]) {
                    int tmp=array[j+1];
                    array[j+1]=array[j];
                    array[j]=tmp;
                }
            }
            if(flg==false) {
                return ;
            }
        }
    }

    public static void main(String[] args) {
        int[] array={1,29,10,36,5,21,46,3,6};
        bubblesort(array);
        System.out.println(Arrays.toString(array));
    }

代码的运行结果为：

7.给定一个整数nums和一个整数目标target,请你再该数组中找出，和为目标值target的那两个数，并返回它们的数组下标！（假设每种输入只会有一个答案！但是数组中，同一个元素，再数组中，不能重复出现）

    public  static int[] findtarget(int[] arrary ,int target) {
        int[] ret={-1,-1};
        for (int i = 0; i < arrary.length; i++) {
            for(int j=0;j<arrary.length;j++) {
                if(arrary[i]+arrary[j]==target) {
                    ret[0] =i;
                    ret[1]=j;
                    return ret;  //成功
                }
            }
        }
        return ret;  //失败
    }

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

代码的运行结果为：

8，给定一个非空数组，除了某个元素只出现依次之外，其余全部每个元素均出现两次，找出那个只出现一次的元素！

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

    public static void main(String[] args) {
        int[] array={10,10,3,5,3};
        int ret=findNum(array);
        System.out.println(ret);
    }

代码的运行的结果为：

9.给定一共大小为n的数组，找到其中的多数元素（多数元素是指：在数组中，出现次数大于n/2的元素

方法1：将数组进行排序，中间的元素，一定为多数元素！

   public static void main(String[] args) {
        int[] array={1,1,2,1,2};
        Arrays.sort(array);
        System.out.println(array[array.length/2]);
    }

方法2：

    public static int majorityElement(int[] array) {
        int count=0;
        int tmp=array[0];
        for (int i = 0; i < array.length; i++) {
            if(array[i]==tmp) {
                count++;
            } else if(array[i] !=tmp) {
                count--;
            }
             if(count==0) {
                 tmp=array[i];
                 count++;
             }
        }
        return tmp;
    }

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

代码的运行结果为：

10.给你一共整数arr，请你判断数组中是否存在连续三个元素，都是奇数的情况？？如果存在，就返回true ,否则返回false

    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;
                }
            }else {
                count=0;
            }
        }
        return false;
    }

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

代码的运行结果为：

11.数组逆序

   public static void swap(int[] array,int i,int j) {
        int tmp=array[i];
         array[i]=array[j];
        array[j]=tmp;
    }

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


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

代码的运行结果为：