递归和数组

递归思想

自己调用自己

递归头、递归体

public class Demo02 {
    public static void main(String[] args) {
        System.out.println(p(5));
    }
    public static int p(int n){
        if(n==1){
            return 1;
        }else {
            return n*p(n-1);
        }
    }
​
}
​

数组

数组的声明和创建

public class ArrayDemo01 {
    //变量类型 变量名 = 变量的值
    //数组类型
    public static void main(String[] args) {
        //声明
        int[] arrys;
        //创建
        arrys = new int[10];
        //声明+创建
        int[] arrys2 = new int[10];
        arrys[0]=1;
        arrys[1]=2;
        arrys[2]=3;
        arrys[3]=4;
        arrys[4]=5;
        arrys[5]=6;
        arrys[6]=7;
        arrys[7]=8;
        arrys[8]=9;
        arrys[9]=10;
        int sum = 0;
        for (int i = 0; i < arrys.length; i++) {
            sum +=arrys[i];
        }
        System.out.println(sum);
    }
}

数组的初始化

package com.lzy.array;
​
public class ArraysDemo02 {
    private static int anInt;
​
    public static void main(String[] args) {
        //静态初始化
        int[] a = {1, 2, 3};
        Man[] man = {new Man(), new Man()};
        //动态初始化
        int[] arrays = new int[10];
        arrays[0] = 1;
        arrays[1] = 2;
        //数组的默认初始化
        //数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化
    }
}
​

注意：数组的创建是在堆中进行的

数组的使用

• 普通for循环

• For-Each循环

• 数组作方法入参

• 数组作作返回值

package com.lzy.array;
​
public class ArraysDemo03 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        //for-each
        for (int array : arrays) {
            System.out.println(array);
        }
        //数组作方法入参
        printArrays(arrays);
        //数组作作返回值
        printArrays(reverse(arrays));
    }
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        //反转操作
        for (int i = 0,j=arrays.length-1; i < arrays.length; i++,j--) {
            result[i]=arrays[j];
        }
        return result;
    }
    public static void printArrays(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+" ");
        }
​
    }
}

二维数组

package com.lzy.array;
​
public class ArraysDemo04 {
    public static void main(String[] args) {
        //[4][5]
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.println(array[i][j]);
            }
        }
    }
}
​

Arrays类

Arrays.sort排序（升序）

Arrays.toString输出数组

package com.lzy.array;
​
import java.util.Arrays;
//Arrays是静态类，可以直接调用
public class ArraysDemo05 {
    public static void main(String[] args) {
        int[] a = {1,2,33,44,555,151664,156};
        //返回对象参数[I@4554617c
        System.out.println(a);
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
    }
}
​

冒泡排序

1.比较数组中，两个相邻的元素，如果第一个数比第二个大，我们就交换他们的位置

2.每一次比较，都会产出一个最大，或者最小的数字

3.下一轮则可以减少一次排序（重要）

4.依次循环，直到结束

package com.lzy.array;
​
import java.util.Arrays;
​
public class ArraysDemo06 {
    public static void main(String[] args) {
        int[] a = {1,2,33,44,555,151664,156,777};
        int[] sort = sort(a);
        System.out.println(Arrays.toString(sort));
​
    }
    public static int[] sort(int[] arrays){
        int t;
        for (int i = 0; i < arrays.length-1; i++) {
            boolean flag =false;//通过flag标识减少没有意义的比较
            for (int j = 0; j < arrays.length-1-i; j++) {
                if(arrays[j]<arrays[j+1]){
                    t = arrays[j];
                    arrays[j]= arrays[j+1];
                    arrays[j+1]=t;
                    flag = true;
                }
                if(flag==false){
                    return arrays;
                }
            }
​
        }//时间复杂度O(n2)
        return arrays;
    }
}
​