首页 > 其他分享 >数组

数组

时间:2024-07-13 17:09:30浏览次数:15  
标签:int System 数组 println nums1 out

数组

数组初始化

/* 数组(arrays)
1、相同数据(元素)类型的有序集合-从0开始的
2、首先声明数组变量才能在程序中使用
                数组类型 数组名字
声明数组-声明数组变量的语法 int[] nums; //首选方法
            或  int nums[]; //效果相同但不是首选方法
创建数组-使用new操作来创建数组 nums = new int[10];
声明和创建-int[] nums = new int[10];
赋值-nums[0]=1;
获取数组长度-nums.length
 */
/* 内存分析
1、栈-存放具体的值-nums
2、堆-存放new的对象和数组;被所有线程共享、不会存放别的-赋值10个数
3、方法区
 */
// 三种数组的初始化

package c;

public class a1 {
    public static void main(String[] args) {
        //静态初始化-创建+赋值
        int[] nums1 = {1,3,5,7,9};
        //动态初始化:包含默认初始化int为0、String为null
        int[] nums2 = new int[10];
        nums2[0] = 2;
        System.out.println(nums1[3]);
        System.out.println(nums2[0]);
        System.out.println(nums2[1]);
    }
}
/*注;
1、定义的数组可以是任何数据类型
2、数组对象本身是在堆中
3、数组越界了会报错-ArraylndexOutofBounds
 */

简单的for数组应用

//简单的for数组的使用
package c;

public class a2 {
    public static void main(String[] args) {
        int[] nums1 = {1,2,3,4,5};
        //打印全部数组元素
        for (int i = 0; i < nums1.length; i++) {
            System.out.println(nums1[i]);
        }
        System.out.println("-----------");
        //计算所有元素的和
        int sum = 0;
        for (int i = 0; i < nums1.length ; i++) {
            sum = sum +nums1[i];
        }
        System.out.println("sum="+sum);
        //查找最大元素
        int max = nums1[0];
        for (int i = 0; i < nums1.length; i++) {
            if(nums1[i]>max){
                max = nums1[i];
            }
        }
        System.out.println("max="+max);
    }
}

增强型的-与方法的联用

//增强型的-与方法的联用

package c;

import java.sql.SQLOutput;

public class a201 {
    public static void main(String[] args) {
        int[] nums1 = {1, 2, 3, 4, 5};
        //没有下标-更简单的操作  数组对象:数组名
        for (int i : nums1) {
            System.out.println(i);
        }
        printArray(nums1);
        int[] reverse = reverse(nums1);
        System.out.println("\t");
        printArray(reverse);

    }

    //打印数组元素
    public static void printArray(int[] nums1) {
        for (int i = 0; i < nums1.length; i++) {
            System.out.print(nums1[i] + " ");
        }
    }

    //反转数组
    public static int[] reverse(int[] nums1) {
        int[] result = new int[nums1.length];
        //反转的操作
        for (int i = 0, j = result.length - 1; i < nums1.length; i++, j--) {
            result[j] = nums1[i];
        }
        return result;
    }
}

多维数组-二维类推

/* 多维数组-二维类推
int a[][] = new int[2][5] 可以看成两行五列的数组
 */
package c;

public class a3 {
    public static void main(String[] args) {
        //[4][2]
        /*
            1,2 array[0]
            2,3 array[1]
            3,4 array[2]
            4,5 array[3]
         */
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};
        System.out.println(array[0]);
        printArray(array[0]);
        System.out.println("\t");
        System.out.println(array[0][0]);
        System.out.println(array[3][0]);
        System.out.println(array.length);
        System.out.println(array[0].length);
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j <array[i].length ; j++) {
                System.out.print(array[i][j]+"\t");
            }

        }

    }
    public static void printArray(int[] nums1) {
        for (int i = 0; i < nums1.length; i++) {
            System.out.print(nums1[i]);
        }
    }

}

使用数组Array类的工具-在帮助文档里看定义

// 使用数组Array类的工具-在帮助文档里看定义
package c;

import java.util.Arrays;

public class a4 {
    public static void main(String[] args) {
        int[] a={5,3,1,7,888,666};
        System.out.println(a);
        //打印数组元素Arrays.toString
        System.out.println(Arrays.toString(a));
        printArray(a);
        //对数组进行排序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        //数组填充
        Arrays.fill(a,1,6,0);
        System.out.println(Arrays.toString(a));
    }
    //也可以自己创建一个方法
    public static void printArray(int[] a){
        for (int i = 0; i < a.length; i++) {
            if(i==0) {
                System.out.print("【");
            }
            System.out.print (a[i]+",");
            if(i==a.length-1){
                System.out.println("】");
            }
        }
    }
}

冒泡排序

/* 冒泡排序
1、相邻两两依次比较换位进行排序
2、时间复杂度高
 */
package c;

import java.util.Arrays;

public class a5 {
    public static void main(String[] args) {
        int[] a={5,4,7,88,2,3,9};
        sort(a);//调用完我们自己写的排序方法后返回排序数组
        System.out.println(Arrays.toString(a));
    }
    public static void sort(int[] array){
        //临时变量
        int temp = 0;
        //外层循环,判断我们这个要走多少次
        for (int i = 0; i < array.length-1; i++) {
            boolean flag = false;//通过flag标识位减少没有意义的比较
           //内层循环,比值两个数,如果第一个数比第二个数大,则换位
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j+1]>array[j]){
                   temp = array[j];
                   array[j] = array[j+1];
                   array[j+1] =temp;
                   flag = true;
                }

            }
            if (flag == false){
                break;
            }
        }

    }
}

稀疏数组-一个数组中大部分元素为0

/* 稀疏数组-一个数组中大部分元素为0
将不同值的数值单独记,从而压缩程序的规模
 */
package c;

import java.util.Arrays;

public class a6 {
    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();
        }
        //2.转换为稀疏数组保存
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("===================");
        System.out.println("有效个数为:"+sum);
        //3.创建一个稀疏数组的数组
        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("还原");
        //1.还原原数组行列数
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //2.还原原数组数值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]]=array2[i][2];

        }
        //打印
        System.out.println("输出还原的数组");
        System.out.println("输出的原始数组");
        for (int[] ints : array1) { //循环识别每个数组(一行一行的)
            for (int anInt : ints) { // 循环识别每个数组的内容
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}

标签:int,System,数组,println,nums1,out
From: https://www.cnblogs.com/moulixu/p/18300353

相关文章

  • 2024/7/13 每日一题:数组是否有序
    3011.数组是否可以变为有序给你一个下标从0开始且全是正整数的数组nums。一次操作中,如果两个相邻元素在二进制下数位为1的数目相同,那么你可以将这两个元素交换。你可以执行这个操作任意次(也可以0次)。如果你可以使数组变有序,请你返回true,否则返回false。......
  • js 树形数组转一维数组,或一维数组转树形数组
    树形数组转一维数组要将一棵树结构(包含children属性)拍平为一个一维数组,可以使用递归或迭代的方法。下面是两种常见的实现方式:1.使用递归functionflattenTree(tree){letresult=[];tree.forEach(node=>{result.push(node);if(node.children){......
  • 【C++编程】数组、函数、结构体、指针、类
    数组:存储一个固定大小的相同类型元素的顺序集合声明、初始化:typearrayName[size0][size1]...={{value00,value01,...},{value10,value11,...},...};intmy_array[2][3]={{1,2,3},{4,5,6}};访问数组元素:arrayName[index0][index1]...;intget_eleme......
  • C语言——数组、sizeof关键字
    一、数组1.数组的引入与定义: C语言中的数组是一种基本的数据结构,用于在计算机内存中连续存储相同类型的数据。数组中的每个元素可以通过索引来访问,索引通常是一个整数,用于指定元素在数组中的位置。在C语言中,数组索引是从0开始的。 要使用数组,必须在程序中先定义数组,即通知......
  • C++数组 字符串
    是什么:相同类型元素的集合写法:intexample[3]//数组在声明大小时必须为常数数组名example是个指针类型如int*ptr=example;数组索引的工作原理:example[3]//从首地址位置偏移数组类型大小(int是4字节)乘索引值(4*3)个字节//从当前字节位置往后读四个字节;可能出现的错误:ex......
  • [LeetCode]961. 在长度 2N 的数组中找出重复 N 次的元素
    /*961.在长度2N的数组中找出重复N次的元素已解答简单给你一个整数数组nums,该数组具有以下属性:nums.length==2*n.nums包含n+1个不同的元素nums中恰有一个元素重复n次找出并返回重复了n次的那个元素。示例1:输入:nums=[1,2,3,3]输出:3示例2:输入......
  • 数组
    数组相同类型数据的有序集合,数组也是对象,数组长度一旦确定不可更改。每一个数据被称为一个数组元素,每个数组元素可以通过索引(下标,从0开始)访问必须先声明数组变量,才能使用数组:数据类型[]数组名称;例:Int[]nums;Java用new操作符创建数组,例:nums=newint[10];获取数......
  • 后缀数组【jiangly模板】
    目录后缀数组简介后缀数组可以用于什么场景如何实现后缀数组倍增法求后缀数组\(height\)数组\(LCP\)(最长公共前缀)\(height\)代码模板参考文章后缀数组是一种非常强大的一种处理字符串问题的工具后缀数组简介前置知识:计数排序、基数排序后缀数组(SuffixArray)主要关系到两......
  • 信息学奥赛初赛天天练-45-CSP-J2020阅读程序1-字符数组默认值、字符串长度、字符数组
    PDF文档公众号回复关键字:202407122020CSP-J阅读程序11阅读程序(程序输入不超过数组或字符串定义的范围;判断题正确填√,错误填×。除特殊说明外,判断题1.5分,选择题3分,共计40分)01#include<cstdlib>02#include<iostream>03usingnamespacestd;0405ch......
  • 数组的基本知识
    数组的定义数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们。(从0开始)数组声明创建首先必须声明数组变量,才能在程序中使用数组。下面是声明数组......