线性表（
Linear List
）就是数据排成像一条线一样的结构，数据只有前后两个方向
1 数组
概念
数组（
Array
）是
有限
个
相同类型
的变量所组成的
有序
集合，数组中的每一个变量被称为元素。数组是最为简单、最为常用的数据结构。
数组下标从零开始
(Why)
存储原理
数组用一组
连续的内存空间
来存储一组具有
相同类型
的数据
(
模拟内存存储
)
灰色格子：被使用的内存
橙色格子：空闲的内存
红色格子：数组占用的内存
数组可以根据下标随机访问数据
比如一个整型数据
int[]
长度为
5
假设首地址是：
1000
int
是
4
字节（
32
位）
,
实际内存存储是位
随机元素寻址
a[i]_address=a[0]_address+i*4
该公式解释了三个方面
- 连续性分配
- 相同的类型
- 下标从0开始
操作
- 读取元素
根据下标读取元素的方式叫作随机读取
int n=nums[2]- 更新元素
nums[3]= 10;
注意不要数组越界
读取和更新都可以随机访问，时间复杂度为O(1)
- 插入元素
有三种情况：
尾部插入
在数据的实际元素数量小于数组长度的情况下：
直接把插入的元素放在数组尾部的空闲位置即可，等同于更新元素的操作
a[6]=10
中间插入
在数据的实际元素数量小于数组长度的情况下：
由于数组的每一个元素都有其固定下标，所以首先把插入位置及后面的元素向后移动，
腾出地方，再把要插入的元素放到对应的数组位置上。
超范围插入
假如现在有一个数组，已经装满了元素，这时还想插入一个新元素，或者插入位置是越界的
这时就要对原数组进行扩容：可以创建一个新数组，长度是旧数组的
2
倍，再把旧数组中的元素 统统复制 过去，这样就实现了数组的扩容。
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
Node{
int data;
Node next;
}- 双向链表
双向链表的每一个节点除了拥有
data
和
next
指针，还拥有指向前置节点的
prev
指针。
Node{
int data;
Node next;
Node prev;
}- 循环链表
链表的尾节点指向头节点形成一个环，称为循环链表
存储原理
数组在内存中的存储方式是顺序存储（连续存储），链表在内存中的存储方式则是随机存储（链式存储）。
链表的每一个节点分布在内存的不同位置，依靠
next
指针关联起来。这样可以灵活有效地利用零散的碎片空间。
链表的第
1
个节点被称为头节点（3），没有任何节点的
next
指针指向它，或者说它的前置节点为空
头结点用来记录链表的基地址。有了它，我们就可以遍历得到整条链表
链表的最后
1
个节点被称为尾节点（2），它指向的
next
为空
操作
- 查找节点
在查找元素时，链表只能从头节点开始向后一个一个节点逐一查找。
- 更新节点
找到要更新的节点，然后把旧数据替换成新数据
- 插入节点
尾部插入
把最后一个节点的
next
指针指向新插入的节点即可
头部插入
第
1
步，把新节点的
next
指针指向原先的头节点
第
2
步，把新节点变为链表的头节点
中间插入
第
1
步，新节点的
next
指针，指向插入位置的节点
第
2
步，插入位置前置节点的
next
指针，指向新节点
只要内存空间允许，能够插入链表的元素是无限的，不需要像数组那样考虑扩容的问题
- 删除节点
尾部删除
把倒数第
2
个节点的next指针指向空即可
头部删除
把链表的头节点设为原先头节点的
next
指针即可
中间删除
把要删除节点的前置节点的
next
指针，指向要删除元素的下一个节点即可
完整代码
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
算法实现、消息队列等
数组与链表的对比
数据结构没有绝对的好与坏，数组和链表各有千秋。
数组的优势在于能够快速定位元素，对于读操作多、写操作少的场景来说，用数组更合适一些
链表的优势在于能够灵活地进行插入和删除操作，如果需要在尾部频繁插入、删除元素，用链表更合适 一些
数组和链表是线性数据存储的物理存储结构：即顺序存储和链式存储。
扫一扫
364
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
