当前位置： 首页 > article >正文

【Java小白图文教程】-05-数组和排序算法详解

article 2024/10/26 10:31:21

 精品专题：

01.《C语言从不挂科到高绩点》课程详细笔记

https://blog.csdn.net/yueyehuguang/category_12753294.html?spm=1001.2014.3001.5482

02. 《SpringBoot详细教程》课程详细笔记

https://blog.csdn.net/yueyehuguang/category_12789841.html?spm=1001.2014.3001.5482

03.《SpringBoot电脑商城项目》课程详细笔记

https://blog.csdn.net/yueyehuguang/category_12752883.html?spm=1001.2014.3001.5482

04.《VUE3.0 核心教程》课程详细笔记

https://blog.csdn.net/yueyehuguang/category_12769996.html?spm=1001.2014.3001.5482

================================

||     持续分享系列教程，关注一下不迷路 ||

||                视频教程：墨轩大楼               ||

================================

1. 容器的概述

 如果需要完成一个学生成绩管理系统，有50名学生，需要计算50名学生的平均成绩，目前为止，可能考虑到的解决方法：定义50个变量分别表示每个 学生的成绩，然后将50个变量全部累加，除以总人数。针对于以上问题的解决方案显示是不合适的，因此需要有一个能够存储50个相同数据类型的容器

容器：是一种存储结构，现实生活中的容器：杯子，教室，公交车。。。

有关容器的概念关联一门课程：数据结构(数据存储的一种表现方式)

其中数据结构中最为简单的就是数组

2.数组入门

2.1 概述

数组是一种容器，用来存储一组相同数据类型的容器，是一种引用数据类型，从数据结构上来说数组是一种典型的线性结构

2.2 数组声明的语法

数据类型[] 数组名称

int a;//用来存储一个整形数据
//数组的声明
int[] arr;//用来存储一组整形数据
int arr2[];//用来存储一组整形数据(不推荐)

double[] brr;
String[] strs;

2.3 数组的初始化

任何的局部变量再未初始化时是无法使用的，数组同理，也必须初始化之后才能使用，数组的初始化分为两种方式

  1. 静态初始化
  2. 动态初始化
2.3.1. 静态初始化

静态初始化指的是再声明数组的同时为数组指定元素：

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

{}之间每个值都是数组中的一个元素，中间用逗号隔开(标点符号为英文输入法下的符号)

注意事项

以下声明方式是错误的

int[] arr;//用来存储一组整形数据
arr = {1,2,3,4};

以上的写法需要改为

int[] arr;//用来存储一组整形数据
arr = new int[]{1,2,3,4};
2.3.2 动态初始化

动态初始化即再声明数组的时候只指定数组的容量(空间大小)，但是不为数组指定具体的每一个元素

int[] c = new int[4];
//int[] d = new int[];//编译错误，使用动态初始化的时候必须给让容量

以上的写法，表示定义了一个容量为4的数组，数组中的每一个元素只能是整数

动态初始化一定要指定容量，否则编译错误

特别注意：数组一旦声明，他的容量是不可改变的

2.4 获取数组中的元素

2.4.1 数组的索引

数组中的每一个元素都有一个独一无二的索引(下标)位置，索引从0开始； 如果需要获取数组中的指定元素或者为数组中的指定元素赋值，都必须通过索引来完成，任何一个数组都有一个length(数组的元素的个数，也叫做数组的长度)属性

获取元素

通过数组名称加上对应位置的索引

数组名[索引]

//1.静态初始化
int[] b = {1,2,3,4};

//2.动态初始化
int[] c = new int[4];

int x = c[1];
int y = b[1];
System.out.println(x);
System.out.println(y);

在获取数组中元素的时候要注意索引的范围：0~ length -1，数组中元素的个数为length，最大的索引值为length-1，如果使用了一个超出范围的索引去获取元素，那么语法上是不会有问题，但是在运行过程中会出现java.lang.ArrayIndexOutOfBoundsException 异常(该异常表示数组下标越界异常)

数组元素赋值

使用数组索引除了可以获取元素之外，也可以通过索引为数组的指定位置赋值

//数组c的第三个元素赋值为100
c[2] = 100;
System.out.println(c[2]);

注意：数组元素的赋值过程中，你所赋值的元素一定要和数组中所存放的数据类型匹配

2.4.2 数组的遍历

在实际开发过程中经常需要将数组中的所有元素都获取到，如果我们单独的使用每一个元素的索引一个个 的去获取这样效率太低；已知数组的索引从0开始，并且数组的长度是有length属性的，因此使用循环语句就能轻松的实现对数组进行遍历

String[] strs = {"强哥","苍#null","翠花","凤姐"};

for (int i = 0; i < strs.length; i++) {
    System.out.println(strs[i]);

}
int i = 0;
while(i < strs.length){
    System.out.println(strs[i]);
    i++;
}

int x = 0;
do{
    System.out.println(strs[x]);
    x++;
}while(x<strs.length);


int[] arrs = {1,2,5,8,10,15,13,20};
//遍历出数组中不是5的倍数的元素
for (int j = 0; j < arrs.length; j++) {
    if(arrs[j]%5 != 0){
        System.out.println(arrs[j]);
    }
}

以上对数组的遍历方式都是使用常规的循环语句解决，在JDK1.5的时候，引进了一种全新的循环方式：增强for循环(forEach循环)，语法规则

for(数组中单个元素的数据类型 变量名:需要遍历的数组名){
    循环体
}
String[] strs = {"强哥","苍#null","翠花","凤姐"};
//这种forEach遍历方式就和索引没有什么直接关系了
for (String name:strs){
    System.out.println(name);
}

增强for循环的实现原理为:迭代器(类似于栈结构的线性存储结构)；元素的获取不需要通过索引完成，而是在使用迭代器的指针(游标)，依次往下迭代获取元素

forEach实际上是一种针对迭代器的语法糖技术

2.5 数据拷贝

由于数组存在弊端:数组的长度一旦定义就无法改变；但是对于一些特殊的需求，无法确定数组中元素的具体个数；针对这个问题，解决方案只有一种:初始化一个固定容量的数组，存储元素，一旦存储空间不足，则创建一个更大容量的新数组，将源数组中的元素拷贝到新的数组中，后续的元素向新数组中添加即可。因此以上的问题解决方案的关键在与:组数的拷贝

  1. 使用传统循环实现数组的拷贝
int[] a = {3,4,5,6};
//{3,4,5,6,7}
//定义一个比原数组容量大一个的新数组
int[] b = new int[a.length+1];
//从原数组中每一个元素取出来赋值到新的数组的对应位置
for (int i = 0; i < a.length; i++) {
    b[i] = a[i];
}
//将新元素赋值到新数组的最后一个位置
b[b.length-1] = 7;
for (int x:b) {
    System.out.println(x);
}
  1. 数组拷贝的方法
//原数组
int[] a = {3,4,5,6};
//新数组
int[] b = new int[7];
/*
参数1：原始数组对象
参数2：原始数组的初始拷贝位置(索引位置)
参数3：目标数组对象
参数4：目标数组的起始位置(索引位置)
参数5：拷贝的元素的个数
*/
System.arraycopy(a,0,b,0,a.length);
b[b.length-1] = 100;
for (int x:b) {
    System.out.println(x);
}

2.6 数组练习

  1. 完成一个抽奖系统，要求从一组候选的名单中随机抽取一名幸运儿，表示中奖了，要求可以反复抽取，但是不能抽取到重复的幸运儿。
//自定义一个抽奖候选名单 0  1      2      3     4
String[] names = {"亮亮","佳文","雨立","豪哥","阿虎儿"};
//{"亮亮","佳文","豪哥","阿虎儿"}
//获取总人数
int con = names.length;
Scanner scanner = new Scanner(System.in);
//循环抽奖
while(con>0){
    System.out.println("按回车键抽取");
    scanner.nextLine();
    //获取一个随机索引
    int index = (int)(Math.random()*con);
    //获取幸运观众
    String name = names[index];
    System.out.println("恭喜你,"+name+"喜提编程题500道！！！");
    con--;
    //数组拷贝
    System.arraycopy(names,index+1,names,index,names.length-index-1);
}
System.out.println("抽奖结束");
  1. 有一组数组{6，3，4，2，1，9，10，8}，按照元素的大小顺序从小到大输出 （排序）

3. 数组的排序

3.1 排序分类

1. 冒泡排序

算法思路：

  1. 比较相邻的元素，如果第一个比第二个大，就交换位置
  2. 对每一对相邻的元素做同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素就是最大的元素
  3. 针对所有的元素重复以上操作，除了最后一个
  4. 重复盘1~3，直到排序完成

int[] arr = {6,3,4,2,1,9,10,8};
System.out.println("排序前：" + Arrays.toString(arr));

for(int j = 1;j<arr.length;j++){//控制比较的轮数
    for (int i = 0;i<arr.length-j;i++){//每轮儿比较的次数
        //声明一个变量用作辅助
        int temp;
        if(arr[i]>arr[i+1]){
            //换位置
            temp = arr[i];
            arr[i] = arr[i+1];
            arr[i+1] = temp;
        }
    }
    System.out.println("第"+j+"轮结束：" + Arrays.toString(arr));
}

//第一轮比较
/*for (int i = 0;i<arr.length-1;i++){
            //声明一个变量用作辅助
            int temp;
            if(arr[i]>arr[i+1]){
                //换位置
                temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        System.out.println("第一轮结束：" + Arrays.toString(arr));
        //第二轮
        for (int i = 0;i<arr.length-2;i++){
            //声明一个变量用作辅助
            int temp;
            if(arr[i]>arr[i+1]){
                //换位置
                temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        System.out.println("第二轮结束：" + Arrays.toString(arr));
        //第三轮
        for (int i = 0;i<arr.length-3;i++){
            //声明一个变量用作辅助
            int temp;
            if(arr[i]>arr[i+1]){
                //换位置
                temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        System.out.println("第三轮结束：" + Arrays.toString(arr));*/
2. 插入排序

从第二个元素开始，每次都与前一个元素两两相比，若符合条件就交换位置

int[] arr = {6,3,4,2,1,9,10,8};
System.out.println("排序前：" + Arrays.toString(arr));

for(int j=1;j<arr.length;j++){
    for(int i=j;i>0;i--){
        int temp;
        if(arr[i]<arr[i-1]){
            temp = arr[i];
            arr[i] = arr[i-1];
            arr[i-1] = temp;
        }
    }
    System.out.println("第"+j+"轮结束:" + Arrays.toString(arr));
}

//第一轮
/*for(int i=1;i>0;i--){
            int temp;
            if(arr[i]<arr[i-1]){
                temp = arr[i];
                arr[i] = arr[i-1];
                arr[i-1] = temp;
            }
        }
        System.out.println("第一轮结束:" + Arrays.toString(arr));
        //第二轮
        for(int i=2;i>0;i--){
            int temp;
            if(arr[i]<arr[i-1]){
                temp = arr[i];
                arr[i] = arr[i-1];
                arr[i-1] = temp;
            }
        }
        System.out.println("第二轮结束:" + Arrays.toString(arr));*/
3. 选择排序

从第一个元素开始和后面的每一个元素做比较，符合条件就交换位置，一直比到最后一个，第二次就是从第二个元素开始和后面的每一个元素作比较，依次类推

int[] arr = {6,3,4,2,1,9,10,8};
System.out.println("排序前：" + Arrays.toString(arr));

for(int j=0;j<arr.length-1;j++){
    for (int i=j;i<arr.length-1;i++){
        int temp;
        if(arr[j] > arr[i+1]){
            temp = arr[j];
            arr[j] = arr[i+1];
            arr[i+1] = temp;
        }
    }
    System.out.println("第"+j+"轮结束：" + Arrays.toString(arr));
}

/*for (int i=0;i<arr.length-1;i++){
            int temp;
            if(arr[0] > arr[i+1]){
                temp = arr[0];
                arr[0] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        System.out.println("第一轮结束：" + Arrays.toString(arr));

        for (int i=1;i<arr.length-1;i++){
            int temp;
            if(arr[1] > arr[i+1]){
                temp = arr[1];
                arr[1] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        System.out.println("第二轮结束：" + Arrays.toString(arr));

        for (int i=2;i<arr.length-1;i++){
            int temp;
            if(arr[2] > arr[i+1]){
                temp = arr[2];
                arr[2] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        System.out.println("第三轮结束：" + Arrays.toString(arr));
*/
4. 归并排序

算法思路： 该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

1、把长度为n的输入序列分成两个长度为n/2的子序列；

2、对这两个子序列分别采用归并排序；

3、将两个排序好的子序列合并成一个最终的排序序列。

5. 快速排序

算法思路： 通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。 快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。

  1. 从数列中挑出一个元素，称为 “基准”（pivot）；
  2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
  3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

6. 堆排序

算法思路：

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

7. 希尔排序

算法思路：

  1. 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
  2. 按增量序列个数k，对序列进行k 趟排序；
  3. 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度


 


http://www.kler.cn/news/365715.html

相关文章：

  • 语音语言模型最新综述！ 关于GPT-4o背后技术的尝试
  • 找不到包的老版本？？？scikit-learn，numpy，scipy等等！！
  • BIO，NIO，直接内存，零拷贝
  • C++面向对象编程学习
  • 使用 pydub 的 AudioSegment 获取音频时长 - python 实现
  • OpenCV与AI深度学习 | 实战 | OpenCV中更稳更快的找圆方法--EdgeDrawing使用演示（详细步骤 + 代码）
  • docker 可用镜像服务地址（2024.10.25亲测可用）
  • 【ChatGPT插件漏洞三连发之二】零点击Github仓库接管
  • Visual 使用技巧合辑
  • 栅格的着色器实现【最完善】
  • 使用AutoDL训练YOLO等计算机视觉网络模型（AutoDL+Xftp+VS Code），附详细操作步骤
  • 打开Windows来体验AIGC或者ChatGPT
  • Python使用asyncio实现异步操作
  • 深度学习系列——RNN/LSTM/GRU，seq2seq/attention机制
  • AI学习指南自然语言处理篇-Transformer模型的编码器-解码器结构
  • OpenCV通道拆分：深入理解图像处理
  • Swift 是一种由苹果公司开发的强大而直观的编程语言，主要用于开发 iOS、macOS、watchOS 和 tvOS 等苹果平台的应用程序。
  • Spring Boot：植物健康监测的智能解决方案
  • Spring Boot框架下的Java多线程
  • 【继承】讲解
  • Halcon图像颜色通道拆分合并与四则运算
  • Matlab中实现智能优化算法的平均排序图
  • Redis对象共享池，性能优化小细节
  • 设计模式（七）桥接模式详解
  • Linux之实战命令53：mtr应用实例(八十七)
  • 将获取的数据存储到Excel文件中