线性表的构成形式-数组（顺序结构）与链表（链式结构）

最新推荐文章于 2023-07-20 20:15:23 发布

云计算小菜鸟

最新推荐文章于 2023-07-20 20:15:23 发布

阅读量797

点赞数

分类专栏：数据结构与算法分析文章标签：数组

本文链接：https://blog.csdn.net/weixin_41724265/article/details/104461702

版权

数据结构与算法分析专栏收录该内容

12 篇文章 1 订阅

订阅专栏

1.线性表与非线性表

线性表以实现方式分为顺序结构（数组）和链式结构（链表）。
这里的线性是指的逻辑上的线性，即只要数据的保存满足了一对一关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接没有例外；就可以说这是一个线性表，而非线性表参考图、数，往往数据间的关系是一对多、多对一等。

2.数组

数组（Array）是一种线性表数据结构。它用一组连续的内存空间，来存储一组具有相同类型的数据。
好的，这里存在着三个关键词，线性表、连续内存空间、以及相同类型数据。我们一个个看。
线性表我们前面已经说过了，现在来看看连续内存空间以及相同类型数据：正是因为这两个限制，它才有了一个堪称“杀手锏”的特性：“随机访问”。但有利就有弊，这两个限制也让数组的很多操作变得非常低效，比如要想在数组中删除、插入一个数据，为了保证连续性，就需要做大量的数据搬移工作。
当计算机需要随机访问数组中的某个元素时，它会首先通过下面的寻址公式，计算出该元素存储的内存地址：

a[i]_address=base_address+i*data_type_size

具体实现：

public class Array<E>{//数组底层实现
	private E[] data;
	private int size;
	public Array(int capacity){
		data=(E[])new Object[capacity];
		size=0;
	}
	public Array(){//无参数构造函数，默认容量为10
		this(10);
	}
	private void resize(int newcapacity){
		E[] newdata=(E[])new Object[newcapacity];
		for(int i=0;i<size;i++){
			newdata[i]=data[i];
		}
		data=newdata;
	}
	public void insertElem(int index,E value){//增
		if(index<0||index>size){
			throw new IllegalArgumentException("越界!");
		}
		//Java的arrayList动态扩充为1.5倍
		if(size==data.length){
			resize(2*data.length);
		}
		for(int i=size;i>index;i--){
			data[i]=data[i-1];
		}
		data[index]=value;
		size++;
	}
	public E deleteElem(int index){//删
		if(index<0||index>size){
			throw new IllegalArgumentException("越界!");
		}
		E a=data[index];
		for(int i=index;i<size-1;i++){
			data[i]=data[i+1];
		}
		size--;
		return a;
	}
	public void updateElem(int index,E value){//改
		data[index]=value;
	}
	public E getElem(int index){//查
		if(index<0||index>size){
			throw new IllegalArgumentException("越界!");
		}
		return data[index];
	}
}

2.1 警惕数组的访问越界

int main(int argc,char *argv[]){
	int i=0;
	int arr[3]={0};
	for(;i<=3;i++){
		arr[i]=0;
		printf("hello world\n");
	}
	return 0;
}

你发现问题了吗？这段代码的运行结果并非是打印三行“hello word”，而是会无限打印“hello world”，这是为什么呢？
因为，数组大小为 3，a[0]，a[1]，a[2]，而我们的代码因为书写错误，导致 for 循环的结束条件错写为了 i<=3 而非 i<3，所以当 i=3 时，数组 a[3]访问越界。
我们知道，在 C 语言中，只要不是访问受限的内存，所有的内存空间都是可以自由访问的。根据我们前面讲的数组寻址公式，**a[3]也会被定位到某块不属于数组的内存地址上，而这个地址正好是存储变量 i 的内存地址，**那么 a[3]=0 就相当于 i=0，所以就会导致代码无限循环。
但并非所有的语言都像 C 一样，把数组越界检查的工作丢给程序员来做，像 Java 本身就会做越界检查，比如下面这几行 Java 代码，就会抛出 java.lang.ArrayIndexOutOfBoundsException。

int[] a=new int[3];
a[3]=10;

2.2 容器是否能完全替代数组？
针对数组类型，很多语言都提供了容器类，最常见的就是Java中的ArrayList。在项目开发中，什么时候适合用数组，什么时候适合用容器呢？
这里我拿 Java 语言来举例。如果你是 Java 工程师，几乎天天都在用 ArrayList，对它应该非常熟悉。那它与数组相比，到底有哪些优势呢？
我个人觉得，ArrayList 最大的优势就是可以将很多数组操作的细节封装起来。比如前面提到的数组插入、删除数据时需要搬移其他数据等。另外，它还有一个优势，就是支持动态扩容。
数组本身在定义的时候需要预先指定大小，因为需要分配连续的内存空间。如果我们申请了大小为 10 的数组，当第 11 个数据需要存储到数组中时，我们就需要重新分配一块更大的空间，将原来的数据复制过去，然后再将新的数据插入。
如果使用 ArrayList，我们就完全不需要关心底层的扩容逻辑，ArrayList 已经帮我们实现好了。每次存储空间不够的时候，它都会将空间自动扩容为 1.5 倍大小。不过，这里需要注意一点，因为扩容操作涉及内存申请和数据搬移，是比较耗时的。所以，如果事先能确定需要存储的数据大小，最好在创建 ArrayList 的时候事先指定数据大小。
但是
1.ArrayList可以存储异构对象，而Array只能存储相同数据类型的数据。
2.Java ArrayList 无法存储基本类型，比如 int、long，需要封装为 Integer、Long 类，而 Autoboxing、Unboxing 则有一定的性能消耗，所以如果特别关注性能，或者希望使用基本类型，就可以选用数组。
3. 如果数据大小事先已知，并且对数据的操作非常简单，用不到 ArrayList 提供的大部分方法，也可以直接使用数组。

2.3为什么很多编程语言中数组都是从0开始编号的
从数组存储的内存模型上来看，“下标”最确切的定义应该是“偏移（offset）”。前面也讲到，如果用 a 来表示数组的首地址，a[0]就是偏移为 0 的位置，也就是首地址，a[k]就表示偏移 k 个 type_size 的位置，所以计算 a[k]的内存地址只需要用这个公式：

a[k]_address = base_address + k * type_size

但是，如果数组从 1 开始计数，那我们计算数组元素 a[k]的内存地址就会变为：

a[k]_address = base_address + (k-1)*type_size

对比两个公式，我们不难发现，从 1 开始编号，每次随机访问数组元素都多了一次减法运算，对于 CPU 来说，就是多了一次减法指令。
数组作为非常基础的数据结构，通过下标随机访问数组元素又是其非常基础的编程操作，效率的优化就要尽可能做到极致。所以为了减少一次减法操作，数组选择了从 0 开始编号，而不是从 1 开始。

3.链表

链表和数组有什么区别呢？从图中我们看到，数组需要一块连续的内存空间来存储，对内存的要求比较高。如果我们申请一个 100MB 大小的数组，当内存中没有连续的、足够大的存储空间时，即便内存的剩余总可用空间大于 100MB，仍然会申请失败。而链表恰恰相反，它并不需要一块连续的内存空间，它通过“指针”将一组零散的内存块串联起来使用，所以如果我们申请的是 100MB 大小的链表，根本不会有问题。
链表结构五花八门，今天我重点给你介绍三种最常见的链表结构，它们分别是：单链表、双向链表和循环链表。我们首先来看最简单、最常用的单链表。
3.1 单链表
我们主要看插入和删除操作。

3.1.1 插入结点操作

插入操作是将值为x的新节点插入到单链表的第i个位置上。
在这里插入图片描述
实现插入结点的代码片段如下：

p=GetElem(L,i-1);
s->next=p->next;
p->next=s;

其中，语句23不能颠倒，否则会产生指针覆盖的问题。
本算法的主要时间开销在于查找第i-1个元素，时间复杂度为O(n)。若是在给定的结点后面插入新结点，则时间复杂度仅为O(1)。

3.1.2 删除结点操作

在这里插入图片描述
实现删除结点的代码片段如下：

p=GetElem(L,i-1);
q=p->next;
p=>next=q->next;
free(q);

和插入算法一样，该算法的主要时间也是耗费在查找操作上，时间复杂度为 O(n)。
具体实现：

class Node{//单链表结点
	public Node next;
	public int data;
	public Node(int data){
		this.data=data;
	}
}
public class LinkList {//单链表
	public Node head;
	public int length=0;
	public Boolean addNode(int index,int data){//增
		if(index<1||index>length){
			return false;
		}
		Node x=new Node(data);
		Node p=head;
		int i=1;
		while(i<index-1){
			p=p.next;
			i++;
		}
		x.next=p.next;
		p.next=x;
		length++;
		return true;
	}
	public Boolean deleteNode(int index){//删
		if(index<1||index>length){
			return false;
		}
		Node p=head;
		int i=1;
		while(i<index-1){
			p=p.next;
			i++;
		}
		Node x=p.next;//x为要删除的结点
		p.next=x.next;
		length--;
		return true;
	}
	public Boolean updateNode(int index,int data){//改
		if(index<1||index>length){
			return false;
		}
		int i=1;
		Node p=head;
		while(i<index){
			p=p.next;
			i++;
		}
		p.data=data;
		return true;
	}
	public int getNode(int index){//查
		if(index<1||index>length){
			throw new IllegalArgumentException("越界!");
		}
		Node p=head;
		int i=1;
		while(i<index){
			p=p.next;
			i++;
		}
		return p.data;
	}
}

3.2 双链表

3.2.1 插入结点操作

在这里插入图片描述
实现插入结点的代码片段如下：

s->next=p->next;
p->next->prior=s;
s->prior=p;
p->next=s;

3.2.2 删除结点操作

在这里插入图片描述
实现删除结点的代码片段如下：

p->next=q->next;
q->next->prior=p;
free(q);

具体实现：

class Node{//双链表结点
	public Node prior;
	public Node next;
	public int data;
	public Node(int data){
		this.data=data;
	}
}
public class LinkList2{//双链表
	public Node head;
	public int length=0;
	public Boolean addNode(int index,int data){//增
		if(index<1||index>length){
			return false;
		}
		Node x=new Node(data);
		Node p=head;
		int i=1;
		while(i<index-1){
			p=p.next;
			i++;
		}
		x.next=p.next;
		p.next.prior=x;
		x.prior=p;
		p.next=x;
		length++;
		return true;
	}
	public Boolean deleteNode(int index){//删
		if(index<1||index>length){
			return false;
		}
		Node p=head;
		int i=1;
		while(i<index-1){
			p=p.next;
			i++;
		}
		Node x=p.next;//x为要删除的结点
		p.next=x.next;
		x.next.prior=p;
		length--;
		return true;
	}
	public Boolean updateNode(int index,int data){//改
		if(index<1||index>length){
			return false;
		}
		int i=1;
		Node p=head;
		while(i<index){
			p=p.next;
			i++;
		}
		p.data=data;
		return true;
	}
	public int getNode(int index){//查
		if(index<1||index>length){
			throw new IllegalArgumentException("越界!");
		}
		Node p=head;
		int i=1;
		while(i<index){
			p=p.next;
			i++;
		}
		return p.data;
	}
}

3.3 其他链表
3.3.1 循环单链表

当处理的数据具有环形结构特点时，特别适用（比如约瑟夫问题）。
在单链表中只能从表头结点开始往后顺序遍历整个链表，而循环单链表可以从表中的任何一个结点开始遍历整个链表。

3.3.2 循环双链表

3.3.3 静态链表
静态链表是借助数组来描述线性表的链式存储结构，结点也有数据域data以及指针域next，与前面所讲的链表中的指针不同的是，这里的指针是结点的相对地址（数组下标），又称游标。和顺序表一样，静态链表也要预先分配一块连续的内存空间。
静态链表和单链表对应关系如图所示：

在这里插入图片描述
静态链表以next==-1作为其结束的标志。

云计算小菜鸟

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
线性表的构成形式-数组（顺序结构）与链表（链式结构）

什么是数组？数组（Array）是一种线性表数据结构。它用一组连续的内存空间，来存储一组具有相同类型的数据。好的，这里存在着三个关键词，线性表、连续内存空间、以及相同类型数据。我们一个个看。1.线性表线性表以实现方式分为顺序结构（数组）和链式结构（链表）。数组这里的线性是指的逻辑上的线性，即只要数据的保存满足了一对一关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接没有例外；...
复制链接

扫一扫