5-数组、排序、查找

已于 2023-06-16 22:27:45 修改
阅读量51 收藏
点赞数
分类专栏： Java学习笔记 文章标签： 数据结构 java 算法
于 2023-05-25 23:18:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46425350/article/details/130877367
版权

第五章 数组、排序、查找

5.1 数组的介绍

数组是可以存放多个同一类型的数据，数组也是一种数据类型，是引用类型。

5.2 数组入门

使用方式1-动态初始化：

​ 数组的定义：

​ 数据类型 数据名[] = new 数据类型[大小]

​ eg：int a[] = new int[5];

数组的的引用：

​ 数组名[下标/索引]

​ 数组的下标从0开始

​ eg：stu[0]就是stu数组中的第一个元素

使用方式2-动态初始化：

​ 先声明数组：

​ 语法：数据类型 数组名[] 或者 数据类型[] 数组名

​ eg：int a[];或者int[] a;

​ 再创建数组

​ 语法：数组名 = new 数据类型[大小];

​ eg: a = new int[10];

使用方法3-静态初始化

​ 初始化数组

​ 语法： 数据类型 数组名[] = {元素值1,元素值2,…};

​ eg: int a[] = {2,3,4,5,6,8};

​ 上面那种等价于 int a[] = new int[6];

​ a[0] = 2; a[1] = 3;…

数组的使用注意细节：

  1. ​ 数组是多个相同类型数据的组合，实现对这些数据的统一管理
  2. 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用。
  3. 数组创建后，如果没有赋值，有默认值 int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null
  4. 使用数组的步骤 1. 声明数组并开辟空间 2 给数组各个元素赋值 3 使用数组 5)
  5. 数组的下标是从 0 开始的。
  6. 数组下标必须在指定范围内使用，否则报：下标越界异常，比如 韩顺平循序渐进学Java 零基础第148页int [] arr=new int[5]; 则有效下标为 0-4
5.3数组赋值机制
public class ArrayAssign {
    public static void main(String[] args){
        //基本数据类型赋值是值拷贝
        //n2的变化，不会影响n1的值
        int n1 = 10;
        int n2 = n1;
        n2 = 80;
        System.out.println(n1);
        System.out.println(n2);

        //数组再默认情况下是引用传递，赋的值是地址，赋值方式是引用赋值
        //是一个地址，arr2的变化会影响arr1
        System.out.println("===============");
        int arr1[] = {1,2,3,4};
        int arr2[] = arr1;
        arr2[0] = 20;
        for(int i = 0; i < arr1.length;i++){
            System.out.println(arr1[i]);
        }
    }
}
5.3.1 值传递和引用传递的区别

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qDOkCDjr-1685027786924)(images/image-20230525160133658.png)]

5.4 数组的拷贝
package com.chapter05;

/**
 * ClassName: ArraryCopy
 * Package: com.chapter05
 * Description:
 *
 * @Author 花听一笑
 * @Create 2023/5/25 16:24
 * @Version 1.0
 */
public class ArraryCopy {
    public static void main(String[] args){
        //将int[] arr1 = {10,20,30};拷贝到arr2数组
        //要求数据空间是独立的
        int arr1[] = {10,20,30};
        //创建一个新的数组arr2，开辟新的空间
        //大小和arr1.length一样
        int arr2[] = new int[arr1.length];
        //遍历arr1 把每个arr1的元素拷贝到arr2
        for(int i = 0 ; i < arr1.length; i++){
            arr2[i] = arr1[i];
        }
        //修改arr2
        arr2[0] = 100;
        //输出arr1
        System.out.println("arr1==========");
        for(int i = 0 ; i < arr1.length; i++){
            System.out.println(arr1[i]);
        }
        //输出arr2
        System.out.println("arr2==========");
        for(int i = 0 ; i < arr2.length; i++){
            System.out.println(arr2[i]);
        }
    }
}
// 数组的拷贝：
// 		1.建立新的数组开辟新的空间，大小与原数组一样，将原数组循环遍历，将每个元素赋值给新的数组
5.5 数组的翻转
package com.chapter05;

/**
 * ClassName: ArrayReverse
 * Package: com.chapter05
 * Description:
 *
 * @Author 花听一笑
 * @Create 2023/5/25 16:32
 * @Version 1.0
 */
public class ArrayReverse {
    public static void main(String[] args){
        //数组反转
        //1.
        int[] arr = {11,22,33,44,55,66};
        //1.把arr[0] 和 arr[5]进行交换
        //2.把arr[1] 和 arr[4]进行交换
        //3.把arr[2] 和 arr[3]进行交换
        //4.一共交换了3次 = arr.length / 2;
        //每次交换时，对应的下标是 arr[i] 和 arr[arr.length - 1 - i;
        int temp = 0 ;
        int len = arr.length;
        for(int i = 0 ; i < len / 2; i++){
            temp = arr[len - 1 - i];
            arr[len - 1 - i] = arr[i];
            arr[i] = temp;
        }
        System.out.println("反转后数组值为");
        for( int i = 0 ; i < arr.length; i++){
            System.out.print(arr[i] + " ");
        }
    }
}

//方法2：逆序遍历，翻转数组
package com.chapter05;

/**
 * ClassName: ArrayCopy2
 * Package: com.chapter05
 * Description:
 *
 * @Author 花听一笑
 * @Create 2023/5/26 15:18
 * @Version 1.0
 */
public class ArrayCopy2 {
    public static void main(String[] args){
        int arr[] = {11,22,33,44,55,66};
        //数组翻转 逆序赋值方式
        //1.先创建一个新的数组，arr2 大小和arr一样
        //2.逆序遍历，arr，i = arr.length  i >= 0  i--将每个元素拷贝到arr2元素中
        //3.增加一个变量 j -> 0 -> 5
        int arr2[] = new int[arr.length];
        //逆序遍历arr
        for(int i = arr.length - 1,j = 0; i >= 0;j++, i--){
            arr2[j] = arr[i];
        }
        //当for循环结束后 那么arr2就是一个逆序的数组，
        //让arr指向arr2，此时arr原来的数据就没有变量引用了，就会被当作垃圾回收销毁
        arr = arr2;
        System.out.println("翻转后的数组");
        for(int i = 0 ; i < arr.length; i++){
            System.out.print(arr[i] + "\t");
        }
    }

}
5.6 数组的扩容
package com.chapter05;
import java.util.Scanner;
/**
 * ClassName: ArraryAdd
 * Package: com.chapter05
 * Description:
 *
 * @Author 花听一笑
 * @Create 2023/5/28 15:17
 * @Version 1.0
 */
public class ArraryAdd {
    public static void main(String[] args){
        //要求：实现动态的给数组添加元素效果，实现对数组扩容。ArrayAdd.java
        //1) 原始数组使用静态分配 int[] arr = {1,2,3}
        //2) 增加的元素 4，直接放在数组的最后 arr = {1,2,3,4}
        //3) 用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？y/n
        //分析：
        //首先外层套循环 至少循环一次用do while
        //1.定义初始数组，int arr1[] = {1,2,3};
        //2.定义一个新的数组， int arrNew[] = new int[arr1.leng +1];
        //3.遍历原arr数组，将arr的元素依次拷贝给arrNew；
        //使用scanner 让用户输入添加的元素 假设输入4
        //4.将4 赋值给 arrNew[arrNew.length - 1] = 4; 把4 赋值给arrNew最后一个元素
        //5.让arr指向arrNew  arr = arrNew;
        //6.然后创建char 类型变量 ，用if判断用户是否需要继续添加
        //char  key = scan.nenxt().charAt(0);
        //if(key == 'n'){break;}
        int arr1[] = {1,2,3};
        do{
        int arr2[] = new int[arr1.length + 1];
        for(int i = 0 ; i < arr1.length;i++){
            arr2[i] = arr1[i];
        }
        System.out.println("请输入添加元素的值：");
        Scanner scan = new Scanner(System.in);
        int addNum = scan.nextInt();
        arr2[arr2.length -1] = addNum;
        arr1 = arr2;
        for(int i = 0 ; i< arr1.length;i++){
            System.out.print(arr1[i] + "\t");
        }
        System.out.println("\n"+"是否要继续添加");
        char key = scan.next().charAt(0);
        if( key == 'n'){
            break;
        }
        }while(true);
        System.out.println("你已经退出添加...");
    }
}
5.7 数组的缩减
package com.chapter05;
import  java.util.Scanner;
/**
 * ClassName: ArrayReduce
 * Package: com.chapter05
 * Description:
 *
 * @Author 花听一笑
 * @Create 2023/5/28 17:15
 * @Version 1.0
 */
public class ArrayReduce {
    public static void main(String[] args){
        //有一个数组 {1， 2， 3， 4， 5}， 可以将该数组进行缩减，
        // 提示用户是否继续缩减，每次缩减最后那个元素。
        // 当只剩下最后一个元素，提示，不能再缩减。

        //分析：
        //
        //1.创建初始数组，int arr[] = {1,2,3,4,5};
        //2.再创建一个新的数组 int arrNew[] = new int[arr.length -1 ];
        //3.遍历循环初始arr数组，将原数组元素依次拷贝给arrNew
        //4.然后将原数组arr指向arrNew

        //创建初始数组
        int arr[] = {1,2,3,4,5};
        //再创建一个新的数组
        do{
            int arrNew[] = new int[arr.length - 1];
            //遍历循环初始arr数组将原数组元素依次拷贝给arrNew
            for(int i = 0 ; i< arrNew.length; i++){
                arrNew[i]  = arr[i];
            }
            arr = arrNew;
            for(int i = 0 ; i < arr.length; i++){
                System.out.print(arr[i]);
            }
            System.out.println( "\n"+"是否要缩减数组:");
            //创建scanner 监听用户是否需要继续缩减数组
            Scanner scan = new Scanner(System.in);
            char key =scan.next().charAt(0);
            if(arr.length == 1){
                System.out.println("将退出缩减数组，元素仅剩1个");
                continue;
            }else if (key == 'n'){
                System.out.println("将退出缩减数组");
                break;
            }
        }while (true);
        System.out.println("程序继续运行....");
    }
}
5.8 排序

排序是将多个数据，依指定的顺序进行排列的过程。

排序的分类：

5.8.1 内部排序

​ 指将需要处理的所有数据都加载到内部存储器中进行排序。包括(交换式排序法、选择 式排序法和插入式排序法)；

5.8.2 外部排序

​ 数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。包括(合并排序法和直接合并排序法)

5.8.3 冒泡排序

​ 冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从后向前（从下标较大的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。

5.8.4 冒泡思路

在这里插入图片描述

代码：

package com.chapter05;

/**
 * ClassName: BubbleSort
 * Package: com.chapter05
 * Description:
 *
 * @Author 花听一笑
 * @Create 2023/5/29 15:01
 * @Version 1.0
 */
public class BubbleSort {
    public static void main(String[] args) {
        //冒泡排序
        //数组[24,69,80,57,13]
        //第一轮排序：目标把最大数放在最后
        //第一次比较[24,69,80,57,13]
        //第二次比较[24,69,80,57,13]
        //第三次比较[24,69,57,13,80]
        //第四次比较[24,69,57,13,80]

        //先死后活

        int temp = 0;
        int arr[] = {24,69,57,13,80,99,-12};
        for(int i = 0 ; i < arr.length - 1 ; i++){
            //内层循环
            //用于交换的中间变量
            for(int j = 0 ; j < arr.length - 1 - i; j++){
                if(arr[j] > arr[j+1]){
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            System.out.println("\n"+"第" + (i+1) + "轮排序后");
            for(int j = 0 ; j < arr.length;j++){
                System.out.print(arr[j] + "\t");
            }
        }
    }
}
5.9 查找

在java中，我们常用的查找有两种查找

1.顺序查找

package com.chapter05;
import  java.util.Scanner;
/**
 * ClassName: SeqSearch
 * Package: com.chapter05
 * Description:
 *
 * @Author 花听一笑
 * @Create 2023/5/29 16:41
 * @Version 1.0
 */
public class SeqSearch {
    public  static void main(String[] args){
        //有一个数列：白眉鹰王、金毛狮王、紫衫龙王、青翼蝠王猜数游戏：从键盘中任意输入一个名称，
        // 判断数列中是否包含此名称【顺序查找】
        // 要求: 如果找到了，就提示找到，并给出下标值。
        String names[] = {"白眉鹰王","金毛狮王","紫衫龙王","青翼蝠王"};
        int index  = -1;
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入名字");
        String findName = scan.next();
        for(int i = 0 ; i< names.length; i++){
            //比较找到的是否匹配
            if(findName.equals(names[i])){
                System.out.println("找到了" + findName);
                System.out.println("下标为：" + i);
                index = i;
            }
        }
        //没有找到
        if(index == -1){
            System.out.println("没有找到");
        }

    }
}

2.二分查找

5.10 二维数组

多维数组我们只介绍二维数组。

二维数组的应用场景 比如我们开发一个五子棋游戏，棋盘就是需要二维数组来表示

5.11 二维数组使用

在这里插入图片描述

package com.chapter05;

/**
 * ClassName: TwoDimensionalArray
 * Package: com.chapter05
 * Description:
 *
 * @Author 花听一笑
 * @Create 2023/5/29 19:58
 * @Version 1.0
 */
public class TwoDimensionalArray {
    public static void main(String[] args){
        /*
        *  请用二维数组输出如下图型：
        *   0 0 0 0 0 0
        *   0 0 1 0 0 0
        *   0 2 0 3 0 0
        *   0 0 0 0 0 0
        * */

        //什么是二维数组
        //1.从定义形式上看  int[][]
        //2.可以这样理解，原来的一维数组的每个元素是一维数组
        //3.二维数组的元素个数：arr.length
        //4.二维数组每个元素是一维数组，如果想得到每个一维数组的值那么
        //就需要再次遍历
        //5.如果我们要访问（i+1）个一维数组的第j+1个值 那么就需要 arr[i][j]
        int[][] arr = {{0 ,0 ,0 ,0 ,0, 0},{0 ,0, 1, 0 ,0, 0},
                {0 ,2, 0 ,3, 0 ,0},{0 ,0,0,0, 0, 0}};
        //输出二维数组图形
        for(int i = 0 ; i < arr.length; i++){
            //遍历二维数组的每个元素
            //1.arr[i] 表示二维数组的第i个元素 比如arr[0] 二维数组第一个元素
            //2.arr[i].length 得到对应元素的长度
            for(int j = 0 ; j < arr[i].length; j++){
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }

    }
}
5.12 二维数组在内存中的演示

在这里插入图片描述

package com.chapter05;

/**
 * ClassName: TwoDimensionalArray2
 * Package: com.chapter05
 * Description:
 *
 * @Author 花听一笑
 * @Create 2023/5/31 14:44
 * @Version 1.0
 */
public class TwoDimensionalArray2 {
    public static void main(String[] args){
        //int[][] arr = new int[2][3];
        int[][] arr;
        arr = new int[2][3];
        arr[1][1] = 8;
        for(int i = 0 ; i < arr.length;i++){
            for(int j = 0 ; j <arr[i].length; j++){//遍历一维数组内的元素
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}
5.13 二维数组使用方式1和2

动态初始化1

  1. 语法: 数据类型[] [] 数组名 = new 数据类型[] [];
    1. 比如: int[] [] a = new int[2] [3];

动态初始化2

1.语法：先声明 数据类型[] [] 数组名；

​ 在创建开辟空间 数组名 = new 数据类型[大小] [大小]；

5.14 动态初始化使用方式3 列数不确定
package com.chapter05;

/**
 * ClassName: TwoDimensionalArray3
 * Package: com.chapter05
 * Description:
 *
 * @Author 花听一笑
 * @Create 2023/5/31 15:07
 * @Version 1.0
 */
public class TwoDimensionalArray3 {
    public  static void main(String[] args){
        /*
        *动态创建数组如下：
        *   i = 0：1
        *   i = 1：2    2
        *   i = 2：3    3   3
        * */
        //创建初始数组 有3个一维数组，但是一维数组内部还没有开辟空间
        int[][] arr = new int[3][];
        for(int i = 0 ; i < arr.length; i++){
            //给每个一维数组开辟空间 有规律可知 每i 自增1 此时一维数组的元素也多一个
            arr[i] = new int[i + 1];
            for(int j = 0 ; j < arr[i].length; j++){
                arr[i][j] = i + 1;// i 从0 开始 且 arr[0][0] , arr[0][1] 都为 1 所以 i + 1
            }
        }
        //输出
        //循环二维数组一共有多少个一维数组
        for(int i = 0 ; i< arr.length; i++){
            //循环遍历 二维数组中的一维数组内的元素
            for(int j = 0; j < arr[i].length; j++){
                System.out.print(arr[i][j] + " ");
            }
            //每输出完一组一维数组换行
            System.out.println();
        }
    }
}
5.15 二维数组静态初始化

语法：

​ 数组类型[] [] 数组名 = {{值1，值2，值3}，{值1，值2，值3}，{值1，值2，值3}}；

​ eg： int[] [] arr= {{1,2,3},{2,3,4},{4,5,6}};

5.16 杨辉三角
/**
 * ClassName: YangHui
 * Package: PACKAGE_NAME
 * Description:
 *
 * @Author Dawn
 * @Create 2023/6/16 14:03
 * @Version 1.0
 */
public class YangHui {
    public static void main(String[] args){
        /*
        打印10行的杨辉三角
        * 1
        * 1 1
        * 1 2 1
        * 1 3 3 1
        * 1 4 6 4 1
        * 1 5 10 10 5 1
        * */
        //第一行有一个元素 ，第n行有第n个元素
        //每一行的第一个元素和最后一一个元素都是1
        //arr[i][j] = arr[i-1][j] + arr[i-1][j-1] 规律：

        //创建一个10个元素的二维数组 因为每行元素不确定所以先不写
        int Yanghui[][] = new int[10][];
        for(int i = 0 ; i < Yanghui.length; i++){
            //开辟空间
             Yanghui[i] = new int[i + 1];
             for(int j = 0; j < Yanghui[i].length; j++){
                 //判断是否是第一个元素或者是最后一个元素
                 if(j == 0 || j  == Yanghui[i].length - 1){
                     Yanghui[i][j] = 1;
                 }else {
                     Yanghui[i][j] = Yanghui[i-1][j] + Yanghui[i-1][j-1];
                 }
             }
        }
        //输出杨辉
        for(int i = 0;i < Yanghui.length; i++){
            for(int j = 0 ; j < Yanghui[i].length; j++){ //遍历输出该行
                System.out.print(Yanghui[i][j] + "\t");
            }
            System.out.println();
        }
    }
}
5.17 二维数组使用细节

1.一维数组的声明方式有: int[] x 或者 int x[]

2.二维数组的声明方式有: int[] [] y 或者 int[] y[] 或者 int y[] []

3.二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不相同。比如：map[] [] 是一个二维数组 int map[] [] [][] = {{1,2},{3,4,5}} 由 map[0] 是一个含有两个元素的一维数组 ，map[1] 是一个含有三个元素的一维数组构成，我们也称为列数不等的二维数组

5.18 二维数组练习

在这里插入图片描述
在这里插入图片描述

package com.chapter05;

/**
 * ClassName: Homework03
 * Package: com.chapter05
 * Description:
 *
 * @Author Dawn
 * @Create 2023/6/16 14:50
 * @Version 1.0
 */
public class Homework04 {
    public  static void main(String[] args){
        //已知有一个升序数组，要求插入一个元素，该数组依然是升序
        //eg：arr[]  = {10,12,45,90] ,添加元素后 数组为：{10，12，23，45，90}

        //初始化数组
        //笨方法：扩容 + 冒泡
        /*int[] arr = {10,12,45,90};
        int insertNum = 23;
        int[] arrNew = new  int[arr.length + 1];
        for(int i = 0 ;i < arr.length; i++){
            arrNew[i]  = arr[i];
        }
        arrNew[arrNew.length-1] = insertNum;
        arr = arrNew;
        int temp  = 0;
        for(int i = 0 ; i < arr.length;i++){
            for(int j = 0 ; j < arr.length - 1 -i; j++){
                if(arr[j] > arr[j +1]){
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        //遍历输出
        for(int i =0 ;i < arr.length;i++){
            System.out.print(arr[i] + "\t");
        }*/

		//推荐方法
        //分析：
        //1.本质 扩容 + 定位
        //1.先确定 添加的数插入哪一个索引
        //2.然后再扩容

        //定义原数组
        int[] arr = {10,12,45,90};
        int insertNum = 23;
        //索引位置默认-1
        int index = -1;  

        //遍历arr数组 如果发现insertNum <= arr[i],说明就是找到了i的位置
        //使用index保留 index = i
        //如果遍历完没发现 insertNum <= arr[i] 那么index = arr.length;
        for(int i = 0 ; i < arr.length;i++){
            if(insertNum <= arr[i]){
                index = i; //找到位置退出并且保存i
                break;
            }
        }
        //判断index的位置
        if(insertNum == -1){
            index = arr.length;
        }
		//新建数组arrNew
        int[] arrNew = new int[arr.length + 1];
        for(int i = 0 ,j = 0;i < arrNew.length; i++){
            if(i != index){
                arrNew[i]  = arr[j]; // 说明可以将arr的数赋值到arrNew
                j++;
            }else {
                arrNew[i]  = insertNum; // 可以将插入的数添加到arrNew
            }
        }
        arr = arrNew; //将原来的数组指向arrNew
        //输出
        for(int i = 0 ; i < arr.length; i++){
            System.out.print(arr[i] + "\t");
            
        }

    }
}


package com.chapter05;
import java.util.Random;

/**
 * ClassName: Homework05
 * Package: com.chapter05
 * Description:
 *
 * @Author Dawn
 * @Create 2023/6/16 17:04
 * @Version 1.0
 */
public class Homework05 {
    public static void main(String[] args){
        /*
        * 随机产生10个整数（1-100范围）保存到数组 倒序打印(不是排序仅仅只是倒着打印）以及平均值求最大值和其下标
        * 并查找里面是否有8
        * */
        //分析
        //1.创建一个一维数组 并开辟空间10
        //2.循环遍历数组随机产生1-100 并赋值给arr[i]
        //3.打印正常情况下的arr数组和arr倒序情况下的数组元素
        //4.求最大值和其下标  定义sum 为总和  max 为最大数 maxindex 为下标
        //5.循环遍历数组 并且累计求和 再判断max < arr[i]
        
        

        int[] arr = new int[10];
        //循环赋值
        for(int i = 0 ; i < arr.length ; i++){
            arr[i] = (int)(Math.random()*100 + 1);//随机产生10个数并赋值
        }
        System.out.println("=========arr正常情况");
        for(int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + "\t");

        }
        System.out.println("\n"+"===========arr倒序打印情况");
        //倒序输出
        for(int i = arr.length-1 ; i >= 0; i--){
            System.out.print(arr[i] + "\t");

        }
        //求平均值和最大值及下标
        double sum = arr[0];
        int max = arr[0];
        int maxIndex = 0;
        for( int i = 1; i < arr.length; i++){
            sum += arr[i];
            if(max < arr[i]){
                max = arr[i];
                maxIndex = i;
            }
        }
        System.out.println("\nmax= " + max + "maxIndex =" + maxIndex);
        System.out.println("average=" + (sum / arr.length ));


        //并查找里面是否有8 //顺序查找
        int findNum = 8;
        int index = -1;
        for(int i =0; i < arr.length; i++){
            if(findNum == arr[i]){
                System.out.println("找到了" + arr[i] + "下标为：" + i );
                index = i;
                break;
            }
        }
        if(index == -1){
            System.out.println("没有找到" + findNum);
        }
    }
}

在这里插入图片描述

MoonA1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C语言---数组排序
mqs580的博客
03-19 1万+
1、冒泡排序（从后往前） 1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。 2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应 该会是最大的数。 3.针对所有的元素重复以上的步骤，除了最后一个。 4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 代码： 2、直接选择排序 每一次从待排序的数据元素中选出最小(或最大)的...
数组、排序、查找
sunflower34
05-06 81
数组数组数组的三种使用方式排序查找二维数组 为什么需要数组： 方便处理大批数据 数组 数组可以存放多个同一类型的数据，数组也是一种数据类型，是引用类型。 数组的三种使用方式 动态初始化1 1、数组定义： 数据类型[] 数组名 =new 数据类型[大小] 2、数组引用: 数组名【下标\索引】 动态初始化2 1、先声明数组 语法： 数据类型 数组名【】 数据类型【】 数组名 数组名 =new 数据类型【大小】 2、创建数组 静态初始化 1、初始化 语法： 数据类型【】 数组名 ={元素1，元素2} 数组注意事
Java实例-数组排序和查找元素位置
m0_54158068的博客
04-26 1127
Java实例-数组排序和查找元素位置
【东方博宜】【入门】1858--数组查找及替换
LAN_CIKR的博客
12-20 1228
题目描述 给定某整数数组和某一整数b。要求删除数组中可以被b整除的所有元素，同时将该数组各元素按从小到大排序。如果数组元素数值在A到Z的ASCII之间，替换为对应字母。元素个数不超过100，b在1至100之间。 输入 第一行为数组元素个数和整数b 第二行为数组各个元素 输出 按照要求输出 样例 输入 7 2 77 11 66 22 44 33 55 输出 11 33 55 M 码来! #include<bits/stdc++.h> using namespace.
6、数组、排序和查找
yys0628的博客
03-31 810
一、数组（array） 介绍：数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型 即：数（数据）组（一组）就是一组数据 1、数组的创建 如： //1、 double[] 表示是double类型的数组，数组名是num01 // 2、{3, 4, 6, 8.7, 3.4} 表示数组的值/元素， 依次表示数组的第几个元素（从0开始） // 3、可用 for 循环遍历 // 4、[] 中括号可以写在数组名后 如：double num[] = {3, 4, 6, 8.7, 3.4};
java代码-数组排序封装类
07-15
"java代码-数组排序封装类"可能是指一个自定义的Java类，该类提供了对数组进行排序的功能，封装了常见的排序算法，如冒泡排序、插入排序、选择排序、快速排序、归并排序等。这个封装可以提高代码的可读性和可重用性...
Java 实例 - 数组排序及元素查找源代码-详细教程.zip
08-07
一、数组排序 在Java中，有多种方法对数组进行排序： 1. **冒泡排序（Bubble Sort）**：这是一种简单的排序算法，通过不断交换相邻的不正确顺序的元素来完成排序。虽然效率较低，但易于理解。 2. **选择排序...
算法-数组排序 按数组内数字大小排序 取得最大值或最小值.rar
09-16
总结来说，"数组排序 按数组内数字大小排序 取得最大值或最小值.pdf"这个文件很可能详细介绍了上述各种排序算法的原理、实现步骤、性能分析以及最大值和最小值的查找方法。通过学习这些内容，我们可以更好地理解和...
DS09-排序ppt DS08-查找ppt司 DS07-图ppt DS06-树ppt DS05-数组和广义表ppt DS04-串
03-20
DS09-排序ppt DS08-查找ppt DS07-图ppt DS06-树ppt DS05-数组和广义表ppt DS04-串.ppt DS03-栈和队列.ppt DS02-线性表,ppt DS01-概论ppt
C语言考试系统题库-5-数组.doc
07-05
C语言考试系统题库-数组 本文档总结了C语言考试系统题库中关于数组的九个知识点，...本文档涵盖了C语言考试系统题库中关于数组和字符串的多种知识点，包括数组的使用、字符串的操作、排序算法、查找算法、替换算法等。
数据结构（初阶3.单链表）
2401_83968713的博客
07-14 658
一、单链表1.1概念与结构1.2结点1.3链表的性质1.4链表的打印二、实现单链表SList.hSList.c申请新节点尾插头插尾删头删在指定位置之前插入数据在指定位置之后插入数据删除指定位置结点删除指定位置之后的结点销毁结点test.c。
算法复杂度＜数据结构 C版＞
hukang的博客
07-13 1742
简单来说算法复杂度是用来衡量一个算法的优劣的，一个程序在运行时，对运行时间和运行空间有要求，即时间复杂度和空间复杂度。
【面试题】数据结构：堆排序的排序思想？
Colorful___的博客
07-18 446
堆排序是一种高效的排序算法，其基本思想是利用堆这种数据结构来实现排序。堆是一种特殊的完全二叉树，通常用数组来表示。
数据结构第35节 性能优化 算法的选择
最新发布
hummhumm的专栏
07-18 391
算法的选择对于优化程序性能至关重要。不同的算法在时间复杂度、空间复杂度以及适用场景上有着明显的差异。下面我将结合具体的代码示例，来讲解几种常见的算法选择及其优化方法。
【数据结构】栈和队列
奋斗的小羊的博客
07-12 1852
栈超超超详解
【数据结构】二叉树-1
m0_46676283的博客
07-15 864
现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是 ，则它就是满二叉树。双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；
【数据结构】线性结构——数组、链表、栈和队列
Filotimo_的博客
07-15 1193
线性结构是指数据元素之间存在一对一的关系，包括数组、链表、栈和队列等。这里介绍了这四种数据结构的优缺点和适用场景。
【数据结构】手写快速排序
qq_59143106的博客
07-14 306
什么是快速排序？首先确立pivot，比如下图位于末尾然后i遍历3到6在3的时候，j指向i前面一位如果3
【Java--数据结构】栈的应用
2301_80898480的博客
07-14 756
如有错误，欢迎指出~
新旧更替--数组插入pta
06-18
数组插入操作通常涉及到在已有数组中添加一个新元素，这在数据结构和编程中是非常常见的操作。"新旧更替"可能指的是在插入新元素后，原有的数据可能会被覆盖或者需要调整，以保持数组的连续性和正确性。 **新插入操作过程**: 1. **查找插入位置**: 需确定新元素应该插入到数组的哪个索引。这可能是数组的开始、中间或结尾，具体取决于数组的排序规则（如插入排序）或插入策略。 2. **移动元素**: 如果插入位置后面还有其他元素，需要将这些元素向后移动一位，以便为新元素腾出空间。 3. **插入新元素**: 将新元素放置在找到的位置。 **旧元素处理**: - 如果数组是固定大小的，插入后可能需要删除数组尾部的元素以保持容量不变，或者采用动态扩容的方式来适应新元素。 - 对于动态数组，插入操作通常是直接进行，数组会自动扩展其容量以容纳新元素。 **相关问题--:** 1. 插入操作对数组的性能有何影响？ 2. 如何高效地处理数组插入后的内存管理？ 3. 插入操作在不同数据结构（如链表、堆）中的实现有何差异？

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值