线性表(
Linear List
)就是数据排成像一条线一样的结构,数据只有前后两个方向
![](https://i-blog.csdnimg.cn/direct/c88da973ca50477b903f542630f375ef.png)
1 数组
概念
数组(
Array
)是
有限
个
相同类型
的变量所组成的
有序
集合,数组中的每一个变量被称为元素。数组是最为简单、最为常用的数据结构。
![](https://i-blog.csdnimg.cn/direct/88ad12e29a254cd8a1cacf569714ab16.png)
数组下标从零开始
(Why)
存储原理
数组用一组
连续的内存空间
来存储一组具有
相同类型
的数据
![](https://i-blog.csdnimg.cn/direct/43f1b546379841b0a9517ee2319270be.png)
(
模拟内存存储
)
灰色格子:被使用的内存
橙色格子:空闲的内存
红色格子:数组占用的内存
数组可以根据下标随机访问数据
比如一个整型数据
int[]
长度为
5
![](https://i-blog.csdnimg.cn/direct/8eaa007abb4249d596a9d3088a33cddb.png)
假设首地址是:
1000
int
是
4
字节(
32
位)
,
实际内存存储是位
随机元素寻址
a[i]_address=a[0]_address+i*4
该公式解释了三个方面
- 连续性分配
- 相同的类型
- 下标从0开始
操作
- 读取元素
根据下标读取元素的方式叫作随机读取
int n=nums[2]
- 更新元素
nums[3]= 10;
注意不要数组越界
读取和更新都可以随机访问,时间复杂度为O(1)
- 插入元素
有三种情况:
尾部插入
在数据的实际元素数量小于数组长度的情况下:
直接把插入的元素放在数组尾部的空闲位置即可,等同于更新元素的操作
![](https://i-blog.csdnimg.cn/direct/b3297eaa20394009857f310e0d330894.png)
a[6]=10
中间插入
在数据的实际元素数量小于数组长度的情况下:
由于数组的每一个元素都有其固定下标,所以首先把插入位置及后面的元素向后移动,
腾出地方,再把要插入的元素放到对应的数组位置上。
![](https://i-blog.csdnimg.cn/direct/5d54006427e04621a9322da62c1bec71.png)
超范围插入
假如现在有一个数组,已经装满了元素,这时还想插入一个新元素,或者插入位置是越界的
这时就要对原数组进行扩容:可以创建一个新数组,长度是旧数组的
2
倍,再把旧数组中的元素 统统复制 过去,这样就实现了数组的扩容。
![](https://i-blog.csdnimg.cn/direct/351ad17caa1646fd8d5089ca125e22be.png)
int[] numsNew=new int[nums.length*2];
System.arraycopy(nums,0,numsNew,0,nums.length);
// 原数组就丢掉了,资源浪费
nums=numsNew;
- 删除元素
数组的删除操作和插入操作的过程相反,如果删除的元素位于数组中间,其后的元素都需要向前挪动1
位。
for(int i=p;i<nums.length;i++){
nums[i-1]=nums[i];
}
完整的代码:
package com.fx.linear;
public class ArrayDemo1 {
int[] nums = new int[8];
public ArrayDemo1() {
nums[0] = 3;
nums[1] = 1;
nums[2] = 2;
nums[3] = 5;
nums[4] = 4;
nums[5] = 9;
}
public int get(int i) {
return nums[i];
}
public void update(int i, int n) {
nums[i] = n;
}
public void insertTail(int n) {
nums[6] = n;
}
public void insertMiddle(int p, int n) {
for (int i = nums.length-1; i >= p-1; i--) {
//能取得值
if (nums[i] != 0) {
nums[i+1]=nums[i];
}
}
nums[p-1]=n;
}
/**
* 旧数组复制到新数组
*/
public void resize(){
int[] numsNew=new int[nums.length*2];
System.arraycopy(nums,0,numsNew,0,nums.length);
nums=numsNew;
}
public void insertOutOfBounds(int p,int n){
//数组扩容
resize();
nums[p-1]=n;
}
public void deleteMiddle(int p){
for(int i=p;i<nums.length;i++){
nums[i-1]=nums[i];
}
}
public void display() {
for (int n : nums) {
System.out.println(n);
}
}
public void display2() {
for (int i = nums.length - 1; i >= 0; i--) {
System.out.println(nums[i]);
}
}
public static void main(String[] args) {
ArrayDemo1 demo1 = new ArrayDemo1();
demo1.deleteMiddle(3);
demo1.display();
}
}
时间复杂度
读取和更新都是随机访问,所以是
O(1)
插入数组扩容的时间复杂度是
O(n)
,插入并移动元素的时间复杂度也是
O(n)
,综合起来插入操作的时间
复杂度是
O(n)
。
删除操作,只涉及元素的移动,时间复杂度也是
O(n)
优缺点
- 优点:
数组拥有非常高效的随机访问能力,只要给出下标,就可以用常量时间找到对应元素
- 缺点:
插入和删除元素方面。由于数组元素连续紧密地存储在内存中,插入、删除元素都会导致大量元素被迫 移动,影响效率。 (ArrayList LinkedList )
申请的空间必须是连续的,也就是说即使有空间也可能因为没有足够的连续空间而创建失败
如果超出范围,需要重新申请内存进行存储,原空间就浪费了
应用
数组是基础的数据结构,应用太广泛了,
ArrayList
、
Redis
、消息队列等等。
数据结构和算法的可视化网站:
https://www.cs.usfca.edu/~galles/visualization/Algorithms.html
2 链表
概念
链表(
linked list
)是一种在物理上非连续、非顺序的数据结构,由若干节点(
node
)所组成。
链表中数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。每个结点包括两个部分:一个是存储数据元素的数据域,另一个是存储下一个结点地址的指针域。(百度百科)
常见的链表包括:单链表、双向链表、循环链表
- 单链表
单向链表的每一个节点又包含两部分,一部分是存放数据的变量
data
,另一部分是指向下一个节
点的指针
next
![](https://i-blog.csdnimg.cn/direct/45951bceea1b49cd99c2b27ecd397d12.png)
Node{
int data;
Node next;
}
- 双向链表
双向链表的每一个节点除了拥有
data
和
next
指针,还拥有指向前置节点的
prev
指针。
![](https://i-blog.csdnimg.cn/direct/fa567d2b241744f195ebde72c7e9a82b.png)
Node{
int data;
Node next;
Node prev;
}
- 循环链表
链表的尾节点指向头节点形成一个环,称为循环链表
![](https://i-blog.csdnimg.cn/direct/85581388178a485ebb26089fcfea6e0e.png)
存储原理
数组在内存中的存储方式是顺序存储(连续存储),链表在内存中的存储方式则是随机存储(链式存储)。
链表的每一个节点分布在内存的不同位置,依靠
next
指针关联起来。这样可以灵活有效地利用零散的碎片空间。
![](https://i-blog.csdnimg.cn/direct/c54796fc4082409fb4eeb09804e652e1.png)
链表的第
1
个节点被称为头节点(3),没有任何节点的
next
指针指向它,或者说它的前置节点为空
头结点用来记录链表的基地址。有了它,我们就可以遍历得到整条链表
链表的最后
1
个节点被称为尾节点(2),它指向的
next
为空
操作
- 查找节点
在查找元素时,链表只能从头节点开始向后一个一个节点逐一查找。
![](https://i-blog.csdnimg.cn/direct/745eca145c5e4dd58ad2dc54738194ee.png)
- 更新节点
找到要更新的节点,然后把旧数据替换成新数据
![](https://i-blog.csdnimg.cn/direct/3d284d877f68445ea832ee98c874c0b1.png)
- 插入节点
尾部插入
把最后一个节点的
next
指针指向新插入的节点即可
![](https://i-blog.csdnimg.cn/direct/86ef0d8e1ec24c28baba28844e118672.png)
头部插入
第
1
步,把新节点的
next
指针指向原先的头节点
第
2
步,把新节点变为链表的头节点
![](https://i-blog.csdnimg.cn/direct/e5ab4b8ecfdc459c8f01688120aaced0.png)
中间插入
第
1
步,新节点的
next
指针,指向插入位置的节点
第
2
步,插入位置前置节点的
next
指针,指向新节点
![](https://i-blog.csdnimg.cn/direct/e8f0fc41266741debf3079b01666e668.png)
只要内存空间允许,能够插入链表的元素是无限的,不需要像数组那样考虑扩容的问题
- 删除节点
尾部删除
把倒数第
2
个节点的next指针指向空即可
![](https://i-blog.csdnimg.cn/direct/f81ddcd6a66048e087c5dd5bec26ae7a.png)
头部删除
把链表的头节点设为原先头节点的
next
指针即可
![](https://i-blog.csdnimg.cn/direct/adb443c9b307400b9ff217b56235087c.png)
中间删除
把要删除节点的前置节点的
next
指针,指向要删除元素的下一个节点即可
![](https://i-blog.csdnimg.cn/direct/6806799b6a464ec3b9c6f8ca72bcaecc.png)
完整代码
package com.fx.linear;
/**
* @ Author fx
* @ Date 2024/8/20 9:46
*/
public class Node {
int id;
String name;
//下一个节点
Node next;
public Node(int id, String name) {
this.id = id;
this.name = name;
}
@Override
public String toString() {
return "Node{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
}
package com.fx.linear;
/**
* 单链表
*/
public class SingleLinkedList {
//初始化头节点
private Node head = new Node(0, "");
/**
* 添加节点:从头插入
*
* @param node
*/
public void addNode(Node node) {
//从头插入
Node tmp = head;
while (true) {
//到尾节点
if (tmp.next == null) {
break;
}
//后移一个节点
tmp = tmp.next;
}
tmp.next = node;
}
public void addByIdOrder(Node node){
//从头插入
Node tmp = head;
while (true) {
//到尾节点
if (tmp.next == null) {
break;
}
//节点存在
if (tmp.next.id == node.id) {
break;
}
if (tmp.next.id > node.id) {
break;
}
tmp = tmp.next;
}
//交换位置
node.next = tmp.next;
tmp.next = node;
}
//遍历链表
public void showList() {
//空链表
if (head.next == null) {
System.out.println("链表为空");
return;
}
Node temp = head.next;
while (true) {
if (temp == null) {
return;
}
System.out.println(temp);
//指针下移
temp = temp.next;
}
}
public static void main(String[] args) {
Node n1=new Node(1,"张飞");
Node n2=new Node(2,"关羽");
Node n3=new Node(3,"赵云");
Node n4=new Node(4,"黄忠");
Node n5=new Node(5,"马超");
SingleLinkedList sll=new SingleLinkedList();
sll.addByIdOrder(n4);
sll.addByIdOrder(n5);
sll.addByIdOrder(n1);
sll.addByIdOrder(n2);
sll.addByIdOrder(n3);
sll.showList();
}
}
时间复杂度
查找节点 :
O(n)
插入节点:
O(1)
更新节点:
O(1)
删除节点:
O(1)
优缺点
- 优势
插入、删除、更新效率高
省空间
- 劣势
查询效率较低,不能随机访问
应用
链表的应用也非常广泛,比如树、图、
Redis
的列表、
LRU
算法实现、消息队列等
数组与链表的对比
数据结构没有绝对的好与坏,数组和链表各有千秋。
![](https://i-blog.csdnimg.cn/direct/27d020e12a6040709d91e55d80b2d5a1.png)
数组的优势在于能够快速定位元素,对于读操作多、写操作少的场景来说,用数组更合适一些
链表的优势在于能够灵活地进行插入和删除操作,如果需要在尾部频繁插入、删除元素,用链表更合适 一些
数组和链表是线性数据存储的物理存储结构:即顺序存储和链式存储。