java数组、冒泡排序，稀疏数组

最新推荐文章于 2024-08-28 19:47:50 发布

sw_eet

最新推荐文章于 2024-08-28 19:47:50 发布

阅读量172

点赞数

文章标签： java 排序算法

本文链接：https://blog.csdn.net/sw_eet/article/details/103568173

版权

数组

数组的定义

数组是相同类型数据的有序集合
数组描述相同数据的若干数据，按一定的先后顺序排列而成
每一个数据称数组元素，用数组的下标访问它们
数组的下标从0开始

数组的创建、声明

数组长度是确定的，一旦被创建大小就不可以改变,如果越界会报ArrayIndexOutofBounds错误
其类型必须相同，不能出现混合类型
数组中的元素可以是任何数据类型，包括基本类型和引用类型
数字变量属于引用类型，数组也可看成对象，数组中的每个元素，相当于该对象的成员变量，数组本身就是对象，java的对象是在堆中的，数组对象是在堆中的
数组元素通过索引访问，从0开始
获取数组长度，aray.length

 public static void main(String[] args) {

        int[] nums;                //声明一个数组
        nums=new int[10];          //创建一个数组
        
        int[] nums2=new int[10];     //一步完成
        
        nums[0]=0;
        nums[1]=1;
        nums[2]=2;
        nums[3]=3;
        nums[4]=4;
        nums[5]=5;
        nums[6]=6;
        nums[7]=7;
        nums[8]=8;
        nums[9]=9;
        
     for (int i = 0; i < nums.length; i++) {
            System.out.println(nums[i]);
        }
        
    }

内存分析

堆

存放new的数组和对象
可以被所有线程共享，不会存放别的对象引用

栈

存放基本变量类型（会包含这个基本类型的具体数据）
引用对象的变量（会存放这个引用在堆里的具体地址）

方法区

可以被所有线程共享
包含了所有的class和staic变量

 public static void main(String[] args) {

        //静态初始化
        int[] nums={1,2,3,4,5,6};
        for (int i = 0; i < 6; i++) {
            System.out.println(nums[i]);
        }

        System.out.println("===============================");
        //动态初始化
        //初始未赋值，默认为0
        int[] nums2=new int[6];
        nums2[0]=1;
        nums2[1]=2;
        for (int i = 0; i < 6; i++) {
            System.out.println(nums2[i]);
        }

    }

数组的使用

普通for循环

 public static void main(String[] args) {

        int[] arrays={1,2,3,4,5};

        //打印全部数组元素
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }
        System.out.println("===========================");
        //计算所有元素总和
        int sum=0;
        for (int j = 0; j < arrays.length; j++) {
            sum=sum+arrays[j];
        }
        System.out.println("总和为："+sum);
        System.out.println("===========================");
        //查找最大元素
        int max=arrays[0];
        for (int k = 1; k <arrays.length ; k++) {
            if(max<arrays[k]){
                max=arrays[k];
            }
        }
        System.out.println("最大数为："+max);
    }

增强for循环

 public static void main(String[] args) {
        int[] arrays={1,2,3,4,5,6};

        //jdk1.5以后才有，无下标
        for (int i : arrays) {
            System.out.println(i);
        }
    }

数组作为方法传入参数
数组作为返回值

 public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5, 6};

        printarrays(arrays);
        reverse(arrays);
        printarrays(arrays);
        }

    //打印数组元素
    // 作为传入参数
    public static void printarrays(int[] arrays){
        for (int i = 0; i <arrays.length ; i++) {
            System.out.print(arrays[i]+"  ");
        }
        System.out.println();
    }
    //反转数组
    //作为返回值
    public static int[] reverse(int[] arrays){

        int a=0;
        for (int i = 0; i <(arrays.length)/2 ; i++) {
            a=arrays[i];
            arrays[i]=arrays[arrays.length-1-i];
            arrays[arrays.length-1-i]=a;
        }

        return arrays;
    }

多维数组

多维数组可以看成数组的数组，例如二维数组就是一个特殊的一维数组，其中每一个元素就是一个一维数组

二维数组

 public static void main(String[] args) {

        int[][] arrays={{1,2},{2,3},{3,4},{4,5},{5,6}};

        //使用for循环打印
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j <arrays[i].length ; j++) {
                System.out.print(arrays[i][j]+" ");
            }
        }
    }

Array类

数组工具类，java.util.Arrays
由于数组对象本神并没有什么方法供我们调用，但API中提供了一个工具类Arrays，供我们使用从而可以对数据对象进行一些基本操作
具体包含的请看JDK帮助文档
Arrays类中的方法，都是static修饰的静态方法，在使用时可以直接使用类名进行调用，而”不用“使用对象来调用（注意是”不用“不是”不能“）

常用功能

给数组赋值，通过fill方法
对数组排序，通过sort方法，按升序
比较数组，通过equals方法，比较数组中元素是否相等

查找数组元素，通过binarySearch方法，对排好序的数组进行二分查找法操作

public class ArraysDemo06 {
    public static void main(String[] args) {
        int[] a={5,23,6,9,48,56,12,46,63,85,154,1};
        //打印数组元素
        System.out.println(Arrays.toString(a));
        printarrays(a);
        System.out.println("=================================================");
        //排序,升序
        Arrays.sort(a);
        printarrays(a);
        System.out.println("=================================================");
        //fill赋值
        Arrays.fill(a,0);//全赋值为0
        printarrays(a);
        Arrays.fill(a,2,5,6);//2-5之间赋值为0，不包括2、5
        printarrays(a);
    }

    //打印数组,,,,,开始造轮子
    public static void printarrays(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            if(i==0){
                System.out.print("["+arrays[0]+", ");
            }else if(i==arrays.length-1){
                System.out.println(arrays[i]+"]");
            }else {
                System.out.print(arrays[i]+", ");
            }
        }
    }
}

冒泡排序（8大排序之一）

两层循环，外层冒泡轮数，内层依次比较
两层循环嵌套，时间复杂度为O(n^2)
冒泡排序，比价数组中两个相邻的元素，第一个大于第二个，则交换
每一次比较都会产生一个最大或最小的数
下一轮会少一次排序
依次循环直到结束

public class ArrayDemo07 {
    public static void main(String[] args) {
        int[] a={5,23,6,9,48,56,12,46,63,85,154,1};
        int[] b={5,23,6,9,48,56,12,46,63,85,154,1};
        sorts(a);
        System.out.println(Arrays.toString(a));
        System.out.println("===================================================");
        Arrays.sort(b);
        System.out.println(Arrays.toString(b));
    }

    //冒泡排序，比价数组中两个相邻的元素，第一个大于第二个，则交换
    //每一次比较都会产生一个最大或最小的数
    //下一轮会少依次排序
    public static void sorts(int[] arrays){
        //判断走多少次
        for (int i = 0; i <arrays.length ; i++) {
            //判断其是否有序，若第一次不进行任何赋值，则就是有序数组
            boolean flag=false;
            //从第一个与后面的一一对比
            for (int j = 0; j < arrays.length-i-1; j++) {
                if(arrays[j]>arrays[j+1]){
                    int a=arrays[j+1];
                    arrays[j+1]=arrays[j] ;
                    arrays[j]=a;
                    flag=true;
                }
                if(flag==false){
                    //若一趟不进行任何赋值，则就是有序数组
                    //直接结束排序
                    break;
                }
            }
        }

    }

}
//出现错误java.lang.ArrayIndexOutOfBoundsException
//问题是数组下标越界

稀释数组

数组中有很多值是相同的，只有几个是修改的，我们只需存储修改值就好，可以节省空间
稀疏数组的处理方式
- 记录数组有几行几列
- 把具有不同值元素的行和列，记录到小规模数组中，从而缩小程序规模（压缩）
- 下表第一行表示数组为6行7列数组共8个值不为0，之后每行表示该行该列的值

稀疏数组

public class ArrayDemo08 {
    public static void main(String[] args) {
        //创建一个11*11,0是无棋，1是白棋，2是黑棋
        int[][] arrays=new int[11][11];
        arrays[1][2]=1;
        arrays[2][3]=2;

        //输出原始数据
        System.out.println("输出原始数据");
        for (int[] array : arrays) {
            for (int i : array) {
                System.out.print(i+"\t");
            }
            System.out.println();
        }
        //转换为稀疏数组存储
        //1.获取有效值得个数
        int num=0;
        for (int[] array : arrays) {
            for (int i : array) {
                if(i!=0){
                    num++;
                }
            }
        }
        System.out.println("================================================");
        System.out.println("有效值个数"+num);
        //创建稀疏数组
        int[][] array1=new int[num+1][3];
        //把数据记录到稀疏数组
        int count=1;
        array1[0][0]=arrays.length;
        array1[0][1]=arrays[0].length;
        array1[0][2]=num;
        //遍历数组，将不为0的存放在稀疏数组中
        for (int i = 0; i <arrays.length ; i++) {
            for (int j = 0; j <arrays[i].length ; j++) {
                if(arrays[i][j]!=0){
                    array1[count][0]=i;
                    array1[count][1]=j;
                    array1[count][2]=arrays[i][j];
                    count++;
                }
            }
        }
        //打印稀疏数组
        System.out.println("================================================");
        System.out.println("打印稀疏数组");
        for (int[] ints : array1) {
            for (int k : ints) {
                System.out.print(k+"\t");
            }
            System.out.println();
        }
        //还原稀疏数组
        System.out.println("================================================");
        System.out.println("还原稀疏数组");
        //创建数组
        int[][] array2=new int [array1[0][0]][array1[0][1]];
        //给数组还原值
        for (int i = 1; i <array1.length ; i++) {
            array2[array1[i][0]][array1[i][1]]=array1[i][2];
        }
        //打印还原结果
        for (int[] ints : array2) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

    }
}

idea快捷键

5.for+enter，自动生成循环

arrays（数组名）.for+enter，自动生成增强for循环

i.for/fori+enter，自动生成循环结构

psvm+enter，自动生成mian函数

sout+enter，自动生成输出语句

sw_eet

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java数组、冒泡排序，稀疏数组

数组数组的定义数组是相同类型数据的有序集合数组描述相同数据的若干数据，按一定的先后顺序排列而成每一个数据称数组元素，用数组的下标访问它们数组的下标从0开始数组的创建、声明数组长度是确定的，一旦被创建大小就不可以改变,如果越界会报ArrayIndexOutofBounds错误其类型必须相同，不能出现混合类型数组中的元素可以是任何数据类型，包括基本类型和引用类型数字变量属于引...
复制链接

扫一扫