数组，缺省，排序算法

数组

数组是一种引用数据类型，是用来保存一组数据的容器，也是一种存储数据的数据结构。

要求一组数据中的数据类型相同

数组中的数据可以是任何类型，包括数组，类，接口等引用数据类型

一、使用数组：

1.声明数组，如 int[ ]=name；放置在栈中

2.创建对象 name=new int[5]; 使用new在堆中开辟空间，创建了一个长为5的数组对象，用于存储内容，其内存首地址存放在栈中，即让name这个引用指向数组；

3.赋值：name[0]=1；通过索引找到对应的地址空间存放数据

4.使用数据元素，通过数组下标，如：System.out.println（name[2]),表示输出name数组中第3个值（下标从0开始）。

5.遍历，通过for循环遍历

6.简写

7.多维数组：java中其实只要一维数组，二维数组原理就是将一维数组作为另一个一维数组的元素，多维一样。

public class ArrayPractice01 {
    public static void main(String[] args) {
        String[] names;
        names=new String[3];
        names[0]="hello";
        names[1]="你好";
        names[2]="you too";

        System.out.println(names[1]);

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

数组小练习：

1.输入10个数，求和，平均值，最大值，最小值

import java.util.Scanner;
public class ArrayPractice02 {
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        int[] a=new int[10];
        //依次向数组中输入值
        for (int i=0; i<10;i++){
            a[i]=s.nextInt();
        }
        //遍历数组，使数组元素相加
        int sum=0;
        for (int i = 0; i <a.length; i++) {
            sum=sum+a[i];
        }
        System.out.println("和为"+sum);
        int ju;
        ju=sum/10;
        System.out.println("平均值为"+ju);
        int max=a[0];
        int min=a[0];
        
        //判断最值，只需要将最大值赋给对应变量，不需要通过临时变量交换变量值
        for (int i = 0; i <a.length; i++) {
            if (max<a[i]){
                max=a[i];
            }
            if (min>a[i]){
                min=a[i];
            }
        }
        System.out.println("平均值为"+max);
        System.out.println("平均值为"+min);

    }
}

2.输入10个数，求偶数和，以及奇数和。

import java.util.Scanner;

public class ArrayPractice03 {
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        int[] a=new int[10];
        
        for (int i=0; i<10;i++){
            a[i]=s.nextInt();
        }
        
        int sum_odd=0,sum_even=0;
        for (int i = 0; i <a.length ; i++) {
            if (a[i]%2==0){
                sum_even+=a[i];
            }else {
                sum_odd+=a[i];
            }
        }
        System.out.println(sum_even+",奇数和为"+sum_odd);
    }

}

二、缺省

int，short，byte，long类型的数组缺省输出为0

double 为0.0

char为空格

boolean为false

引用数据类型的数组缺省输出为null；

三、排序

时间复杂度，空间复杂度，稳定性

1.冒泡排序

相邻比较，达到互换互换条件互换

public class BubbleSort {
    public static void main(String[] args) {
        int[] a={1,2,39,87,55,44,22,0,6,4};

        for (int i = 0; i < a.length-1; i++) {
            for (int j = 0; j <a.length-i-1 ; j++) {

                if(a[j]>a[j+1]){
                    int temp=0;
                    temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
        
        for (int i = 0; i <a.length ; i++) {
            System.out.println(a[i]);
        }

    }
}

2.选择排序

从第一个开始与后面的值依次比较，达到互换互换条件互换，

public class SelecteSort {
    public static void main(String[] args) {
        int[] a={5,9,2,1,5,3,6};
        
        for (int i = 0; i <a.length-1 ; i++) {
            for (int j=i+1;j<a.length;j++){
                if (a[i]>a[j]){
                    int temp=a[i];
                    a[i]=a[j];
                    a[j]=temp;
                }
            }
        }
        
        for (int i = 0; i <a.length ; i++) {
            System.out.println(a[i]);
        }
    }
}

3.插入排序

从第二位开始与前面的所有值比较，达到条件使前面值的标记+1，

public class InsertionSort {
    public static void main(String[] args) {
        int[] a={1,2,39,87,55,44,22,0,6,4};

        for (int i = 0; i < a.length-1; i++) {
            int current=a[i+1];
            int preIndex=i;
            while(preIndex>=0&&current<a[preIndex]){
                a[preIndex+1]=a[preIndex];
                preIndex--;
            }
            a[preIndex+1]=current;
        }
        
        for (int i = 0; i <a.length ; i++) {
            System.out.println(a[i]);
        }
    }
}

4.希尔排序

5.归并排序

6.快速排序

7.堆排序

8.基数排序

9.计数排序

10.桶排序