java中数组常见的操作

数组常见操作

• 遍历

/**
 * @ClassName: ArrayDemo4
 * @Description: TODO
 * @Author: benjamin
 * @Date: 2019/3/23 11:27
 * @Version: 1.0
 */
public class ArrayDemo4 {
    public static void main(String[] args) {
​
        int[] arr = {1,2,3,4,5,6,7};
​
        System.out.println("length:"+arr.length); //打印数组的长度
​
        for(int i = 0;i<arr.length;i++){
            //数组的遍历输出-》顺序
            System.out.println("arr["+i+"] = "+arr[i]+";");//arr[0]=1,....;
        }
        System.out.println(" ");
        for(int i = arr.length-1;i>=0;i--){
            //数组倒序的遍历输出
            System.out.println("arr["+i+"] = "+arr[i]+";");//arr[0]=1,....;
        }
        System.out.println(" ");
        for(int i =0;i<arr.length;i+=2){
            //自定义步长输出
            System.out.println("arr["+i+"] = "+arr[i]+";");//arr[0]=1,....;
        }
//        System.out.println("Hello World");
    }
}

• 最值

　　两个思路：一是比较最大的值；二是找到最大的下标，然后返回最大的值。

/**
 * @ClassName: ArrayDemo5
 * @Description: TODO
 * @Author: benjamin
 * @Date: 2019/3/23 11:39
 * @Version: 1.0
 */
public class ArrayDemo5 {
    public static void main(String[] args) {
//        int[] array = new int[]{-1,-9,-8,-2};
        int[] array = new int[]{22,3,1,343,455,24,5};
​
        System.out.println("max = "+getMaxNum(array));
        System.out.println("max = "+getMaxNum_2(array));
    }
    /* 获取数组中的最大值；
     * 思路：
     * 1. 需要进行比较，并定义变量记录每次比较后较大的值；
     * 2. 对数组中的元素进行遍历取出，和变量中记录的元素进行比较；
     *   如果遍历到的元素大于变量中记录的元素，就用变量记录住该大的值；
     * 3. 遍历结果，该变量记录就是最大的值；
     * */
    public static int getMaxNum(int[] array){
        //
        int maxValue = array[0];
        for(int i = 1; i<array.length;i++){
            if(array[i]>=maxValue)
                maxValue = array[i];
        }
        return maxValue;
    }
    public static int getMaxNum_2(int[] array){
        //找到最大的下标，返回最大的值array[maxIndex]
        int maxIndex = 0;
        for(int i = 1; i<array.length;i++){
            if(array[i]>=array[maxIndex])
                maxIndex = i;
        }
        return array[maxIndex];
    }
}

• 排序

  • 选择排序

  /**
   * @ClassName: SelectSort
   * @Description: 选择排序
   * @Author: benjamin
   * @Date: 2019/3/24 15:23
   * @Version: 1.0
   */
  public class SelectSort {
      public static void main(String[] args) {
  ​
          //定义一个数组 元素类型[] 数组名 = new 元素类型 [] {元素1,元素2...}
          int [] array = new int[]{54,26,93,17,77,313,44,55,20};
  ​
          selectSort(array);//选择排序
          //打印数组；
          for(int i =0;i<array.length;i++){
              System.out.print(array[i]+",");
          }
  ​
  //        System.out.println("Hello World");
      }
      public static void selectSort(int[] array){
          // 选择排序算法
          // 最外层的循环用来遍历数组，最后一个元素不用比
          for(int i=0;i<array.length-1;i++){
              //最外层用来i从0到数组的长度减1，最后一个数不用排；
              for(int j=i+1;j<array.length;j++){
                  // j从比i大1的位置开始比较，一直比到最后一个值（此时对应的值是数组中最后一个值）；找最小的值；
                  if(array[i]>array[j]){
  //                    int temp = array[i];
  //                    array[i] = array[j];
  //                    array[j] = temp;
                      swap(array,i,j);
                  }
              }
          }
      }
      //交换函数；
      public static void swap(int[] array,int a,int b){
          int temp = array[a];
          array[a] = array[b];
          array[b] = temp;
      }
  }

  • 冒泡排序

  /**
   * @ClassName: BubbleSort
   * @Description: 冒泡排序
   * @Author: benjamin
   * @Date: 2019/3/24 17:06
   * @Version: 1.0
   */
  public class BubbleSort {
      public static void main(String[] args) {
  ​
          int[] array = new int[]{54,26,93,17,77,313,44,55,20};
          bubbleSort(array);
          //打印数组；
          for(int i =0;i<array.length;i++){
              System.out.print(array[i]+",");
          }
  ​
      }
      public static void bubbleSort(int[] array){
          //冒泡排序
          for(int i=0;i<array.length-1;i++){
              //走的次数；大循环保证取值从0到数组的最后一个元素array[length-1]
              for(int j=0;j<array.length-1-i;j++){
                  // -1 是为了避免越界，比如array[8]与array[8+1]比。后者越界不存在；
                  // -i 让外循环每增加一次，内循环参与比较的元素个数递减
                  // i = 0 ，比较9次；i=1，比较8次；
                  if(array[j] > array[j+1]){
  //                    int temp = array[j];
  //                    array[j] = array[j+1];
  //                    array[j+1] = temp;
                      swap(array,j,j+1);
                   }
              }
          }
      }
      //交换函数；
      public static void swap(int[] array,int a,int b){
          int temp = array[a];
          array[a] = array[b];
          array[b] = temp;
      }
  }

• 折半查找（二分查找）

  /**
   * @ClassName: ArrayDemo7
   * @Description: 数组常见功能查找
   * @Author: benjamin
   * @Date: 2019/3/24 20:55
   * @Version: 1.0
   */
  public class ArrayDemo7 {
      public static void main(String[] args) {
  ​
          int[] array = new int[]{12,23,34,55,56};
  ​
          int key = getIndex(array,23);
          System.out.println("key:"+key);
  ​
          int value = binarySearch(array,55);
          int value2 = binarySearch_2(array,56);
          System.out.println("value:"+value);
          System.out.println("value2:"+value2);
      }
      //数组常见的功能：通过key查找数组中对应的元素
      public static int getIndex(int[] array,int key){
  ​
          for(int i =0;i<array.length;i++){
              if(array[i] == key){
                  return i; //返回这个下标
              }
          }
          return -1; //表示没有这个下标的元素
      }
      //二分查找：binarySearch,返回输入元素的下标；
      public static int binarySearch(int[] array,int value){
          int low = 0;
          int high = array.length-1;
          int mid = (low + high) / 2;
          while(array[mid] != value){
              if(value > array[mid]){
                  //如果所给值大于中间数，则保留mid右边
                  low = mid + 1;
              }else if(value < array[mid]){
                  //如果所给值小于中间数，则保留mid左边
                  high = mid - 1;
              }
              if (high < low){
                  // 代表循环结束
                  return -1;
              }
              mid = (high+low)/2;
          }
          return mid;
      }
      public static int binarySearch_2(int[] array,int value){
          int low = 0;
          int high = array.length-1;
  ​
          while(low <= high){
              //只要low
              int mid = (low + high) / 2;
              if(value > array[mid]){
                  low = mid + 1;
              }else if(value < array[mid]){
                  high = mid - 1;
              }else{
                  return mid;
              }
          }
          return -1;
      }
  }　　

面试题：给定一个有序的数组，若果往该数组中存储一个元素，并保证这个数组还是有序的，那么这个元素的存储的角标如何获取？

​ 数组，有序，优先想到二分查找

/**
 * @ClassName: ArrayDemo8
 * @Description:
 * 给定一个有序的数组，
 * 如果往该数组中存储一个元素，并保证这个数组还是有序的，
 * 那么这个元素的存储的角标如何获取？
 * @Author: benjamin
 * @Date: 2019/3/24 21:45
 * @Version: 1.0
 */
public class ArrayDemo8 {
    public static void main(String[] args) {
        int[] array = new int[]{12,23,34,55,56};
        int index = binarySearch(array,40);
        System.out.println("该放在"+index+"的位置");
    }
    public static int binarySearch(int[] array,int value){
        int low = 0;
        int high = array.length-1;
​
        while(low <= high){
            int mid = (low + high) / 2;
            if(value > array[mid]){
                low = mid + 1;
            }else if(value < array[mid]){
                high = mid - 1;
            }else{
                return mid;
            }
        }
        return low;//此时low是大于high的值，也就是放入的这个数在low的位置；
    }
}