Day03

 

类变量可以在main方法中，直接调用，在方法前面加上static修饰符，其实也就相当于类变量。

方法重载

方法名必须相同，但是形参列表一定要不同（参数类型不同，参数个数不同，参数排列顺序不同）。

递归

递归会占用电脑的内存，挤压栈，小基数可以用，大数能不用就不用。

边界条件：边界

前阶段：

返回阶段：n*(n-1)

使用Scanner时的问题

在循环使用scanner获得输入时，应注意，如果使用while true为循环，则在循环体中必须要有，退出循环语句，否则程序会默认为死循环，会一直执行不了在循环外的关闭scanner的操作，而报错！

冒泡排序

import java.lang.reflect.Array;
import java.util.Arrays;
​
public class ArrayDemo05 {
    public static void main(String[] args) {
        int[] array = {1,99,50,23,15,66,77};
        int[] sort = sort(array);
        System.out.println(Arrays.toString(sort));
​
    }
    //冒泡排序
    //1、比较数组中两个相邻的元素，如果第一个数比第二个数大，就交换位置
    //2、每一次比较都会产生一个最大或者最小的数字
    //3.下一轮可以少一次比较
    //4.依次循环，直到结束
    public static int[] sort(int[] array){
        int temp = 0;
        for (int i = 0; i < array.length-1; i++) {
            for (int j = 0; j <array.length-1-i ; j++) {
                if (array[j+1]<array[j]){
                    temp = array[j+1];
                    array[j+1]=array[j];
                    array[j] = temp;
                }
            }
        }
        return array;
    }
}

循环保证了最右的位置为最大值，然后减少循环值，再进行循环比较。

冒泡排序算法解析

 

稀疏数组

public class ArrayDemo06 {
    public static void main(String[] args) {
        //1.创建一个二维数组 11*11  0：没有棋子，1：黑棋，2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;

        System.out.println("输出原始的数组：");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        System.out.println("==================================================");

        //转换为稀疏数组
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j <11 ; j++) {
               if (array1[i][j]!=0){
                   sum++;
               }
            }
        }
        //创建一个稀疏数组
        int[][] array2 = new int[sum+1][3];

        array2[0][0]=11;
        array2[0][1]=11;
        array2[0][2]=sum;

        //遍历二维数组，将非零的值，存放在稀疏数组中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j]!=0){
                    count++;
                    array2[count][0] = i;   //存储非零值的行
                    array2[count][1] = j;   //存储非零值的行
                    array2[count][2] = array1[i][j];   //存储值
                }
            }
        }
        //输出稀疏数组
        System.out.println("输出稀疏数组：");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"
                              +array2[i][1]+"\t"
                              +array2[i][2]+"\t");

        }
        System.out.println("==================================================");

        //还原稀疏数组
        System.out.println("还原");
        int[][] array3 = new int[array2[0][0]][array2[0][1]];

        //给其中的元素还原值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        System.out.println("还原的数组：");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}