java三种排序及二维数组

最新推荐文章于 2024-10-03 22:26:28 发布
最新推荐文章于 2024-10-03 22:26:28 发布
阅读量2.9k 收藏 8
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43289802/article/details/83313744
版权

排序

冒泡排序

public class TestDemo {
    //冒泡排序
    public static void bubbleSort(int[] array) {
        boolean val = false;
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    int tmp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = tmp;
                    val = true;
                }
            }
            if (!val) {
                break;
            }
        }
    }

    public static void main(String[] args) {
        int[] array = {1, 5, 15, 2, 9, 6, 35, 22};
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }
}

时间复杂度：
最好情况 O(n) 当输入的数组有序就是最好情况
最坏情况 O(n^2)
稳定性：在输入数组中有两个及以上相同的数，排序结束后数字前后位置不变
稳定

直接插入排序

public class TestDemo {   
    //直接插入排序
    public static void insertSort(int[] array) {
        int j = 0;
        for (int i = 1; i < array.length; i++) {
            int tmp = array[i];
            for (j = i - 1; j >= 0; j--) {

                if (tmp < array[j]) {
                    array[j + 1] = array[j];
                } else {
                    break;
                }
            }
            array[j + 1] = tmp;
        }
    }
    
    public static void main(String[] args) {
        int[] array = {1, 5, 15, 2, 9, 6, 35, 22};
        insertSort(array);
        System.out.println(Arrays.toString(array));
    }
}

时间复杂度：
最好情况 O(n)
最坏情况 O(n^2)
稳定性：稳定

选择排序

public class TestDemo {  
    //选择排序
    public static void selectSort(int[] array) {
        for (int i = 0; i < array.length; i++) {
            for (int j = i + 1; j < array.length; j++) {
                if (array[i] > array[j]) {
                    int tmp = array[j];
                    array[j] = array[i];
                    array[i] = tmp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] array = {1, 5, 15, 2, 9, 6, 35, 22};        
        selectSort(array);
        System.out.println(Arrays.toString(array));        
    }
}

时间复杂度：： O(n^2)
稳定性：稳定

二维数组

定义

int[][] array = new int[2][3];
//第一种

int[][] array2 = {{1,2,3},{4,5,6},{7,8,9}};
//第二种

int[][] array3 = new int[2][];
array3[0] = new int[4];
array3[1] = new int[5];
//定义一个不规则数组

二维数组的拷贝

与一维数组相同，四种拷贝方式皆为浅拷贝
以下四种方法二维数组array1的初始值为10

for循环拷贝
class Arr {
    private int val = 10;

    public void setVal(int val) {
        this.val = val;
    }

    public int getVal() {
        return this.val;
    }
}

public class TestDemo1 {
	public static void main(String[] args) {
        Arr[][] array1 = new Arr[2][2];
        array1[0][0] = new Arr();
        array1[0][1] = new Arr();
        array1[1][0] = new Arr();
        array1[1][1] = new Arr();
        Arr[][] array2 = new Arr[2][2];
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                array2[i][j] = array1[i][j];
            }
        }
        for (int i = 0; i < array2.length; i++) {
            for (int j = 0; j < array2[i].length; j++) {
                System.out.print(array2[i][j].getVal() + " ");
            }
            System.out.println();
        }
        array2[0][0].setVal(100);
        System.out.println("================修改后===============");

        for (int i = 0; i < array2.length; i++) {
            for (int j = 0; j < array2[i].length; j++) {
                System.out.print(array2[i][j].getVal() + " ");
            }
            System.out.println();
        }
        System.out.println();
    }
}

输出结果：
在这里插入图片描述

.clone()
class Arr {
    private int val = 10;

    public void setVal(int val) {
        this.val = val;
    }

    public int getVal() {
        return this.val;
    }
}

public class TestDemo1 {
	public static void main(String[] args) {
        Arr[][] array1 = new Arr[2][2];
        array1[0][0] = new Arr();
        array1[0][1] = new Arr();
        array1[1][0] = new Arr();
        array1[1][1] = new Arr();
        Arr[][] array2 = new Arr[2][2];
        for (int i = 0; i < array1.length; i++) {
            array2[i] = array1[i].clone();
            for (int j = 0; j < array1[i].length; j++) {
                System.out.print(array2[i][j].getVal() + " ");
            }
            System.out.println();
        }
        array2[0][0].setVal(100);
        System.out.println("================修改后===============");
        for (int i = 0; i < array2.length; i++) {
            for (int j = 0; j < array2[i].length; j++) {
                System.out.print(array2[i][j].getVal() + " ");
            }
            System.out.println();
        }
    }
}

输出结果:
在这里插入图片描述

Arrays.cpoyOf()
class Arr {
    private int val = 10;

    public void setVal(int val) {
        this.val = val;
    }

    public int getVal() {
        return this.val;
    }
}

public class TestDemo1 {
	public static void main(String[] args) {
        Arr[][] array1 = new Arr[2][2];
        array1[0][0] = new Arr();
        array1[0][1] = new Arr();
        array1[1][0] = new Arr();
        array1[1][1] = new Arr();
        Arr[][] array2 = new Arr[2][2];
        //array2 = Arrays.copyOf(array1, array1.length);
        //或者将循环中的Arrays.copyOf方法删掉，用上一行的方法拷贝
        for (int i = 0; i < array1.length; i++) {
            array2[i] = Arrays.copyOf(array1[i], array1[i].length);
            for (int j = 0; j < array1[i].length; j++) {
                // array2[j]=array1[j].clone();
                System.out.print(array2[i][j].getVal() + " ");
            }
            System.out.println();
        }
        array2[0][0].setVal(100);
        System.out.println("================修改后===============");
        for (int i = 0; i < array2.length; i++) {
            for (int j = 0; j < array2[i].length; j++) {
                System.out.print(array2[i][j].getVal() + " ");
            }
            System.out.println();
        }
    }
}

输出结果：
在这里插入图片描述

System.arraycopy()
class Arr {
    private int val = 10;

    public void setVal(int val) {
        this.val = val;
    }

    public int getVal() {
        return this.val;
    }
}

public class TestDemo1 {
	public static void main(String[] args) {
        Arr[][] array1 = new Arr[2][2];
        array1[0][0] = new Arr();
        array1[0][1] = new Arr();
        array1[1][0] = new Arr();
        array1[1][1] = new Arr();
        Arr[][] array2 = new Arr[2][2];
        for (int i = 0; i < array1.length; i++) {
            System.arraycopy(array1[i], 0, array2[i], 0, array1[i].length);            
            for (int j = 0; j < array1[i].length; j++) {
                System.out.print(array2[i][j].getVal() + " ");
            }
            System.out.println();
        }
        array2[0][0].setVal(100);
        System.out.println("================修改后===============");
        for (int i = 0; i < array2.length; i++) {
            for (int j = 0; j < array2[i].length; j++) {
                System.out.print(array2[i][j].getVal() + " ");
            }
            System.out.println();
        }
    }
}

输出结果：
在这里插入图片描述

Allen..
关注
Java零基础（七）之数组排序+二维数组
默主归沙的博客
06-05 585
排序基础 冒泡排序(重点)冒泡排序：相邻两数两两比较，大的放右边，比较完一轮后，最右边的数为最大值；以此类推共比较(长度-1)轮 流程： 1.先画图分析 2.再写代码 选择排序(重点) 插入排序(扩展)系统提供的排序 一维数组练习(斐波拉契数列) 二维数组（掌握基本使用） 二维数组： 一维数组的一维数组，可以看成一维数组中的元素又是一个一维数组 二维数组的赋值与取值 二维数组的遍历 二维数组的创建 二维数组的练习(杨辉三角)......
JAVA-基础⑦二维数组与排序
weixin_66768178的博客
04-30 1830
1、 冒泡排序（Bubble Sort） 冒泡排序是所有排序算法中最简单的一个排序，也是我个人学习的第一个排序方法，在这里重新进行一个总结。 冒泡排序（Bubble Sort）就如同其名称一样，水中的气泡由于压强的原因所以从下到上其大小也是从小到大，如下图 整个排序过程分为一个大循环和大循环中的很多小循环进行，我们先来讲其中的小循环他做的事情： 每次小循环其实做的事情都很简单，就是单纯的循环所有数据找到其中最大值，将最大值放到当前比较数据的最后一个位置。下面给大家举个例子： 第一步，我们需要一
二维数组排序
09-29
public class Test { // 二维数组冒泡排序 public static void main(String[] args) { int i=0, j=0, temp = 0; int[][] nums1 = { { 34, 1, 22, 5 }, { 28, 98, 15, 32 }, { 33, -5, 17, 41 } }; int rows = nums1.length; //二维数组行的长度 int cols = nums1[0].length; //二维数组列的长度 int qty = rows*cols; //一维数组的长度（二维数组的列*宽） System.out.println("原始二维数组："); //打印原始二维数组 for(i=0;i<rows;i++) { for(j=0;j<cols;j++) {
【JAVA】基础：数组、二维数组、排序
qq_42755008的博客
12-21 3821
数组： 用于存储大量同一类型的数据。 数组的定义格式： 数据类型 数组名[ ]=new 数据类型[数组长度 ]； 给值： 1.数组名 [下标 ]=值； 如：数组名[ 0]=10; 数组名[ 1]=20; 2.数据类型 数组名[ ]={值，值，值…}; 数组默认值是0 注意： 数组下标是从0开始的，注意不要赋值或访问越界。 比如：数组的长度是2，就只能给下标0、1赋值。如果超出了就会报访问越界错...
Java中的数组
最新发布
m0_72047169的博客
10-03 1648
数组相当于程序中的容器，是一种重要的基础数据结构，用于存储一系列相同类型的数据。用于存储固定大小的同类型元素的集合。每个数组都有一个固定的长度 (一旦创建，长度不可更改)，并通过一个索引（从0开始）来访问数组中的元素。引用数据类型，数组中的元素可以是任何数据类型。创建数组对象会在内存中开辟一整块“连续的空间”，占用内存空间大大小，取决于数组的长度和数组中元素的类型。数组中的元素在内存中是依次紧密排列的，有序的。数组的初始化完成，长度就确定，无法更改。数组名中引用的是这块连续空间的首地址。
java对二维数组进行排序
qq_41857397的博客
12-05 3247
java对二维数组进行排序
Java 多维数组排序
weixin_30474613的博客
05-29 316
Java 多维数组 按某列 排序 转载于:https://www.cnblogs.com/qlky/p/9105430.html
二维数组如何排序Java_java中二维数组排序
weixin_42667269的博客
02-25 770
package practice; import java.util.Scanner; public class Paixu{ static void sort2(int n,int m){ System.out.println("随机产生的"+n+"行"+m+"列数组:"); int [][] a = new int[n][m]; for (int i = 0;i < ...
二维数组如何进行冒泡排序
07-18
### 二维数组冒泡排序详解 #### 一、引言 冒泡排序是一种简单的排序算法，在数据处理领域有着广泛的应用。对于一维数组而言，冒泡排序实现起来相对容易；然而，当涉及到二维数组时，排序的过程就变得复杂起来。...
java课堂作业：用二维数组存储五个学生姓名学号，并用正则表达式判断输入数据是否有误。输出按学号排序的学生。
01-21
输入5个同学的学号和姓名（格式：“姓-名”），存储在二维数组中检查输入同学学号和姓名的格式，不符合要求，则输出提示：“数据格式错误，请重新输入”，对输入同学的信息按学号排序。这是今天java老师布置的课堂...
java byte 二维数组_Java基础之数组、二维数组
weixin_27645199的博客
02-13 1426
数组的概念：JAVA语言中提供的数组是用来存储类型相同的一组元素，数组分为一维数组和多维数组一维数组声明数组数组的声明和变量的声明是相同的，必须要先声明才能使用，声明之后jvm不会分配内存空间，只有实例化之后才会为数组分配内存空间。数组的声明有两种方式：数据类型[] 变量名；//这是Java声明数组首选的方法数据类型 变量名[]；//这是c语言声明数组的方式创建数组：一：1.声明数组2.实例...
java多维数组排序（代码）
10-05
题目： 假定本学期某班上有5门课，该班上有10人 (1) 请输入该班同学的学号，姓名，5门课的成绩至数组A、B中，再按5门课的总分排序，然后列出排序后的序号，学号，姓名，成绩1~5； (2) 求出5门课的平均成绩
java对二维数组排序_java中怎么对二维数组的列排序？
weixin_36465618的博客
02-12 457
importjava.util.Arrays;publicclassTest{publicstatic>voidsort(Ta[][]){sort(a,true);}publicstatic>voidsort(Ta[][],booleanascend){sortHelper(a,0,a.length-1,ascend);}privatestat...
Java如何给二维数组排序
qq_32661351的博客
08-17 2505
首先，因为是对给定的二维数组排序 那么自然就对应Java官方库中的Arrays工具类 即：Arrays.sort(T[] a, Comparator<? super T> c) 如二维整型数组 int[][] 2darr = new int[10][10]; 则有： （下面写法是按照升序 ，降序则改为o2[0]-o1[0]） Arrays.sort(intervals, new Comparator<int[]>() { @Override
Java二维数组冒泡排序示例：模拟Excel行级排序
在这个Java代码片段中，我们讨论的主题是二维数组的排序，具体是基于冒泡排序算法对一个3x256的整型二维数组进行排序。首先，程序创建了一个名为`s`的数组，其中的元素通过生成随机数（范围在1到10之间）填充。这个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值