排序和二维数组

其他 2018-11-04 20:11:12 阅读次数: 0

排序

排序是数据处理中十分常见的且核心的操作，简单介绍最基础的三种排序：冒泡排序、直接插入排序、选择排序。

1、冒泡排序

冒泡排序是在一堆大小不一的数中，对这些不同的值进行排序所用的一种方法，它是将相邻的两个数相比较，前面的一个数比后面的一个数大（小），则这两个数交换位置，每一趟会将最小（或最大）的元素“浮”到顶端，最终达到完全有序。

代码实现

         public class  Test1{
            public  static void bubbleSort(int[] array){
             int tmp = 0;
             boolean swap = flase;  //优化设置一个标志，来判断是否有交换
             for(int i = 0;i < array.length - 1; i++){
             for(int j = 0;j < array.length - i -1; j++){
             if(array[j] > array[j+1]){
                 tmp = array[j];
                 array[j] = array[j + 1];
                 array[j + 1] = tmp;
                 swpa = true;
                 }
             }
                 if(!swap)    {
                 break;
           }            
         }
         }
         public static void main(String[]   args){
         int array[] = {1,2,5,3,6,9,7};
         System.out.println(Arrays.toString(array));
         }
         }

在这里插入图片描述

在冒泡排序中，若原来的数组是有序的，也就是最好的情况下，仅需n-1次比较就可完成，时间复杂度为:O(n).
若是倒序，也就是最坏的情况下，需要(n-1)+(n-2)+…+1=n(n-1)/2,时间复杂度为O(n^2).

稳定性：稳定

性能低于选择排序

2、直接插入排序(shell排序)

直接插入排序就是每一趟将一个待排序的记录，按照其关键字的大小插入到有序队列中的合适位置，直到全部插入。

代码实现

            public class Test1{
                   public static void insertSort(int[] array){  //直接插入
                   int tmp = 0;//临时量
                   for(int i = 1;i <= array.length;i++ ){   //i从1开始
                   tmp = array[i];//将array[i]的值放在tmp
                   for(int j = i - 1;j >= i - 1;j --){  //j是i前面的值
                   if(array[j] > tmp) {
                   array[j + 1] = array[j];
               }else{
                    break;
             }
                   array[j + 1] = tmp;
         }
         }
 }
    public static void main(String[] args) {
        int[] array =  {1,2,5,3,6,9,7};
        insertSort(array);
        System.out.println(Arrays.toString(array));
    }
}

在这里插入图片描述

插入排序在最好情况下，需要比较n次，无需交换元素，时间复杂度为O(n),在最坏情况下，时间复杂度为O(n^2)。
但是在数组元素随机排列的情况下，插入排序还是优于选择排序和冒泡排序的。
稳定性： 稳定

3、选择排序

最简单、最直观的的一种算法，基本思想为每一趟从待排序的数据元素中选择最小（或最大）的一个元素作为首元素，直到所有的元素排完为止。
       public class Test1{
             public  static void selectedSort(int[] array) {  //选择排序
             int tmp;
             for (int i = 0; i < array.length; i++) {
             for (int j = i + 1; j < array.length; j++)
             if (array[i] > array[i + 1]) {
                 tmp = array[i];
                 array[i] = array[j];
                 array[j] = tmp;

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

在这里插入图片描述

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

二维数组的拷贝

for()循环拷贝
     class TestArray2 {
        private int val;
        public void setVal(int val) {
        this.val = val;
    }
        public int getVal() {
        return this.val;
    }
}
     public class TestDemo10211 {
        public static void main(String[] args) {
        int[][] array = {{1, 2, 3}, {4, 5, 6}};
        int[][] brray = new int[2][3];
        for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array[i].length; j++) {
        brray[i][j] = array[i][j];
            }
        }
        System.out.println(Arrays.deepToString(array));
        System.out.println(Arrays.deepToString(brray));
        brray[0][0] = 1000;
        System.out.println("============修改完成=========");
        System.out.println(Arrays.deepToString(array));
        System.out.println(Arrays.deepToString(brray));
    }
}

在这里插入图片描述

system.arraycopy()

class TestArray2 {
    private int val;
    public void setVal(int val) {
        this.val = val;
    }
    public int getVal() {
        return this.val;
    }
}
public class TestDemo10211 {
    public static void main(String[] args) {
        TestArray2[][] testArray2 = new TestArray2[2][2];
        testArray2[0][0] = new TestArray2();
        testArray2[0][1] = new TestArray2();
        testArray2[1][0] = new TestArray2();
        testArray2[1][1] = new TestArray2();
        TestArray2[][] testArray3 = new TestArray2[2][2];
        for (int i = 0; i < testArray2.length; i++) {
            for (int j = 0; j < testArray2[i].length; j++) {
                testArray3[i][j] = testArray2[i][j];
            }
        }
        System.out.println("=============拷贝完成=========");
        for (int i = 0; i < testArray2.length; i++) {
            for (int j = 0; j < testArray2[i].length; j++) {
                System.out.print(testArray2[i][j].getVal()+" ");
            }
        }
        System.out.println();
        for (int i = 0; i < testArray3.length; i++) {
            for (int j = 0; j < testArray3[i].length; j++) {
                System.out.print(testArray3[i][j].getVal()+" ");
            }
        }
        System.out.println();

        testArray2[0][0].setVal(1000000);
        System.out.println("============修改完成=========");
        for (int i = 0; i < testArray2.length; i++) {
            for (int j = 0; j < testArray2[i].length; j++) {
                System.out.print(testArray2[i][j].getVal()+" ");
            }
        }
        System.out.println();
        for (int i = 0; i < testArray3.length; i++) {
            for (int j = 0; j < testArray3[i].length; j++) {
                System.out.print(testArray3[i][j].getVal()+" ");
            }
        }
        System.out.println();
    }
}

在这里插入图片描述

clone()

class TestArray2 {
    private int val;
    public void setVal(int val) {
        this.val = val;
    }
    public int getVal() {
        return this.val;
    }
}
public class TestDemo10211 {

    public static void main(String[] args) {
        TestArray2[][] testArray2 = new TestArray2[2][2];
        testArray2[0][0] = new TestArray2();
        testArray2[0][1] = new TestArray2();
        testArray2[1][0] = new TestArray2();
        testArray2[1][1] = new TestArray2();
        TestArray2[][] testArray3 = new TestArray2[2][2];
        //clone
        for (int i = 0; i <testArray2.length ; i++) {
            testArray3[i] = testArray2[i].clone();
        }
        System.out.println("=============拷贝完成=========");
        for (int i = 0; i < testArray2.length; i++) {
            for (int j = 0; j < testArray2[i].length; j++) {
                System.out.print(testArray2[i][j].getVal()+" ");
            }
        }
        System.out.println();
        for (int i = 0; i < testArray3.length; i++) {
            for (int j = 0; j < testArray3[i].length; j++) {
                System.out.print(testArray3[i][j].getVal()+" ");
            }
        }
        System.out.println();

        testArray2[0][0].setVal(1000000);
        System.out.println("============修改完成=========");
        for (int i = 0; i < testArray2.length; i++) {
            for (int j = 0; j < testArray2[i].length; j++) {
                System.out.print(testArray2[i][j].getVal()+" ");
            }
        }
        System.out.println();
        for (int i = 0; i < testArray3.length; i++) {
            for (int j = 0; j < testArray3[i].length; j++) {
                System.out.print(testArray3[i][j].getVal()+" ");
            }
        }
        System.out.println();

    }
}

在这里插入图片描述

Arrays.copyOf()
class TestArray2 {
    private int val;
    public void setVal(int val) {
        this.val = val;
    }
    public int getVal() {
        return this.val;
    }
}
public class TestDemo10211 {
    public static void main(String[] args) {
        TestArray2[][] testArray2 = new TestArray2[2][2];
        testArray2[0][0] = new TestArray2();
        testArray2[0][1] = new TestArray2();
        testArray2[1][0] = new TestArray2();
        testArray2[1][1] = new TestArray2();
        TestArray2[][] testArray3 = new TestArray2[2][2];
        // System.arraycopy();
        for (int i = 0; i < testArray2.length; i++) {
            testArray3[i] = Arrays.copyOf(testArray2[i], testArray2[i].length);
            System.arraycopy(testArray2[i], 0, testArray3[i], 0,
                    testArray2[i].length);
        }
        System.out.println(testArray3);
        System.out.println(testArray2);
        testArray3 = Arrays.copyOf(testArray2, testArray2.length);
        System.out.println(testArray3);
        System.out.println(testArray2);


        System.out.println("=============拷贝完成=========");
        for (int i = 0; i < testArray2.length; i++) {
            for (int j = 0; j < testArray2[i].length; j++) {
                System.out.print(testArray2[i][j].getVal() + " ");
            }
        }
        System.out.println();
        for (int i = 0; i < testArray3.length; i++) {
            for (int j = 0; j < testArray3[i].length; j++) {
                System.out.print(testArray3[i][j].getVal() + " ");
            }
        }
        System.out.println();

        testArray2[0][0].setVal(1000000);
        System.out.println("============修改完成=========");
        for (int i = 0; i < testArray2.length; i++) {
            for (int j = 0; j < testArray2[i].length; j++) {
                System.out.print(testArray2[i][j].getVal() + " ");
            }
        }
        System.out.println();
        for (int i = 0; i < testArray3.length; i++) {
            for (int j = 0; j < testArray3[i].length; j++) {
                System.out.print(testArray3[i][j].getVal() + " ");
            }
        }
        System.out.println();

    }
}

在这里插入图片描述

二维数组打印 ： System.out.println(Arrays.deepToString(array));

可变参数编程：

**可变参数的格式：

访问控制符 [修饰符] 返回值类型 方法名（参数类型…参数名）{

程序代码；

[return 返回值；]

}

其中，向方法中传入的参数是以数组的形式保存的。**

可变参数的方法和数组作为参数的方法的区别：

（1）在可变参数的方法传入参数时，可变参数要放在最后；而已数组作为参数的方法在传入参数时，数组参数可以放在参数列表的任何位置。
（2）一个方法只能定义一个可变形参，但可以定义多个数组形参。
（3）方法定义的可变形参可以接收数组实参。

“ 匿名数组”

匿名数组是没有名字的数组, 通过指针或直接引用数组本身来使用, 包括匿名字符串.

举例：

printf("%s", “Hello!”);

这里的"Hello!"其实就是匿名字符串, 即匿名字符数组.

使用数组时，一般需要先声明数组变量，然后创建并初始化一个数组并赋值给声明的数组。java语言也支持匿名数组，及在需要数组变量的地方，直接创建一个匿名数组。

new 数组类型[] {初始值设定项}； //创建一个一维匿名数组

new 数组类型[][] {初始值设定项}；//创建一个二维匿名数组

使用匿名数组你可以任意地创建任何长度的数组传递给方法。一些典型的例子就是用在一些接收可变参数的聚合函数中如：sum()、avg()、min()、max()等等。

使用匿名数组最佳方式就是实现可变参数的方法中，它能够调用不同数量的参数，这些方法预期接收的是一个数组类型，当代码调用这个方法，它创建一个匿名的不同长度的数组然后传递给方法处理。

二维数组

二维数组的定义：

可以简单理解为在数组中又存储了数组

两种初始化形式

格式1: 动态初始化
数据类型 数组名 [ ][ ] = new 数据类型[m][n]数据类型 [ ][ ] 数组名 = new 数据类型[m][n]数据类型 [ ] 数组名 [ ] = new 数据类型[m][n]
举例：int [ ][ ] arr=new int [5][3]; 也可以理解为“5行3例”
格式2: 静态初始化数据类型 [ ][ ] 数组名 = {{元素1,元素2…},{元素1,元素2…},{元素1,元素2…}…};
举例：int [ ][ ] arr={{22,15,32,20,18},{12,21,25,19,33},{14,58,34,24,66},};

猜你喜欢

转载自blog.csdn.net/weixin_43301647/article/details/83280689
今日推荐
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
周排行
计算机组成与设计（七）—— 除法器
Integer Approximation(分治+枚举)
大话数据库索引
windows10系统JDK的配置及下载地址
mysql实现秒值转换中原六仔平台搭建
Codeforces Round #556 (Div. 1)
百练1064 网线主管
Codeforces 995F Cowmpany Cowmpensation
子集生成之增量构造法，位向量法，二进制法
ERROR: cmd.exe failed with args /c "/APK\gradle\rungradle.bat...
每日归档
更多
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022