devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

数据结构与算法入门(Java)_算法入门java

作者：羊村懒王 | 2024-05-24 03:29:26

赞

踩

算法入门java

数据结构与算法(Java)

1. 数据结构与算法概述

1.1 什么是数据结构？

官方解释：

数据结构是一门研究非数值计算的程序设计问题中的操作对象，以及他们之间的关系和操作等相关问题的学科。

大白话：

数据结构就是把数据元素按照一定的关系组织起来的集合，用来组织和存储数据

1.2 数据结构分类

传统上，我们可以把数据结构分为逻辑结构和物理结构两大类。

逻辑结构：

逻辑结构是从具体问题中抽象出来的模型，是抽象意义上的结构，按照对象中数据元素之间的相互关系分类，也是

我们后面课题中需要关注和讨论的问题。

a.集合结构：集合结构中数据元素除了属于同一个集合外，他们之间没有任何其他的关系。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vloCjchP-1681958360316)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930324.png)]

b.线性结构：线性结构中的数据元素之间存在一对一的关系

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-urTNfnpI-1681958360319)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930326.png)]

c.树形结构：树形结构中的数据元素之间存在一对多的层次关系

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YMq2XnQZ-1681958360320)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930329.png)]

d.图形结构：图形结构的数据元素是多对多的关系

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cPNwPc28-1681958360321)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930330.png)]

物理结构：

逻辑结构在计算机中真正的表示方式（又称为映像）称为物理结构，也可以叫做存储结构。常见的物理结构有顺序

存储结构、链式存储结构。

顺序存储结构：

把数据元素放到地址连续的存储单元里面，其数据间的逻辑关系和物理关系是一致的 ，比如我们常用的数组就是

顺序存储结构。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yfujYDJn-1681958360322)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930331.png)]

顺序存储结构存在一定的弊端，就像生活中排时也会有人插队也可能有人有特殊情况突然离开，这时候整个结构都

处于变化中，此时就需要链式存储结构。

链式存储结构：

是把数据元素存放在任意的存储单元里面，这组存储单元可以是连续的也可以是不连续的。此时，数据元素之间并

不能反映元素间的逻辑关系，因此在链式存储结构中引进了一个指针存放数据元素的地址，这样通过地址就可以找

到相关联数据元素的位置。

1.3 什么是算法？

官方解释：

算法是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法解决问题的策略

机制。也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。

**大白话：**根据一定的条件，对一些数据进行计算，得到需要的结果。

2. 算法分析

研究算法的最终目的就是如何花更少的时间，如何占用更少的内存去完成相同的需求。

我们要计算算法时间耗费情况，首先我们得度量算法的执行时间，那么如何度量呢？

2.1 算法的时间复杂度分析

事后分析估算方法：

比较容易想到的方法就是我们把算法执行若干次，然后拿个计时器在旁边计时，这种事后统计的方法看上去的确不

错，并且也并非要我们真的拿个计算器在旁边计算，因为计算机都提供了计时的功能。这种统计方法主要是通过设

计好的测试程序和测试数据，利用计算机计时器对不同的算法编制的程序的运行时间进行比较，从而确定算法效率

的高低，但是这种方法有很大的缺陷：必须依据算法实现编制好的测试程序，通常要花费大量时间和精力，测试完

了如果发现测试的是非常糟糕的算法，那么之前所做的事情就全部白费了，并且不同的测试环境(硬件环境)的差别

导致测试的结果差异也很大。

public static void main(String[] args) {
	long start = System.currentTimeMillis();
    int sum = 0;
    int n=100;
    for (int i = 1; i <= n; i++) {
    	sum += i;
	}
    System.out.println("sum=" + sum);
    long end = System.currentTimeMillis();
    System.out.println(end-start);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

事前分析估算方法：

在计算机程序编写前，依据统计方法对算法进行估算，经过总结，我们发现一个高级语言编写的程序程序在计算机

上运行所消耗的时间取决于下列因素：

1.算法采用的策略和方案；

2.编译产生的代码质量；

3.问题的输入规模(所谓的问题输入规模就是输入量的多少)；

4.机器执行指令的速度；

由此可见，抛开这些与计算机硬件、软件有关的因素，一个程序的运行时间依赖于算法的好坏和问题的输入规模。

如果算法固定，那么该算法的执行时间就只和问题的输入规模有关系了。

我么再次以之前的求和案例为例，进行分析。

需求：

计算1到100的和。

第一种解法：

//如果输入量为n为1，则需要计算1次；
//如果输入量n为1亿，则需要计算1亿次；
public static void main(String[] args) {
    int sum = 0;//执行1次
    int n=100;//执行1次
    for (int i = 1; i <= n; i++) {//执行了n+1次
    	sum += i;//执行了n次
    }
	System.out.println("sum=" + sum);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

第二种解法：

//如果输入量为n为1，则需要计算1次；
//如果输入量n为1亿，则需要计算1次；
public static void main(String[] args) {
    int sum = 0;//执行1次
    int n=100;//执行1次
    sum = (n+1)*n/2;//执行1次
    System.out.println("sum="+sum);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

因此，当输入规模为n时，第一种算法执行了1+1+(n+1)+n=2n+3次；第二种算法执行了1+1+1=3次。如果我们把

第一种算法的循环体看做是一个整体，忽略结束条件的判断，那么其实这两个算法运行时间的差距就是n和1的差

距。

为什么循环判断在算法1里执行了n+1次，看起来是个不小的数量，但是却可以忽略呢？我们来看下一个例子：

需求：

计算100个1+100个2+100个3+…100个100的结果

代码：

public static void main(String[] args) {
    int sum=0;
    int n=100;
    for (int i = 1; i <=n ; i++) {
        for (int j = 1; j <=n ; j++) {
        sum+=i;
        }
    }
    System.out.println("sum="+sum);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

上面这个例子中，如果我们要精确的研究循环的条件执行了多少次，是一件很麻烦的事情，并且，由于真正计算和

的代码是内循环的循环体，所以，在研究算法的效率时，我们只考虑核心代码的执行次数，这样可以简化分析。

我们研究算法复杂度，侧重的是当输入规模不断增大时，算法的增长量的一个抽象(规律)，而不是精确地定位需要

执行多少次，因为如果是这样的话，我们又得考虑回编译期优化等问题，容易主次跌倒。

我们不关心编写程序所用的语言是什么，也不关心这些程序将跑在什么样的计算机上，我们只关心它所实现的算

法。这样，不计那些循环索引的递增和循环终止的条件、变量声明、打印结果等操作，最终在分析程序的运行时间

时，最重要的是把程序看做是独立于程序设计语言的算法或一系列步骤。我们分析一个算法的运行时间，最重要的

就是把核心操作的次数和输入规模关联起来。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pT5IrW7a-1681958360323)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930332.png)]

2.1.1 函数渐近增长

概念：

给定两个函数f(n)和g(n),如果存在一个整数N，使得对于所有的n>N,f(n)总是比g(n)大，那么我们说f(n)的增长渐近

快于g(n)。

概念似乎有点艰涩难懂，那接下来我们做几个测试。

测试一：

假设四个算法的输入规模都是n：

  1. 算法A1要做2n+3次操作，可以这么理解：先执行n次循环，执行完毕后，再有一个n次循环，最后有3次运算；

  2. 算法A2要做2n次操作；

  3. 算法B1要做3n+1次操作，可以这个理解：先执行n次循环，再执行一个n次循环，再执行一个n次循环，最后有 1 次运算。

  4. 算法B2要做3n次操作；

那么，上述算法，哪一个更快一些呢？

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-epnF5Whb-1681958360324)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930333.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ur7s2OLG-1681958360325)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930334.png)]

通过数据表格，比较算法A1和算法B1：

当输入规模n=1时，A1需要执行5次，B1需要执行4次，所以A1的效率比B1的效率低；

当输入规模n=2时，A1需要执行7次，B1需要执行7次，所以A1的效率和B1的效率一样；

当输入规模n>2时，A1需要的执行次数一直比B1需要执行的次数少，所以A1的效率比B1的效率高；

所以我们可以得出结论：

当输入规模n>2时，算法A1的渐近增长小于算法B1 的渐近增长

通过观察折线图，我们发现，随着输入规模的增大，算法A1和算法A2逐渐重叠到一块，算法B1和算法B2逐渐重叠

到一块，所以我们得出结论：

随着输入规模的增大，算法的常数操作可以忽略不计

测试二：

假设四个算法的输入规模都是n：

  1. 算法C1需要做4n+8次操作

  2. 算法C2需要做n次操作

  3. 算法D1需要做2n^2次操作

  4. 算法D2需要做n^2次操作

那么上述算法，哪个更快一些？

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GMe11OXM-1681958360325)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930335.png)]

通过数据表格，对比算法C1和算法D1：

当输入规模n<=3时，算法C1执行次数多于算法D1，因此算法C1效率低一些；

当输入规模n>3时，算法C1执行次数少于算法D1，因此，算法D2效率低一些，

所以，总体上，算法C1要优于算法D1.通过折线图，对比对比算法C1和C2：

随着输入规模的增大，算法C1和算法C2几乎重叠

通过折线图，对比算法C系列和算法D系列：

随着输入规模的增大，即使去除n^2前面的常数因子，D系列的次数要远远高于C系列

因此，可以得出结论：

随着输入规模的增大，与最高次项相乘的常数可以忽略

测试三：

假设四个算法的输入规模都是n：

算法E1: 2n^2+3n+1;

算法E2： n^2

算法F1： 2n^3+3n+1

算法F2： n^3

那么上述算法，哪个更快一些？

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gALThtrJ-1681958360326)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930336.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nCyWP4zR-1681958360327)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930338.png)]

通过数据表格，对比算法E1和算法F1：

当n=1时，算法E1和算法F1的执行次数一样；

当n>1时，算法E1的执行次数远远小于算法F1的执行次数；

所以算法E1总体上是由于算法F1的。

通过折线图我们会看到，算法F系列随着n的增长会变得特块，算法E系列随着n的增长相比较算法F来说，变得比较

慢，所以可以得出结论：

最高次项的指数大的，随着n的增长，结果也会变得增长特别快

测试四：

假设五个算法的输入规模都是n：

算法G： n^3;

算法H: n^2;

算法I： n:

算法J： logn

算法K: 1

那么上述算法，哪个效率更高呢？

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pQFM4oft-1681958360327)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930339.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SVqCZQZq-1681958360328)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930340.png)]

通过观察数据表格和折线图，很容易可以得出结论：

算法函数中n最高次幂越小，算法效率越高

总上所述，在我们比较算法随着输入规模的增长量时，可以有以下规则：

1. 算法函数中的常数可以忽略；

2. 算法函数中最高次幂的常数因子可以忽略；

3. 算法函数中最高次幂越小，算法效率越高。

2.1.2 算法时间复杂度
2.1.2.1 大O记法

定义：

​ 在进行算法分析时，语句总的执行次数T(n)是关于问题规模n的函数，进而分析T(n)随着n的变化情况并确定T(n) 的量级。算法的时间复杂度，就是算法的时间量度，记作:T(n)=O(f(n))。它表示随着问题规模n的增大，算法执行时间 的增长率和f(n)的增长率相同，称作算法的渐近时间复杂度，简称时间复杂度，其中f(n)是问题规模n的某个函数。

​ 在这里，我们需要明确一个事情：执行次数=执行时间

​ 用大写O()来体现算法时间复杂度的记法，我们称之为大O记法。一般情况下，随着输入规模n的增大，T(n)增长最慢的算法为最优算法。

下面我们使用大O表示法来表示一些求和算法的时间复杂度：

算法一：

public static void main(String[] args) {
    int sum = 0;//执行1次
    int n=100;//执行1次
    sum = (n+1)*n/2;//执行1次
    System.out.println("sum="+sum);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

算法二：

public static void main(String[] args) {
    int sum = 0;//执行1次
    int n=100;//执行1次
    for (int i = 1; i <= n; i++) {
    	sum += i;//执行了n次
    }
    System.out.println("sum=" + sum);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

算法三：

public static void main(String[] args) {
    int sum=0;//执行1次
    int n=100;//执行1次
    for (int i = 1; i <=n ; i++) {
        for (int j = 1; j <=n ; j++) {
        	sum+=i;//执行n^2次
        }
    }
    System.out.println("sum="+sum);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

如果忽略判断条件的执行次数和输出语句的执行次数，那么当输入规模为n时，以上算法执行的次数分别为：

算法一：3次

算法二：n+3次

算法三：n^2+2次

如果用大O记法表示上述每个算法的时间复杂度，应该如何表示呢？基于我们对函数渐近增长的分析，推导大O阶

的表示法有以下几个规则可以使用：

1.用常数1取代运行时间中的所有加法常数；

2.在修改后的运行次数中，只保留高阶项；

3.如果最高阶项存在，且常数因子不为1，则去除与这个项相乘的常数；

所以，上述算法的大O记法分别为：

算法一：O(1)

算法二：O(n)

算法三：O(n^2)

2.1.2.2 常见的大O阶
1.线性阶

一般含有非嵌套循环涉及线性阶，线性阶就是随着输入规模的扩大，对应计算次数呈直线增长，例如：

public static void main(String[] args) {
    int sum = 0;
    int n=100;
    for (int i = 1; i <= n; i++) {
    	sum += i;
    }
    System.out.println("sum=" + sum);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

上面这段代码，n=100，也就是说，外层循环每执行一次，内层循环就执行100次，那总共程序想要从这两个循环

中出来，就需要执行100*100次，也就是n的平方次，所以这段代码的时间复杂度是O(n^2).

2. 平方阶

一般嵌套循环属于这种时间复杂度

public static void main(String[] args) {
    int sum=0,n=100;
    for (int i = 1; i <=n ; i++) {
        for (int j = 1; j <=n ; j++) {
        	sum+=i;
        }
    }
    System.out.println(sum);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

上面这段代码，n=100，也就是说，外层循环每执行一次，内层循环就执行100次，那总共程序想要从这两个循环

中出来，就需要执行100*100次，也就是n的平方次，所以这段代码的时间复杂度是O(n^2).

3.立方阶

一般三层嵌套循环属于这种时间复杂度

public static void main(String[] args) {
    int x=0,n=100;
    for (int i = 1; i <=n ; i++) {
        for (int j = i; j <=n ; j++) {
            for (int j = i; j <=n ; j++) {
            	x++;
            }
        }
    }
    System.out.println(x);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

上面这段代码，n=100，也就是说，外层循环每执行一次，中间循环循环就执行100次，中间循环每执行一次，最

内层循环需要执行100次，那总共程序想要从这三个循环中出来，就需要执行100*100*100次，也就是n的立方，所以这段代码的时间复杂度是O(n^3).

4.对数阶

对数，属于高中数学的内容，我们分析程序以程序为主，数学为辅，所以不用过分担心。

int i=1,n=100;
while(i<n){
	i = i*2;
}

  • 1
  • 2
  • 3
  • 4

由于每次i*2之后，就距离n更近一步，假设有x个2相乘后大于n，则会退出循环。由于是2^x=n,得到x=log(2)n,所

以这个循环的时间复杂度为O(logn);

对于对数阶，由于随着输入规模n的增大，不管底数为多少，他们的增长趋势是一样的，所以我们会忽略底数。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ciLmaMn7-1681958360329)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930341.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U7aqE66O-1681958360329)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930342.png)]

5.常数阶

一般不涉及循环操作的都是常数阶，因为它不会随着n的增长而增加操作次数。例如：

public static void main(String[] args) {
    int n=100;
    int i=n+2;
    System.out.println(i);
}

  • 1
  • 2
  • 3
  • 4
  • 5

上述代码，不管输入规模n是多少，都执行2次，根据大O推导法则，常数用1来替换，所以上述代码的时间复杂度

为O(1) 下面是对常见时间复杂度的一个总结：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SbcYCKSv-1681958360330)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930343.png)]

他们的复杂程度从低到高依次为：

O(1)<O(logn)<O(n)<O(nlogn)<O(n2)<O(n3)

根据前面的折线图分析，我们会发现，从平方阶开始，随着输入规模的增大，时间成本会急剧增大，所以，我们的

算法，尽可能的追求的是O(1),O(logn),O(n),O(nlogn)这几种时间复杂度，而如果发现算法的时间复杂度为平方

阶、 立方阶或者更复杂的，那我们可以分为这种算法是不可取的，需要优化。

2.1.2.3 函数调用的时间复杂度分析

之前，我们分析的都是单个函数内，算法代码的时间复杂度，接下来我们分析函数调用过程中时间复杂度。

案例一：

public static void main(String[] args) {
    int n=100;
    for (int i = 0; i < n; i++) {
    	show(i);
    }
}
private static void show(int i) {
	System.out.println(i);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

在main方法中，有一个for循环，循环体调用了show方法，由于show方法内部只执行了一行代码，所以show方法的时间复杂度为O(1),那main方法的时间复杂度就是O(n)

案例二：

public static void main(String[] args) {
    int n=100;
    for (int i = 0; i < n; i++) {
    	show(i);
    }
}
private static void show(int i) {
    for (int j = 0; j < i; i++) {
    	System.out.println(i);
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

在main方法中，有一个for循环，循环体调用了show方法，由于show方法内部也有一个for循环，所以show方法

的时间复杂度为O(n),那main方法的时间复杂度为O(n^2)

案例三：

public static void main(String[] args) {
    int n=100;
    show(n);
    for (int i = 0; i < n; i++) {
    	show(i);
    }
    for (int i = 0; i < n; i++) {
    	for (int j = 0; j < n; j++) {
    		System.out.println(j);
    	}
    }
}

private static void show(int i) {
    for (int j = 0; j < i; i++) {
    	System.out.println(i);
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

在show方法中，有一个for循环，所以show方法的时间复杂度为O(n),在main方法中，show(n)这行代码内部执行

的次数为n，第一个for循环内调用了show方法，所以其执行次数为n^2,第二个嵌套for循环内只执行了一行代码，

所以其执行次数为n2,那么main方法总执行次数为n+n2+n2=2n2+n。根据大O推导规则，去掉n保留最高阶

项，并去掉最高阶项的常数因子2，所以最终main方法的时间复杂度为O(n^2)。

2.1.2.4 最坏情况

从心理学角度讲，每个人对发生的事情都会有一个预期，比如看到半杯水，有人会说：哇哦，还有半杯水哦！但也

有人会说：天哪，只有半杯水了。一般人处于一种对未来失败的担忧，而在预期的时候趋向做最坏的打算，这样即

使最糟糕的结果出现，当事人也有了心理准备，比较容易接受结果。假如最糟糕的结果并没有出现，当事人会很快

乐。 算法分析也是类似，假如有一个需求：

有一个存储了n个随机数字的数组，请从中查找出指定的数字。

public int search(int num){
    int[] arr={11,10,8,9,7,22,23,0};
    for (int i = 0; i < arr.length; i++) {
        if (num==arr[i]){
        	return i;
        }
    }
    return -1;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

最好情况：

查找的第一个数字就是期望的数字，那么算法的时间复杂度为O(1)

最坏情况：

查找的最后一个数字，才是期望的数字，那么算法的时间复杂度为O(n)

平均情况：

任何数字查找的平均成本是O(n/2)

最坏情况是一种保证，在应用中，这是一种最基本的保障，即使在最坏情况下，也能够正常提供服务，所以，除非

特别指定，我们提到的运行时间都指的是最坏情况下的运行时间。

2.2 算法的空间复杂度分析

计算机的软硬件都经历了一个比较漫长的演变史，作为为运算提供环境的内存，更是如此，从早些时候的512k,经

历了1M，2M，4M…等，发展到现在的8G，甚至16G和32G，所以早期，算法在运行过程中对内存的占用情况也

是 一个经常需要考虑的问题。我么可以用算法的空间复杂度来描述算法对内存的占用。

2.2.1 java中常见内存占用

1.基本数据类型内存占用情况：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nDQntRXP-1681958360331)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930344.png)]

2.计算机访问内存的方式都是一次一个字节

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jxjBnsGw-1681958360331)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930345.png)]

3.一个引用（机器地址）需要8个字节表示：

例如： Date date = new Date(),则date这个变量需要占用8个字节来表示

4.创建一个对象

比如new Date()，除了Date对象内部存储的数据(例如年月日等信息)占用的内存，该对象本身也有内存开销，每个对象的自身开销是16个字节，用来保存对象的头信息。

5.一般内存的使用，如果不够8个字节，都会被自动填充为8字节：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NADeP2yw-1681958360332)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930346.png)]

6.数组的特殊性

java中数组被被限定为对象，他们一般都会因为记录长度而需要额外的内存。

一个原始数据类型的数组一般需要24字节的头信息(16个自己的对象开销，4字节用于保存长度以及4个填充字节)再加上保存值所需的内存。

2.2.2 算法的空间复杂度

了解了java的内存最基本的机制，就能够有效帮助我们估计大量程序的内存使用情况。

算法的空间复杂度计算公式记作：S(n)=O(f(n)),其中n为输入规模，f(n)为语句关于n所占存储空间的函数。

案例：

对指定的数组元素进行反转，并返回反转的内容。

解法一：

public static int[] reverse1(int[] arr){
    int n=arr.length;//申请4个字节
    int temp;//申请4个字节
    for(int start=0,end=n-1;start<=end;start++,end--){
        temp=arr[start];
        arr[start]=arr[end];
        arr[end]=temp;
    }
    return arr;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

解法二：

public static int[] reverse2(int[] arr){
    int n=arr.length;//申请4个字节
    int[] temp=new int[n];//申请n*4个字节+数组自身头信息开销24个字节
    for (int i = n-1; i >=0; i--) {
    	temp[n-1-i]=arr[i];
    }
    return temp;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

忽略判断条件占用的内存，我们得出的内存占用情况如下：

算法一：

​ 不管传入的数组大小为多少，始终额外申请4+4=8个字节；

算法二：

​ 4+4n+24=4n+28;

​ 根据大O推导法则，算法一的空间复杂度为O(1),算法二的空间复杂度为O(n),所以从空间占用的角度讲，算法一要 优于算法二。 由于java中有内存垃圾回收机制，并且jvm对程序的内存占用也有优化（例如即时编译），我们无法精确的评估一个java程序的内存占用情况，但是了解了java的基本内存占用，使我们可以对java程序的内存占用情况进行估算。

由于现在的计算机设备内存一般都比较大，基本上个人计算机都是4G起步，大的可以达到32G，所以内存占用一般情况下并不是我们算法的瓶颈，普通情况下直接说复杂度，默认为算法的时间复杂度。 

  • 1

​ 但是，如果你做的程序是嵌入式开发，尤其是一些传感器设备上的内置程序，由于这些设备的内存很小，一般为几kb，这个时候对算法的空间复杂度就有要求了，但是一般做java开发的，基本上都是服务器开发，一般不存在这样的问题。

3. 排序

3.1 总纲

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PPqi5AkW-1681958360332)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202304142116636.png)]

3.2 Comparable与Comparator接口介绍

​ 由于我们这里要讲排序，所以肯定会在元素之间进行比较。规则的。在实际应用中，我们往往有需要比较两个自定义对象大小的地方。而这些自定义对象的比较，就不像简单的整型数据那么简单，它们往往包含有许多的属性，我们一般都是根据这些属性对自定义对象进行比较的。所以Java中要比较对象的大小或者要对对象的集合进行排序，需要通过比较这些对象的某些属性的大小来确定它们之间的大小关系。

​ 一般，Java中通过接口实现两个对象的比较，比较常用就是Comparable接口和Comparator接口。首先类要实现接口，并且使用泛型规定要进行比较的对象所属的类，然后类实现了接口后，还需要实现接口定义的比较方法（compareTo方法或者compare方法），在这些方法中传入需要比较大小的另一个对象，通过选定的成员变量与之比较，如果大于则返回1，小于返回-1，相等返回0。

那么这两个接口有什么区别呢:

一般简单的回答可以这么说：

1）首先这两个接口一般都是用来实现集合内的排序，comparable还可以用于两个对象大小的比较。

2）Comparable接口在java.lang包下面。里面有一个compareTo(T)接口方法。当一个类需要比较的时候，需自行实现Comparable接口的CompareTo方法。当调用集合排序方法的时候，就会调用对象的compareTo()方法来实现对象的比较。

3）Comparator接口在java.util包下面。Comparator是一个比较器接口，一般单独定义一个比较器实现该接口中的比较方法compare();在集合sort方法中传入对应的比较器实现类。一般使用匿名内部类来实现比较器。

4）Comparator相对于Comparable来说更加的灵活，耦合度低。

下面通过两个例子来简单说一下这两个接口的区别！

Comparable

1.定义一个学生类User，具有年龄age和姓名username两个属性，并通过Comparable接口提供比较规则

package com.ynu.Java版算法.U2_排序.T1_简单排序.S1_Comparable接口介绍;


public class User implements Comparable<User>{

    private String name;

    private int age;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    // compareTo 接口返回值大于0   传入的o排序时候放在前面  (前大后小)
    // 所以假如要升序排列  新进一个元素如果比当前年龄小还要在前面，就要让返回值大于0 那么就用this.age - o.age
    // 假如要降序序排列  新进一个元素如果比当前年龄小还要排在后面，就要让返回值小于0 那么就用o.age - this.age
    @Override
    public int compareTo(User o) {
        return this.age-o.age;      //升序排列  (当前升后降   当前对象在减号前面是升序，反之降序)
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}



package com.ynu.Java版算法.U2_排序.T1_简单排序.S1_Comparable接口介绍;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {

    public static void main(String[] args) {
        List<User> users = new ArrayList<>();
        users.add(new User("lh",27));
        users.add(new User("lmj",25));
        users.add(new User("ybh",24));
        users.add(new User("czx",26));
        System.out.println(users);
        //排序 需要传入集合的对象实现了Comparable接口
        Collections.sort(users);
        System.out.println(users);

    }

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74

Comparator

package com.ynu.Java版算法.U2_排序.T1_简单排序.S2_Compareto接口介绍;

import java.util.Comparator;

public class MyComparator implements Comparator<User> {

    @Override
    public int compare(User o1, User o2) {
        return o1.getAge() - o2.getAge();   //根据年龄升序排列   把o1作为当前对象
    }
}


package com.ynu.Java版算法.U2_排序.T1_简单排序.S2_Compareto接口介绍;

public class User {

    private String name;

    private int age;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}


package com.ynu.Java版算法.U2_排序.T1_简单排序.S2_Compareto接口介绍;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {

    public static void main(String[] args) {

        List<User> users = new ArrayList<>();
        users.add(new User("lmj",25));
        users.add(new User("ybh",24));
        users.add(new User("czx",27));
        users.add(new User("lh",23));
        System.out.println(users);
        // 传入Comparator接口实现类   用自定义的规则排序
        Collections.sort(users,new MyComparator());
        System.out.println(users);

    }

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78

Comparator接口与Comparable接口不同的是：

① Comparator位于包java.util下，而Comparable位于包java.lang下。

② Comparable接口将比较代码嵌入需要进行比较的类的自身代码中，而Comparator接口在一个独立的类中实现比较。

③ comparator接口相对更灵活些，因为它跟接口实现的类是耦合在一起的，可以通过换比较器来换不同的规则进

​ 行比较，即如果前期类的设计没有考虑到类的Compare问题而没有实现Comparable接口，后期可以通过

​ Comparator接口来实现比较算法进行排序，并且为了使用不同的排序标准做准备，比如：升序、降序。

④ Comparable接口强制进行自然排序，而Comparator接口不强制进行自然排序，可以指定排序顺序。

⑤ 换一种说法，简单的说：

Comparable：使user类具有自比较的能力，可以让自己跟同类型的数据做比较；

Comparator:就是一个比较器,像一个第三方，传入两个对象，让比较器去判断谁大谁小；

3.1 比较类排序

3.1.1 交换排序

在我们的程序中，排序是非常常见的一种需求，提供一些数据元素，把这些数据元素按照一定的规则进行排序。比如查询一些订单，按照订单的日期进行排序；再比如查询一些商品，按照商品的价格进行排序等等。所以，接下来我们要学习一些常见的排序算法。

在java的开发工具包jdk中，已经给我们提供了很多数据结构与算法的实现，比如List，Set，Map，Math等等，都是以API的方式提供，这种方式的好处在于一次编写，多处使用。我们借鉴jdk的方式，也把算法封装到某个类中， 那如果是这样，在我们写java代码之前，就需要先进行API的设计，设计好之后，再对这些API进行实现。

就比如我们先设计一套API如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RR2VQzgc-1681958360333)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930347.png)]

然后再使用java代码去实现它。

① 冒泡排序

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。

需求：

排序前：{4,5,6,3,2,1}

排序后：{1,2,3,4,5,6}

排序原理：

  1. 比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置。

  2. 对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大

    值。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CpkCirCH-1681958360334)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930348.png)]

冒泡排序API设计：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MLXG3wYu-1681958360334)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930349.png)]

冒泡排序的代码实现：

package com.ynu.Java版算法.U2_排序.T2_冒泡排序;

import java.util.Comparator;

public class Bubble {

    // 对数组内的元素进行升序
    public static void sort(Comparable[] arr){
        for (int i = arr.length-1; i >= 0; i--) {
            for (int j = 0; j < i; j++) {
                if (greater(arr[j],arr[j+1])){
                    exch(arr,j,j+1);
                }
            }
        }
    }

    // 判断v是否大于w
    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }

    // 交换数组中i,j索引处的值
    private static void exch(Comparable[] a,int i,int j){
        Comparable temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

package com.ynu.Java版算法.U2_排序.T2_冒泡排序;

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // 数字数组
        // Integer类实现过Comparable接口 可以自然排序
        Integer[] arr = {4, 5, 6, 3, 2, 1};
        System.out.println("排序前"+Arrays.toString(arr));
        Bubble.sort(arr);
        System.out.println("排序后"+Arrays.toString(arr));
        
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45

冒泡排序的时间复杂度分析 冒泡排序使用了双层for循环，其中内层循环的循环体是真正完成排序的代码，所以，

我们分析冒泡排序的时间复杂度，主要分析一下内层循环体的执行次数即可。

在最坏情况下，也就是假如要排序的元素为{6,5,4,3,2,1}逆序，那么：

元素比较的次数为：

(N-1)+(N-2)+(N-3)+…+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;

元素交换的次数为：

(N-1)+(N-2)+(N-3)+…+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;

总执行次数为：

(N2/2-N/2)+(N2/2-N/2)=N^2-N;

按照大O推导法则，保留函数中的最高阶项那么最终冒泡排序的时间复杂度为O(N^2).

② 快速排序
3.1.2 插入排序
① 简单插入排序
② 希尔排序
3.1.3 选择排序

选择排序是一种更加简单直观的排序方法。

需求：

排序前：{4,6,8,7,9,2,10,1}

排序后：{1,2,4,5,7,8,9,10}

① 简单选择排序
② 希尔排序
3.1.4 归并排序
① 二路归并排序
② 多路归并排序

3.2 非比较类排序

① 计数排序
② 桶排序
③ 基数排序

4. 线性表

线性表是最基本、最简单、也是最常用的一种数据结构(逻辑结构)。一个线性表是n个具有相同特性的数据元素的有限序列。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LDCOn2an-1681958360335)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930350.png)]

前驱元素：

若A元素在B元素的前面，则称A为B的前驱元素

后继元素：

若B元素在A元素的后面，则称B为A的后继元素

**线性表的特征：数据元素之间具有一种“一对一”**的逻辑关系。

  1. 第一个数据元素没有前驱，这个数据元素被称为头结点；

  2. 最后一个数据元素没有后继，这个数据元素被称为尾结点；

  3. 除了第一个和最后一个数据元素外，其他数据元素有且仅有一个前驱和一个后继。

如果把线性表用数学语言来定义，则可以表示为(a1,…ai-1,ai,ai+1,…an)，ai-1领先于ai,ai领先于ai+1，称ai-1是ai的

前驱元素，ai+1是ai的后继元素。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gPdZggZj-1681958360336)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930351.png)]

线性表的分类：

线性表中数据存储的方式可以是顺序存储，也可以是链式存储，按照数据的存储方式不同，可以把线性表分为顺序

表和链表。

4.1 顺序表

​ 顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元，依次存储线性表中的各个元素、使得线性表中再逻辑结构上响铃的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3AXTm4dY-1681958360337)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930352.png)]

4.1.1 顺序表的实现

顺序表API设计：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Rv95Zs9s-1681958360337)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930353.png)]

顺序表的代码实现：

package com.ynu.Java版算法.U4_线性表.T1_顺序表.S1_顺序表实现;

import org.omg.CORBA.Object;

//顺序表代码
public class SequenceList<T> {

    // 存储元素的数组
    private T[] eles;

    // 记录当前顺序表的元素个数
    private int N;

    // 构造方法
    public SequenceList(int capacity) {
        // 初始化这个内部数组
        eles = (T[])new Object[capacity];
        // 初始化大小
        N = 0;
    }

    // 判断当前线性表 是否为空
    public boolean isEmpty(){
        return N == 0;
    }

    //获取线性表的长度
    public int length(){
        return N;
    }

    // 获取指定位置的元素
    public T get(int i){
        if (i < 0 || i >= N){
            throw new RuntimeException("当前元素不存在");
        }
        return eles[i];
    }

    // 向线型表中添加元素t  末尾添加
    public void insert(T t){
        if (N == eles.length){
            throw new RuntimeException("当前表已满了");
        }
        eles[N++] = t;
    }

    //在i元素处插入元素t
    public void insert(int i,T t){
        if (i==eles.length){
            throw new RuntimeException("当前表已满");
        }
        if (i<0 || i>N){
            throw new RuntimeException("插入的位置不合法");
        }
        for (int index = N; index > i ; index--) {
            eles[index] = eles[index-1];    // i之后的元素后移
        }

        //把t放到i位置处
        eles[i]=t;
        //元素数量+1
        N++;
    }

    //删除指定位置i处的元素，并返回该元素
    public T remove(int i){
        if (i<0 || i>N-1){
            throw new RuntimeException("当前要删除的元素不存在");
        }

        T result = eles[i];  //记录当前移除的元素

        for (int index = i; index < N-1  ; index++) {
            eles[index] = eles[index+1];
        }

        N--;

        return result;
    }

    //查找t元素第一次出现的位置
    public int indexOf(T t){
        if(t==null){
            throw new RuntimeException("查找的元素不合法");
        }
        for (int i = 0; i < N; i++) {
            if (eles[i].equals(t)){
                return i;
            }
        }
        return -1;
    }

}

// 测试代码


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
4.1.2 顺序表的遍历

一般作为容器存储数据，都需要向外部提供遍历的方式，因此我们需要给顺序表提供遍历方式。

在java中，遍历集合的方式一般都是用的是foreach循环，如果想让我们的SequenceList也能支持foreach循环，则需要做如下操作：

1.让SequenceList实现Iterable接口，重写iterator方法；

2.在SequenceList内部提供一个内部类SIterator,实现Iterator接口，重写hasNext方法和next方法；

代码：

package com.ynu.Java版算法.U4_线性表.T1_顺序表.S1_顺序表遍历;


import java.util.Iterator;

//顺序表代码
public class SequenceList<T> implements Iterable<T>{

    // 存储元素的数组
    private T[] eles;

    // 记录当前顺序表的元素个数
    private int N;

    // 构造方法
    public SequenceList(int capacity) {
        // 初始化这个内部数组
        eles = (T[])new Object[capacity];
        // 初始化大小
        N = 0;
    }

    // 判断当前线性表 是否为空
    public boolean isEmpty(){
        return N == 0;
    }

    //获取线性表的长度
    public int length(){
        return N;
    }

    // 获取指定位置的元素
    public T get(int i){
        if (i < 0 || i >= N){
            throw new RuntimeException("当前元素不存在");
        }
        return eles[i];
    }

    // 向线型表中添加元素t  末尾添加
    public void insert(T t){
        if (N == eles.length){
            throw new RuntimeException("当前表已满了");
        }
        eles[N++] = t;
    }

    //在i元素处插入元素t
    public void insert(int i,T t){
        if (i==eles.length){
            throw new RuntimeException("当前表已满");
        }
        if (i<0 || i>N){
            throw new RuntimeException("插入的位置不合法");
        }
        for (int index = N; index > i ; index--) {
            eles[index] = eles[index-1];    // i之后的元素后移
        }

        //把t放到i位置处
        eles[i]=t;
        //元素数量+1
        N++;
    }

    //删除指定位置i处的元素，并返回该元素
    public T remove(int i){
        if (i<0 || i>N-1){
            throw new RuntimeException("当前要删除的元素不存在");
        }

        T result = eles[i];  //记录当前移除的元素

        for (int index = i; index < N-1  ; index++) {
            eles[index] = eles[index+1];
        }

        N--;

        return result;
    }

    //查找t元素第一次出现的位置
    public int indexOf(T t){
        if(t==null){
            throw new RuntimeException("查找的元素不合法");
        }
        for (int i = 0; i < N; i++) {
            if (eles[i].equals(t)){
                return i;
            }
        }
        return -1;
    }

    //将一个线性表置为空表
    public void clear(){
        N=0;
    }


    @Override
    public Iterator<T> iterator() {
        return new MyIterator();
    }

    class MyIterator implements Iterator<T>{

        // 当前遍历的位置
        private int position;

        public MyIterator() {
            this.position = 0;
        }

        @Override
        public boolean hasNext() {
            return position < N;
        }

        @Override
        public T next() {
            return eles[position++];
        }
    }

}


package com.ynu.Java版算法.U4_线性表.T1_顺序表.S1_顺序表遍历;

public class Main {
    public static void main(String[] args) {

        SequenceList<String> list = new SequenceList(10);
        list.insert("ybh");
        list.insert("lmj");
        list.insert("czx");
        list.insert("lh");

        for (String s : list) {
            System.out.println(s);
        }

    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
4.1.3 顺序表的容量可变

在之前的实现中，当我们使用SequenceList时，先new SequenceList(5)创建一个对象，创建对象时就需要指定容

器的大小，初始化指定大小的数组来存储元素，当我们插入元素时，如果已经插入了5个元素，还要继续插入数

据，则会报错，就不能插入了。这种设计不符合容器的设计理念，因此我们在设计顺序表时，应该考虑它的容量的

伸缩性。

考虑容器的容量伸缩性，其实就是改变存储数据元素的数组的大小，那我们需要考虑什么时候需要改变数组的大

小？

1.添加元素时：

添加元素时，应该检查当前数组的大小是否能容纳新的元素，如果不能容纳，则需要创建新的容量更大的数组，我

们这里创建一个是原数组两倍容量的新数组存储元素。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BNnVGtYj-1681958360338)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930354.png)]

2.移除元素时：

​ 移除元素时，应该检查当前数组的大小是否太大，比如正在用100个容量的数组存储10个元素，这样就会造成内存空间的浪费，应该创建一个容量更小的数组存储元素。如果我们发现数据元素的数量不足数组容量的1/4，则创建一个是原数组容量的1/2的新数组存储元素。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G2s2JOsa-1681958360339)(https://gitee.com/yangbhui/cloudimg/raw/master/img/202303250930355.png)]

package com.ynu.Java版算法.U4_线性表.T1_顺序表.S2_顺序表的容量可变;


import java.util.Arrays;
import java.util.Iterator;

//顺序表代码
public class SequenceList<T> implements Iterable<T>{

    // 存储元素的数组
    private T[] eles;

    // 记录当前顺序表的元素个数
    private int N;

    // 构造方法
    public SequenceList(int capacity) {
        // 初始化这个内部数组
        eles = (T[])new Object[capacity];
        // 初始化大小
        N = 0;
    }

    // 判断当前线性表 是否为空
    public boolean isEmpty(){
        return N == 0;
    }

    //获取线性表的长度
    public int length(){
        return N;
    }

    // 获取指定位置的元素
    public T get(int i){
        if (i < 0 || i >= N){
            throw new RuntimeException("当前元素不存在");
        }
        return eles[i];
    }

    // 向线型表中添加元素t  末尾添加
    public void insert(T t){
        //元素已经放满了数组，需要扩容
        if (N == eles.length){
            revise(eles.length*2);
        }
        eles[N++] = t;
    }

    //在i元素处插入元素t
    public void insert(int i,T t){

        if (i<0 || i>N){
            throw new RuntimeException("插入的位置不合法");
        }

        if (N==eles.length){
            revise(eles.length*2);
        }

        for (int index = N; index > i ; index--) {
            eles[index] = eles[index-1];    // i之后的元素后移
        }

        //把t放到i位置处
        eles[i]=t;
        //元素数量+1
        N++;
    }

    //删除指定位置i处的元素，并返回该元素
    public T remove(int i){
        if (i<0 || i>N-1){
            throw new RuntimeException("当前要删除的元素不存在");
        }

        T result = eles[i];  //记录当前移除的元素

        for (int index = i; index < N-1  ; index++) {
            eles[index] = eles[index+1];
        }
        N--;

        if (N>0 && N < eles.length / 4){
            revise(eles.length/2);
        }

        return result;
    }

    //查找t元素第一次出现的位置
    public int indexOf(T t){
        if(t==null){
            throw new RuntimeException("查找的元素不合法");
        }
        for (int i = 0; i < N; i++) {
            if (eles[i].equals(t)){
                return i;
            }
        }
        return -1;
    }

    //将一个线性表置为空表
    public void clear(){
        N=0;
    }


    @Override
    public Iterator<T> iterator() {
        return new MyIterator();
    }

    class MyIterator implements Iterator<T>{

        // 当前遍历的位置
        private int position;

        public MyIterator() {
            this.position = 0;
        }

        @Override
        public boolean hasNext() {
            return position < N;
        }

        @Override
        public T next() {
            return eles[position++];
        }
    }


    // 改变容量
    public void revise(int newSize){
        // 记录旧数组
        T[] temp = eles;
        // 创建新数组
        eles = (T[])new Object[newSize];

        //把旧数组中的元素拷贝到新数组
        for (int i = 0; i < N; i++) {
            eles[i] = temp[i];
        }

    }

    // 返回线性表表的容量
    public int capacity(){
        return eles.length;
    }


    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < N; i++) {
            sb.append(eles[i]+" ");
        }
        return sb.toString();
    }
}

package com.ynu.Java版算法.U4_线性表.T1_顺序表.S2_顺序表的容量可变;

public class Main {
    public static void main(String[] args) {
        SequenceList<String> list = new SequenceList(2);
        System.out.println("当前集合的容量为："+list.capacity());

        list.insert("ybh");
        list.insert("lmj");
        list.insert("czx");
        list.insert("lh");
        System.out.println("现在集合的容量为："+list.capacity());


        list.insert(4,"aa");
        list.insert(4,"aa");
        list.insert(4,"aa");
        list.insert(4,"aa");
        list.insert(4,"aa");
        System.out.println(list);
        System.out.println("现在集合的容量为："+list.capacity());

        list.remove(1);
        list.remove(1);
        list.remove(1);
        list.remove(1);
        list.remove(1);
        list.remove(1);
        list.remove(1);

        System.out.println(list);
        System.out.println("现在集合的容量为："+list.capacity());

    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
4.1.4 顺序表的时间复杂度

get(i): 不难看出，不论数据元素量N有多大，只需要一次eles[i]就可以获取到对应的元素，所以时间复杂度为O(1);

insert(int i,T t): 每一次插入，都需要把i位置后面的元素移动一次，随着元素数量N的增大，移动的元素也越多，时间复杂为O(n);

**remove(int i)

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/615624
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。