Java:数组/汉诺塔/冒泡排序/二分查找

目录

什么是数组:

数组的创建与初始化:

数组的使用:

数组和方法之间的关系: 

 数组的练习:

 二分查找:

什么是数组:

本质上是能让我们能"批量"创建相同类型的变量.

数组的创建与初始化:

1.数组的动态初始化:

     int[] arr = new int[] {1,2,3};//初始化数组时,每个元素同时赋值
     int[] arr2 = new int[3];//每个元素都是默认的数据类型(0)

2.数组的静态初始化:

int[] arr3 = {1,2,3};

数组的使用:

如果访问了索引不存在的元素就会引发数组越界异常

遍历数组的每个元素:

//arr[i]拿到了每个数组的元素

 int[] arr = new int[] {1,2,3};//初始化数组时,每个元素同时赋值

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

//只能读取数组的元素值,无法修改!

  i是原数组每个元素的临时拷贝,并不是实实在在的数组元素

       for (int i : arr){
            System.out.println(i);
        }

数组和方法之间的关系: 

   1.数组作为方法之间的关系:

2.关于引用数据类型理解的问题 

  栈:

堆:

 数组的练习:

//实现一个copy方法对一个整形数组进行拷贝,得到一个新的数组
int[] arr = new int[] {1,2,3};

      int newArr[] =  copyArr(arr);
      printArr(newArr);//打印数组
    }
    
    private static int[] copyArr(int arr[]) {
         int [] newArr = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            newArr[i] = arr[i];
        }
        return newArr;
    }

//数组对象转换为字符串对象
  int[] arr = new int[] {1,2,3}
  
  String str = Arrays.toString(arr);
  System.out.print(str);

//找出数组的最大值
 public static int arrMax(int[] arr){
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(arr[i]>max){
               max = arr[i];
            }
        }
        return max;
    }

//数组转换字符串
    public static String arrToStr(int[] arr){
        String str = "[";
        for (int i = 0; i < arr.length; i++) {
            str += arr[i];
            if(i != arr.length-1){
                str+=",";
            }
        }
        str += "]";
        return str;
    }

//在数组中查找指定的元素并返回索引,没找到返回-1
    public static int toFind(int[] arr,int num){
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == num) {
                return i;
            }
        }
        return -1;
    }

//在数组中查找指定的元素并返回索引,没找到返回-1
    public static int toFind(int[] arr,int num){
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == num) {
                return i;
            }
        }
        return -1;
    }

 二分查找:

      在有序的集合上才能使用二分查找

public static int search(int[] arr,int toFind){
        int left = 0;
        int right = arr.length-1;

        while (left<=right){
            int mind = (left+right)/2;
            if(toFind<arr[mind]){
                right = mind-1;
            }else if(toFind>arr[mind]){
                left = mind+1;
            }else {
                System.out.println("找到了!");
                return mind;
            }
        }
        return -1;
    }

 //二分查找的递归写法
    public static int Search(int[] arr,int toFind,int left,int right){
        if(left>right){
            return -1;
        }
        int mid = (left + right) / 2;
        if(arr[mid] == toFind){
            return mid;
        }else if(toFind<arr[mid]){
            return Search(arr,toFind,left,mid-1);
        }else if(toFind>arr[mid]){
            return Search(arr,toFind,mid+1,right);
        }
        return 0;
    }

 //判断一个数组是否有序
    public static boolean isArray(int[] arr){
        for (int i = 0; i < arr.length-1; i++) {
            if(arr[i]>arr[i + 1]){
                return false;
            }
        }
        return true;
    }

//冒泡排序
public static void popo(int[] arr){
        int temp = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length-1-i; j++) {
                if(arr[j]>arr[j+1]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }

    }

 //冒泡排序的优化
    public static void popo(int[] arr){
        int temp = 0;
        for (int i = 0; i < arr.length-1; i++) {
            boolean ispopo = false;
            for (int j = 0; j < arr.length-1-i; j++) {
                if(arr[j]>arr[j+1]){
                    ispopo = true;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            if(!ispopo){
                break;
            }
        }

//数组逆序
    public static void revers(int arr[]){
        int i = 0;
        int j = arr.length - 1;
        while (i<j){
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++;
            j--;
        }
    }