数据结构 数组中常见的算法（笔记十）

最新推荐文章于 2022-09-08 15:02:50 发布
最新推荐文章于 2022-09-08 15:02:50 发布
阅读量414 收藏
点赞数
分类专栏： java 文章标签： 算法 快速排序 java 数组异常
diaolove
本文链接：https://blog.csdn.net/qq_45047809/article/details/114939093
版权

目录

一、数据结构

1.数据与数据之间的逻辑关系:维合、一对一、一对多、多对多
2.数据的存储结构:
线性表：顺序表（比如:数组)、链表、栈、队列
树形结构：二叉树
图形结构：

二、数组中涉及的常见算法

1.数组元素的赋值(杨辉三角、回形数等)
2.求数值型数组中元素的最大值、最小值、平均数、总和等
3.数组的复制、反转、查找(线性查找、二分法查找)
4.数组元素的排序算法

（1）杨辉三角

在这里插入图片描述

（2） 求数值型数组中元素的最大值、最小值、平均数、总和等
**
 * @Description:算法的考查:求数值型数组中元素的最大值、最小值、平均数、总和等
 * 定义一个int型的一维数组，包含1日个元素，分别赋一些随机整数，
 * 然后求出所有元素的最大值,最小值，和值，平均值，并输出出来。
 * 要求:所有随机数都是两位数。 $
 * @Author: dyq
 * @Date: $
 */
public class Test05 {
    public static void main(String[] args) {
        int[] arr = new int[10];

        for (int i =0;i<arr.length;i++){
            arr[i]= (int)(Math.random()*(99-10+1)+10);
        }
        //遍历
        for (int i =0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
        //求数组元素的最大值
        int max =arr[0];
        for (int i=0;i< arr.length;i++){
            if(max<arr[i]){
                max=arr[i];
            }
        }
        System.out.println("最大值为："+max);

        //求最小值
        int min =arr[0];
        for (int i=0;i< arr.length;i++){
            if(min>arr[i]){
                min=arr[i];
            }
        }
        System.out.println("最小值为："+min);

        //求和
        int sum =0;
        for (int i =0;i<arr.length;i++){
            sum+=arr[i];
        }
        System.out.println("总和为："+sum);

        //数组元素的平均数
        double avg = sum/arr.length;
        System.out.println("平均值为："+avg);

    }
}

（3）.数组的复制、反转、查找(线性查找、二分法查找)

a、数组的复制

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
数组的赋值：

public class Test06 {
    public static void main(String[] args) {
      int[] arry1,arry2;

      arry1 = new int[]{2,3,5,7,11,13,17,19};

      //显示arry1的内容
        System.out.print("第一次输出arry1：");
        for (int i=0;i<arry1.length;i++){
            System.out.print(arry1[i]+"\t");
        }
        //赋值arry2变量arry1  不能称作数组的复制
        arry2=arry1; //array1和array2地址值相同，都指向了堆空间的唯一的一个数组实体。

        //修改arry2中的偶数索引元素，使其等于索引值(如array[0]=0,array[2]=2)。打印出array1。
        for (int i=0;i<arry2.length;i++){
            if(i % 2==0){
                arry2[i]=i;
            }
        }
            System.out.print("第二次输出arry1：");
        for (int i=0;i<arry1.length;i++){
            System.out.print(arry1[i]+"\t");
        }

    }
}

输出结果：

第一次输出arry1：2	3	5	7	11	13	17	19	
第二次输出arry1：0	3	2	7	4	13	6	19

数组的复制：

public class Test07 {
    public static void main(String[] args) {
      int[] arry1,arry2;

      arry1 = new int[]{2,3,5,7,11,13,17,19};

      //显示arry1的内容
        System.out.print("第一次输出arry1：");
        for (int i=0;i<arry1.length;i++){
            System.out.print(arry1[i]+"\t");
        }

       //数组的复制
       arry2 = new int[arry1.length];
        for (int i =0;i<arry2.length;i++){
            arry2[i]=arry1[i];
        }

        //修改arry2中的偶数索引元素，使其等于索引值(如array[0]=0,array[2]=2)。打印出array1。
        for (int i=0;i<arry2.length;i++){
            if(i % 2==0){
                arry2[i]=i;
            }
        }
            System.out.print("第二次输出arry1：");
        for (int i=0;i<arry1.length;i++){
            System.out.print(arry1[i]+"\t");
        }
    }
}

第一次输出arry1：2	3	5	7	11	13	17	19	
第二次输出arry1：2	3	5	7	11	13	17	19
数组的反转，查找
public class Test08 {
    public static void main(String[] args) {
        String[] arr = new String[]{"哥哥", "姐姐", "弟弟", "妹妹", "爸爸", "妈妈"};

        //数组的复制
        String[] arr1 = new String[arr.length];
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] = arr[i];
        }

        //数组的反转
        //方式一
//        for (int i =0 ;i<arr.length/2;i++){
//            String temp = arr[i];
//            arr[i] = arr[arr.length-i-1];
//            arr[arr.length-i-1]= temp;
//        }
        //方法二
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            String temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        //遍历
        System.out.println("反转数组：");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i] + "\t");
        }

        //查找（或收索）
        //线性查找
        String dest = "姐姐";
        boolean isFlag = true;
        System.out.println("查找元素：");
        for (int i = 0; i < arr.length; i++) {
            if (dest.equals(arr[i])) {
                System.out.println("找到指定元素" + dest + "，位置为：" + i);
                isFlag = false;
                break;
            }
        }
        if (isFlag) {
            System.out.println("很遗憾没有找到！");
        }

        //二分法查找  前提：所要查找的数组必须有序。
        int[] arr2 = new int[]{  -99,-89,-1,12, 23, 44,45,66,67,98,100};

        int dest1 =-99;

        int head = 0;//初始的首索引
        int end = arr2.length - 1;//初始的末索引
        boolean isFlag1 = true;

        while (head <= end) {

            int middle = (head + end) / 2;

            if (dest1 == arr2[middle]) {
                System.out.println("找到了指定的元素，位置为：" + middle);
                isFlag1 = false;
                break;
            } else if (arr2[middle] > dest1) {
                end = middle- 1;
            } else {//arr2[middle]<dest1
                head = middle + 1;
            }
        }
        if (isFlag1) {
            System.out.println("很遗憾没有找到！");
        }
    }
}

结果：

反转数组：
妈妈	
爸爸	
妹妹	
弟弟	
姐姐	
哥哥	
查找元素：
找到指定元素姐姐，位置为：4
找到了指定的元素，位置为：0

（4）、数组元素的排序算法

在这里插入图片描述
在这里插入图片描述
算法的五大特征：
在这里插入图片描述
说明：满足确定性的算法也称为:确定性算法。现在人们也关注更广泛的概念，例如考虑各种非确定性的算法，如并行算法、概率算法等。另外，人们也关注并不要求终止的计算描述，这种描述有时被称为过程（ procedure ) 。

冒泡排序

在这里插入图片描述

public class BubbleSortTest {
    public static void main(String[] args) {
        int[] arry = new int[]{43,32,21,4,56,77,89,900};

        //冒泡排序
        for (int i =0;i<arry.length-1;i++){
            for (int j =0;j<arry.length-1-i ; j++){
                if (arry[j]>arry[j+1]){
                    int temp = arry[j];
                    arry[j] = arry[j+1];
                    arry[j+1] = temp;
                }
            }
        }

        for (int i =0;i<arry.length;i++){
            System.out.println("冒泡排序："+arry[i]+"\t");
        }

    }
}

结果：

4	
21	
32	
43	
56	
77	
89	
900
快速排序

在这里插入图片描述

public class QuickSort {
    private static void swap(int[] data, int i, int j) {
        int temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }

    private static void subSort(int[] data, int start, int end) {
        if (start < end) {
            int base = data[start];
            int low = start;
            int high = end + 1;
            while (true) {
                while (low < end && data[++low] - base <= 0) ;
                while (high > start && data[--high] - base >= 0) ;
                if (low < high) {
                    swap(data, low, high);
                } else {
                    break;
                }
            }
            swap(data, start, high);

            subSort(data, start, high - 1);//递归调用
            subSort(data, high + 1, end);
        }
    }
    public static void quickSort(int[] data){
        subSort(data,0,data.length-1);
    }


    public static void main(String[] args) {
        int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };
        System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
        quickSort(data);
        System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
    }
}

结果：

排序之前：
[9, -16, 30, 23, -30, -49, 25, 21, 30]
排序之后：
[-49, -30, -16, 9, 21, 23, 25, 30, 30]
各种内部排序方法性能比较

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

三、Arrays工具类的使用

在这里插入图片描述
代码实例：

import java.util.Arrays;

/**
 * @Description: $
 * @Author: dyq
 * @Date: $
 */
public class ArraysTest {
    public static void main(String[] args) {
        int[] arr1 = new int[]{1,2,3,4};
        int[] arr2 = new int[]{1,3,2,4};
        //1 boolean equals(int[] a,int[] b) 判断两个数组是否相等。
        boolean equals = arr1.equals(arr2);
        System.out.println(equals);

        //2 String toString(int[] a) 输出数组信息。
        System.out.println(Arrays.toString(arr1));

        //3 void fill(int[] a,int val) 将指定值填充到数组之中。
         Arrays.fill(arr1,10);
        System.out.println(Arrays.toString(arr1));

        //4 void sort(int[] a) 对数组进行排序。
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2));

        //5 int binarySearch(int[] a,int key) 对排序后的数组进行二分法检索指定的值。

       int[] arry1 = new int[]{2,3,5,8,11,13,17,19};
      int a =  Arrays.binarySearch(arry1,19);
        System.out.println(a);
    }
}

结果：

false
[1, 2, 3, 4]
[10, 10, 10, 10]
[1, 2, 3, 4]
7

四、数组使用中的常见异常

public class ArrayException {
    public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4};

//        for (int i=0;i <=arr.length;i++){
//            System.out.print(arr[i]+"\t");  //报异常ArrayIndexOutOfBoundsException数组角标越界异常
//        }
        //   System.out.println(arr[-1]);//报异常ArrayIndexOutOfBoundsException数组角标越界异常

        //空指针异常java.lang.NullPointerException
        //情况一：
//        int[] arr1 = new int[]{1,2,3,4,5};
//        arr1= null;
//        System.out.println(arr1[0]);

        //情况二：
//        int[][] arr2 =new int[4][];
//        System.out.println(arr2[0]); //null

        //情况三：
        String[] arr3 = new String[]{"AA","BB","CC"};
        arr3[0]=null;
        System.out.println(arr3[0].toString());
    }
}

在这里插入图片描述

北街风
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Python 中文数据结构和算法教程.zip
12-30
算法代码：我们提供了多种数据结构的实现代码，包括数组、链表、栈、队列、树、图等。这些代码不仅能帮助你理解数据结构的基本概念，而且能让你明白如何在实际情况中应用这些数据结构。 笔记：详细且系统的笔记，...
C语言中数组的本质
Mature_Guo的博客
04-25 247
C语言中数组的应用
C和指针_第8章_数组_学习笔记
accumulating_mocai的博客
05-02 139
1.22[arry]  = *(arry + 2) = arry[2]1.3下标绝不会比指针更有效率，但指针有时会比下标有效。结论：    1.当根据某个决定数目的增量在一个数组中移动的时候，使用指针比使用下标产生效率更高的代码。当这个增量是1并且机器具有地址自动增量模型时，这点表现更突出。    2.声明为寄存器变量的指针通常比位于静态内存和堆栈中的指针效率更高。    3.如果可以通过测试一些...
数组指针、指针数组以及二位数组
weixin_34378045的博客
04-13 92
int *p[3]与int (*p)[3]的区别 *p[3]这个是一个指针数组，它所代表的意思是数组中的每一个元素都是一个指针变量，而(*p)[3]，p是一个指针变量，表示指向一个含有3个整型元素的一维数组。 View Code int i,j; int a[2][3]={3,4,5,6,7,8}; // int *p[3] ; //表示一个数组，数组中的...
数组（c语言）
Robert_kang的博客
10-14 115
数组 数组是用线性储存的方式 来储存相同类型的值 一个数组只有一个名字 并且可以用一个整数索引来访问 int arry【20】； arry[0] =12; 声明 arry 数组 含有20个元素 赋值 可以直接进行赋值 即arry【0】= 12； 访问 第一个元素是 arry【0】 数组中的索引访问 从0开始 第二个元素是 arry【1】 第n个元素是 arry【n - 1】 索引不能超过数组元素个数 所有数组由连续的内存位置组成 最低地址对应...
数据结构（C）必会知识点+易错点：数组和广义表（n维数组地址计算公式，特殊矩阵对称矩阵的存储，广义表的表示方法）
i6223671的博客
02-01 4506
一，n维数组地址计算公式 ji表示n维数组中该元素在第i维中的坐标 ai表示n维数组中第i维的起始坐标 bi表示第i维度的长度 L表示一个元素所占的字节数 LOC（…）表示该坐标对应的存储中的地址（一维坐标） PS.对与简单的二维数组则①求出该数组前面有多少个元素（分清行主序还是列主序）， ②第一个元素对应的地址加上前面所有元素的总字节数 二，对称矩阵 三，上（下）三角矩阵 四， 对角矩阵 ...
数据结构与算法的学习笔记.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
Java数据结构和算法详细笔记
07-09
在计算机科学中，数据结构和算法是核心概念，它们对于编写高效、优化的代码至关重要。Java作为面向对象的编程语言，支持多种数据结构和算法的实现。 线性结构是数据结构的一种，它的特点是数据元素之间存在一对一的...
数据结构与算法学习笔记.zip
最新发布
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
小码哥《恋上数据结构与算法》学习笔记.zip
12-30
算法代码：我们提供了多种数据结构的实现代码，包括数组、链表、栈、队列、树、图等。这些代码不仅能帮助你理解数据结构的基本概念，而且能让你明白如何在实际情况中应用这些数据结构。 笔记：详细且系统的笔记，...
C数据结构矩阵的运算
12-29
printf("请输入系数矩阵的行数和列数(用逗号隔开)"); scanf("%d,%d",&i,&j); printf("请输入增广矩阵的行数和列数(用逗号隔开)"); scanf("%d,%d",&m,&n); printf("请输入系数矩阵:\n"); for(p=0;p<i;p++) for(q=0;q<j;q++) scanf("%f",&A[p][q]); printf("输出系数矩阵A:\n"); for(p=0;p<i;p++) for(q=0;q<j;q++) { printf("%10.2f",A[p][q]); if((q+1)%j==0) printf("\n"); } printf("请输入增广矩阵:\n"); for(p=0;p<m;p++) for(q=0;q<n;q++) scanf("%f",&B[p][q]); printf("输出增广矩阵B:\n");
数据结构之数组
jiaomubai的博客
11-07 639
数组是有限个相同类型的变量所组成的有序集合，数组中的每一个变量被称为元素。数组是最简单、最常用的数据结构。以整型数组为例，数组的存储形式为： 数组中每一个元素都有自己的下标，这个下标从 0 开始，一直到数组长度 - 1 结束。数组的另外一个特点就是在内存中顺序存储，所以可以很好地实现逻辑上的顺序表。那顺序存储是个什么样子呢？我们知道，内存是由一个个连续的内存单元组成的，每一个内存单元都有自己的地址。在这些内存单元中，有些被其他数据占用了，有些是空闲的。数组中的每一个元素都存储在小小的单元中，并且元素之
常用数据结构与算法（数组）
in_kim的博客
07-23 299
C#常用数据结构与算法（数组）
数据结构与算法——数组
weixin_47998573的博客
04-10 387
数据结构与算法——数组
数组运算
一个搬运知识的笨小孩
03-07 7654
目录1.数组运算1.1 数组的创建和操作1.1.0 通过冒号创建一维数组1.1.1 通过 logspace 函数创建一维数组1.1.2 通过linspace函数创建一维数组1.2 数组的常见运算1.2.0 数组的算术运算1.2.1 数组的关系运算1.2.2 数组的逻辑运算 1.数组运算 MATLAB中的所有数据都按照数组的形式进行存储和运算 数组的属性及数组之间的逻辑关系是编写程序时非常重要的两个方面 在MATLAB上，数组的定义是广义的，数组的元素可以是任意的数据类型，例如数值、字符串等 矩阵是特殊的数组
数据结构与算法--数组
君莫笑的博客
09-08 904
数据结构与算法--数组
数据结构数组的运算
weixin_33940102的博客
05-07 344
#include<stdio.h>int main(){int a[100][100],b[100][100];int m;//表示行printf("请输入行m：\n");scanf("%d",&m);int n;//表示列printf("请输入列n：\n");scanf("%d",&n); for(int i=0;i<m;i++){for(i...
数据结构与算法 －数组
越陌度阡
05-30 986
数组可看成是一种特殊的线性表，其特殊在于表中的数组元素本身也是一种线性表。 数组的逻辑结构和运算 数组它是线性表的推广，其每个元素由一个值和一 组下标组成，其中下标个数称为数组的维数。 数组是我们最熟悉的数据类型，在早期的高级语言中，数组是唯 一可供使用的数据类型。由于数组中各元素具有统一的类型，并且数组元素的下标一般具有固定的上界和下界，因此，数组的处理比其它复杂的结构更为简单，多维数组也是线性表的一种延伸。 上图所示的二维数组Amn可以看成是由m个行向量组成的向量， 也可以看成是n个列向量组

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

北街风

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值