[数据结构与算法]9.4 数组05-08

数组05-08

9.4

数组的使用：

• 普通的For循环

• For-Each循环

• 数组作方法入参

• 数组作返回值

  package Array;
  
  public class ArrayDemo02 {
      public static void main(String[] args) {
          int[] arrays={1,2,3,4,5};
  
  
          //JDK1.5,没有下标   For-Each循环
          for (int array : arrays) {
              System.out.println(array);
          }
          printArray(arrays);  
        int[] reverse=reverse(arrays);
        printArray(reverse);
      }
  
      //反转数组
      public static int[] reverse(int[] arrays) {  //数组作方法入参
          int[] result = new int[arrays.length];
  
          //反转的操作
          for (int i = 0,j=result.length-1; i <arrays.length; i++,j--) {
              result[j]=arrays[i];
          }
          return result;  //数组做返回值
      }
  
      //打印数组元素
      public static void printArray(int[] arrays){
          for (int i = 0; i < arrays.length; i++) {
              System.out.println(arrays[i]+" ");
          }
      }
  
  }
  

多维数组

package Array;

public class ArrayDemo03 {
    public static void main(String[] args) {
        //[4][2]

        int[][] array={{1,2},{2,4},{3,5},{2,9}};
        System.out.println(array[0][0]);
        System.out.println(array[1][1]);
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.println(array[i][j]);
            }
        }
    }
}

Arrays类

• 数组的工具类java.util.Arrays
• API中提供了一个工具类Arrays供我们使用，从而对数据对象进行一些基本的操作
  • 给数组赋值：fill方法
  • 对数组排序：sort方法
  • 比较数组：equals方法比较数组中元素是否相等
  • 查找数组元素：binarySearch方法能对排序好的数组进行二分法查找操作

冒泡排序

• 最出名，总共有八大排序
• 两层循环，外层冒泡轮数，里层依次比较
• 看到嵌套循环，应立马可以得出这个算法的时间复杂度为O（n2）

package Array;

import java.util.Arrays;

public class ArrayDemo04 {
    public static void main(String[] args) {
      int[] a={1,3,45,56,7,8,54,35,345};
      int[] sort=sort(a);
        System.out.println(Arrays.toString(sort));

    }
    public static int[] sort(int[] array){
        //临时变量
        int temp=0;

        //外层循环，判断我们这个要走多少次
        for (int i = 0; i < array.length-1; i++) {

            boolean flag=false;//通过flag标识位减少没有意义的比较

            //内层循环，比较判断两个数，如果第一个数，比第二个数大，则交换位置
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j+1]>array[j]){
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
            if(flag=false){
                break;
            }
        }
        return array;
    }

}

第一次吃这么苦的抹茶味注心饼干，以后再也不要了