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

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

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

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

    方法1：

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

     代码的运行结果为：

     方法2：

    1.  
    2.     public static String myToString(int[] array) {
    3.         String ret="[";
    4.         for (int i = 0; i < array.length; i++) {
    5.             ret=ret+array[i];
    6.             if(i!=(array.length-1)) {
    7.                 ret=ret+",";
    8.             }
    9.         }
    10.         ret=ret+"]";
    11.         return ret;
    12.     }
    13.  
    14.  
    15.     public static void main(String[] args) {
    16.         int[] array={1,2,3,4,5,6,7,8};
    17.         System.out.println(myToString(array));
    18.     }

    代码的运行结果为：

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

    方法1：

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

    代码的运行结果为：

    方法2：

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

    代码的运行结果为：

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

    1.     public static int find(int[] array,int val) {
    2.         for (int i = 0; i < array.length; i++) {
    3.             if(array[i]==val) {
    4.                 return i;
    5.             }
    6.         }
    7.         return -1;
    8.     }
    9.  
    10.     public static void main(String[] args) {
    11.         int[] array1={11,22,33,44,55,66};
    12.         int ret=find(array1,44);
    13.         System.out.println(ret);
    14.     }

    代码的运行结果为：

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

    1.     public  static int binarySearch(int[] array,int key) {
    2.         int left=0;
    3.         int right=array.length-1;
    4.         while (left<=right) {
    5.             int mid=(left+right)/2;
    6.             if(array[mid]<key) {
    7.                 left=mid+1;
    8.             } else if(array[mid]>key) {
    9.                 right=mid-1;
    10.             } else {
    11.                 return mid;
    12.             }
    13.         }
    14.         return -1;
    15.     }
    16.  
    17.     public static void main(String[] args) {
    18.         int[] array={2,4,6,8,10,12,14,16,18,20};
    19.         Arrays.sort(array); //对乱序的数组进行排序
    20.         System.out.println(binarySearch(array,10));
    21.     }

    代码的运行结果为：

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

    1.     public static void func(int[] array) {
    2.         int left=0;
    3.         int right=array.length-1;
    4.         while(left<right) {
    5.             while (left<right && array[left]%2 !=0) {
    6.                 left++;
    7.             }
    8.             while (left<right && array[right]%2==0) {
    9.                 right--;
    10.             }
    11.             int tmp=array[left];
    12.             array[left]=array[right];
    13.             array[right]=tmp;
    14.         }
    15.     }
    16.  
    17.     public static void main(String[] args) {
    18.         int[] array={1,2,3,4,5,6,7,8,9,0};
    19.         func(array);
    20.         System.out.println(Arrays.toString(array));
    21.     }

    代码的运行结果为：

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

    1.    public static void bubblesort(int[] array ) {
    2.         //趟数
    3.         for (int i = 0; i < array.length; i++) {
    4.             //每趟执行的次数
    5.             boolean flg=false;
    6.             for(int j=0;j<array.length-1-i;j++) {
    7.                 if(array[j]>array[j+1]) {
    8.                     int tmp=array[j+1];
    9.                     array[j+1]=array[j];
    10.                     array[j]=tmp;
    11.                 }
    12.             }
    13.             if(flg==false) {
    14.                 return ;
    15.             }
    16.         }
    17.     }
    18.  
    19.     public static void main(String[] args) {
    20.         int[] array={1,29,10,36,5,21,46,3,6};
    21.         bubblesort(array);
    22.         System.out.println(Arrays.toString(array));
    23.     }

    代码的运行结果为：

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

    1.     public  static int[] findtarget(int[] arrary ,int target) {
    2.         int[] ret={-1,-1};
    3.         for (int i = 0; i < arrary.length; i++) {
    4.             for(int j=0;j<arrary.length;j++) {
    5.                 if(arrary[i]+arrary[j]==target) {
    6.                     ret[0] =i;
    7.                     ret[1]=j;
    8.                     return ret;  //成功
    9.                 }
    10.             }
    11.         }
    12.         return ret;  //失败
    13.     }
    14.  
    15.     public static void main(String[] args) {
    16.         int[] array={1,10,3,4,5,0};
    17.         int[] ret=findtarget(array,8);
    18.         System.out.println(Arrays.toString(ret));
    19.     }

    代码的运行结果为：

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

    1.     public static int findNum(int[] array) {
    2.         int ret=array[0];
    3.         for (int i = 1; i < array.length; i++) {
    4.             ret=ret^array[i];
    5.         }
    6.         return  ret;
    7.     }
    8.  
    9.     public static void main(String[] args) {
    10.         int[] array={10,10,3,5,3};
    11.         int ret=findNum(array);
    12.         System.out.println(ret);
    13.     }

    代码的运行的结果为：

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

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

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

    方法2：

    1.     public static int majorityElement(int[] array) {
    2.         int count=0;
    3.         int tmp=array[0];
    4.         for (int i = 0; i < array.length; i++) {
    5.             if(array[i]==tmp) {
    6.                 count++;
    7.             } else if(array[i] !=tmp) {
    8.                 count--;
    9.             }
    10.              if(count==0) {
    11.                  tmp=array[i];
    12.                  count++;
    13.              }
    14.         }
    15.         return tmp;
    16.     }
    17.  
    18.     public static void main(String[] args) {
    19.         int[] array={1,2,1,2,1};
    20.         int ret=majorityElement(array);
    21.         System.out.println(ret);
    22.     }

    代码的运行结果为：

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

    1.     public  static boolean func(int[] array) {
    2.         int count=0;
    3.         for (int i = 0; i < array.length; i++) {
    4.             if(array[i]%2==0) {
    5.                 count++;
    6.                 if(count==3) {
    7.                     return true;
    8.                 }
    9.             }else {
    10.                 count=0;
    11.             }
    12.         }
    13.         return false;
    14.     }
    15.  
    16.     public static void main(String[] args) {
    17.         int[] array={6,5,5,1};
    18.         boolean ret=func(array);
    19.         System.out.println(ret);
    20.     }

    代码的运行结果为：

     11.数组逆序

    1.    public static void swap(int[] array,int i,int j) {
    2.         int tmp=array[i];
    3.          array[i]=array[j];
    4.         array[j]=tmp;
    5.     }
    6.  
    7.     public static void reserve(int[] array) {
    8.         int left=0;
    9.         int right=array.length-1;
    10.         while(left
    11.             swap(array,left,right);
    12.             left++;
    13.             right--;
    14.         }
    15.     }
    16.  
    17.  
    18.     public static void main(String[] args) {
    19.         int[] array={6,9,5,1};
    20.         reserve(array);
    21.         System.out.println(Arrays.toString(array));
    22.     }

    代码的运行结果为：

     

  • 相关阅读:
    Python中lambda函数&eval()函数&递归的详细用法
    TypeScript高级类型
    PgSQL——查询某字段每个月的排名
    面向OLAP的列式存储DBMS-1-[ClickHouse]的发展历程
    Service Worker是什么?
    python多线程
    redis之GEO使用
    芯片学习记录TLP291-4
    Linux下PC与开发板进行数据通讯的三种方式
    公网集群对讲+GPS可视追踪｜助力物流行业智能化管理调度
  • 原文地址：https://blog.csdn.net/weixin_64308540/article/details/127737776