简单了解数组

数组

int[] sh;//首选方法
int sh[];//效果相同，适用于c，c++方法
int[] sh=new int[数组大小];

//静态初始化
int[] x={1,34,52,37,3};

//动态初始化
int[] x=new int[10];
x[0]=33;

反转数组

import java.util.Scanner;

public class demo1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] nums = {1, 32, 43, 22, 10};
        int[] result = reverse(nums);
        for (int i : result) {
            System.out.print(i+" ");
        }
        sc.close();
    }

    public static int[] reverse(int[] nums) {//定义反转数组方法
        int[] result = new int[nums.length];
        int j = nums.length - 1;
        for (int i = 0; i < nums.length; i++) {
            result[j--] = nums[i];//用result数组倒着接收数字
        }
        return result;
    }
}

• Arrays类

  int[] nums={2,43,23,54,239};
  
  //打印数组元素Array.toString(nums)
  System.out.println(Array.toString(nums));
  
  //对数组进行排序Array.sort(nums),按升序
  Array.sort(nums);
  
  //对数组进行填充 Array.fill(数组nums, 填充为值x);
  //Array.fill(数组nums, 起始地址a, 结束地址(不包括)b, 填充值x);
  
  

  冒泡排序(时间复杂度为O(n^2))

  import java.util.Scanner;
  
  public class demo1 {
      public static void main(String[] args) {
          Scanner sc = new Scanner(System.in);
          //冒泡排序，每次比较相邻的两个数，如果第一个数比第二个数大就交换他们的位置
          //每一次比较都产生一个最大或最小的数字在末尾
          //下一轮循环可以少一次排序
  
          int[] arr = {1, 4, 7, 24, 645, 75, 3};
          sort(arr);//调用方法进行排序
          for (int i : arr) {
              System.out.print(i + " ");
          }
          sc.close();
      }
  
      public static void sort(int[] arr) {
          for (int i = 0; i < arr.length - 1; i++) {//记录循环的次数
              for (int j = 0; j < arr.length - i - 1; j++) {//两两进行比较，每次循环后，比上一次少一次循环
                  if (arr[j + 1] < arr[j]) {
                      //arr[j+1]<arr[j]就交换它们的位置，升序排法
                      int t = arr[j + 1];
                      arr[j + 1] = arr[j];
                      arr[j] = t;
                  }
              }
          }
      }
  }
  
  

  稀疏数组

其中[0]后面表示 有6行，7列，8个值

[1]~[8]后面表示 例如：[1]后面表示 第0行，第3列，有一个值为22。以此类推

import java.util.Scanner;

public class demo1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //创建原始二维数组
        int[][] arr = new int[5][10];
        arr[1][5]=4;
        arr[3][7]=2;
        arr[4][9]=10;
        //输出原始的数组
        for (int[] i : arr) {
            for (int j : i) {
                System.out.print(j+" ");
            }
            System.out.println();
        }
        //获取有效值的个数
        int sum=0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if(arr[i][j]!=0) {
                    sum += 1;
                }
            }
        }
        System.out.println("有效值个数为："+sum);
        //创建稀疏数组，行为有效值的个数加一，列为3；
        int[][]arr2 = new int[sum+1][3];
        arr2[0][0]=5;//表示原数组有5行
        arr2[0][1]=10;//表示原数组有10列
        arr2[0][2]=sum;//表示有效值的个数

        //遍历原数组，将非0的值存放到稀疏数组中
        int count=0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if(arr[i][j]!=0) {
                    count++;
                    arr2[count][0]=i;//表示稀疏数组中第count行第一位置存放有效值的 行数
                    arr2[count][1]=j;//表示稀疏数组中第count行第二个位置存放有效值的 列数
                    arr2[count][2]=arr[i][j];//表示稀疏数组中第count行第三个存放有效值的 值
                }
            }
        }
        //打印稀疏数组
        for (int[] i : arr2) {
            for (int j : i) {
                System.out.print(j+" ");
            }
            System.out.println();
        }

        sc.close();
    }
}
/*
结果为：

0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 4 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 2 0 0 
0 0 0 0 0 0 0 0 0 10 
有效值个数为：3
5 10 3 
1 5 4 
3 7 2 
4 9 10 
 */