java数组 2020/9/30

1 数据概述

2 数组声明创建

内存理解：

3 数组使用

4 多维数组

稀疏数组：

   //  稀疏数组
public class Demo05 {
    public static void main(String[] args) {
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        int sum = 0;
        for (int[] ints : array1) {
            for (int anInt : ints) {
                if(anInt!=0){
                    sum++;
                }
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = array1.length;
        array2[0][1] = array1[0].length;
        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];
                }
            }
        }
        for (int[] ints : array2) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            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];
        }
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}

5 Array类

1．数组类Array

 Java中最基本的一个存储结构。

 提供了动态创建和访问 Java 数组的方法。其中的元素的类型必须相同。

 效率高，但容量固定且无法动态改变。

 它无法判断其中实际存有多少元素，length只是告诉我们array的容量。

 get   , getlength  ,set

2、静态类Arrays

此静态类专门用来操作array ，提供搜索、排序、复制等静态方法。

  equals()：比较两个array是否相等。array拥有相同元素个数，且所有对应元素两两相等。

  sort()：用来对array进行排序。

  binarySearch()：在排好序的array中寻找元素。

  Arrays.asList(array):将数组array转化为List

排序方法
1.冒泡排序

冒泡排序思路比较简单：

将序列当中的左右元素，依次比较，保证右边的元素始终大于左边的元素；
（ 第一轮结束后，序列最后一个元素一定是当前序列的最大值；）
对序列当中剩下的n-1个元素再次执行步骤1。
对于长度为n的序列，一共需要执行n-1轮比较
（利用while循环可以减少执行次数）
2. 快速排序
快速排序的基本思想：挖坑填数+分治法
从序列当中选择一个基准数(pivot)
在这里我们选择序列当中第一个数最为基准数
将序列当中的所有数依次遍历，比基准数大的位于其右侧，比基准数小的位于其左侧
重复步骤1.2，直到所有子集当中只有一个元素为止。
用伪代码描述如下：
1．i =L; j = R; 将基准数挖出形成第一个坑a[i]。
2．j–由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中。
3．i++由前向后找比它大的数，找到后也挖出此数填到前一个坑a[j]中。
4．再重复执行2，3二步，直到i==j，将基准数填入a[i]中

public class Demo04 {
    public static void main(String[] args) {
        int[] array = {33,66,23,3,12,64,4,3,21,55,32};
        quicksort1(array,0,array.length-1);
        for (int i : array) {
            System.out.print(i+" ");
        }
    }
    //冒泡排序
    public static int[] bubblesort(int[] array){
        int k = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length; j++) {
                if(array[i]<array[j]){
                    k=array[j] ;
                    array[j]=array[i];
                    array[i]=k;
                }
            }
        }
        return array;
    }
    //快速排序
    public static void quicksort1(int[] array,int low ,int high){
        if(low<high){
            int i = low ;
            int j = high;
            int x = array[low];
            while (i<j){
                while (i<j&&array[j]>=x){
                    j--;
                }
                array[i]=array[j];

                while (i<j&&array[i]<=x){
                    i++;
                }
                array[j]=array[i];

            }
            array[i] = x;
            quicksort1(array,low,i-1);
            quicksort1(array,i+1,high);
        }



    }
}