数据结构与算法之单链表

最新推荐文章于 2024-08-12 20:31:35 发布
最新推荐文章于 2024-08-12 20:31:35 发布
阅读量491 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/admin_lian/article/details/104574038
版权

目录

(一) 单链表

1.定义

链表是一种物理存储结构上非连续，非顺序的线性数据存储结构，数据元素的逻辑顺序是通过链表中的节点(Node)链接次序实现的。每个链表中都包含两部分: 存储的数据 和 下一个节点(Node).

class Node{
	private E e; // 存储的数据
	private Node next; // 下一个节点
}

在之前的博客中实现的动态数组、栈以及队列时，底层都是依托的静态数组，靠resize来解决固定容量的问题, 而链表是真正的动态数据结构, 无需处理固定容量问题.

2. 图解
  • 数据存储在节点(Node)中, 当一个节点(next)为NULL时, 代表此元素为链表的最后一个元素
    在这里插入图片描述
  • 链表插入元素
    在这里插入图片描述
  • 链表删除元素
    -在这里插入图片描述
3.数组和链表的对比
  • 数组静态分配内存, 链表动态分配内存.
  • 数组在内存中是连续的，链表是不连续的。
  • 数组利用索引定位，查找的时间复杂度是O(1)，链表通过遍历定位元素，查找的时间复杂度是O(N)。
  • 数组插入和删除需要移动其他元素，时间复杂度是O(N)，链表的插入或删除不需要移动其他元素，时间复杂度是O(1)。

(二) 自定义链表LinkedList

1. 新建自定义链表实体类LinkedList
public class LinkedList<E> {

	/**
	 * 节点内部类: 可以单独定义出来, 但用户无需关注链表底层实现, 因此定义成LinkedList的内部类
	 * 
	 * @author Admin_Lian
	 *
	 */
	private class Node {
		/**
		 * 存储的数据
		 */
		public E e;
		
		/**
		 * 下一个节点
		 */
		public Node next;
		
		public Node() {
			this(null, null);
		}
		
		public Node(E e) {
			this(e, null);
		}
		
		public Node(E e, Node next) {
			this.e = e;
			this.next = next;
		}
		
		@Override
		public String toString() {
			return e.toString();
		}
	}
	
	/**
	 * 头部节点: 链表第一元素 
	 */
	private Node head;
	
	/**
	 * 链表元素个数
	 */
	private int size;
	
	public LinkedList() {
		head = null;
		size = 0;
	}
	
	/**
	 * 获取链表中元素的个数
	 * 
	 * @return
	 */
	public int getSize() {
		return size;
	}
	
	/**
	 * 返回链表是否为空
	 * 
	 * @return
	 */
	public boolean isEmpty() {
		return size == 0;
	}
}
2. 自定义链表的增加操作
  • 在链表头部添加新元素e
public void addFirst(E e) {
	// 创建一个新头节点
	Node headNode = new Node(e);
	// 新头节点的下一节点next 等于 当前链表的头节点
	headNode.next = this.head;
	// 当前链表的头节点 等于 新头节点
	this.head = headNode;
	
	// 第二种写法
	// this.head = new Node(e, this.head);
	size++;
}
  • 在链表index位置处添加新元素e
public void add(int index, E e) {
	if(index < 0 || index > size) {
		throw new IllegalArgumentException("add(index, e) failed. Illegal index.");
	}
	// index == 0, 相当于在链表头部添加新元素, 但index == 0 没有上一个节点. 因此需要单独处理(待优化)
	if (index == 0) {
		addFirst(e);
	} else {
		// 查询要添加元素的前一个节点, 因此查询index-1位置处的节点
		Node prev = this.head;
		for (int i = 0; i < index - 1; i++) {
			prev = prev.next;
		}
		Node node = new Node(e);
		// 新添加的节点next 指向 index-1位置处的节点
		node.next = prev.next;
		// index-1位置处的节点next 指向 新添加的节点
		prev.next = node;
		
		// prev.next = new Node(e, prev.next);
		size++;
	}
}
  • 在链表末尾添加新元素e
public void addLast(E e) {
	add(size, e);
}
3. 为自定义链表设置一个虚拟的节点
  • 为链表设置一个虚拟的节点: 在add(idnex, e)操作, 也能找到上一个节点, 无需多余的判断. 初始链表时dummyHead, 存储的数据为Null, 下一个节点next也为Null.
    在这里插入图片描述
    优化自定义链表LinkedList
/**
 * 虚拟头部节点: 存储的数据为Null, 下一个节点next也为Null
 */
private Node dummyHead;

/**
 * 链表元素个数
 */
private int size;

public LinkedList() {
	dummyHead = new Node(null, null);
	size = 0;
}


// ....


/**
*  在链表index位置处添加新元素e: 新添加一个虚拟节点, 因此index=0时, 也能找到上一个节点
 * 
 * @param index
 * @param e
 */
public void add(int index, E e) {
	if (index < 0 || index > size) {
		throw new IllegalArgumentException("add(index, e) failed. Illegal index.");
	}
	
	// 查询要添加元素的前一个节点, 因为新添加一个虚拟节点, 所以查询index位置处的节点
	Node prev = this.dummyHead;
	for (int i = 0; i < index; i++) {
		prev = prev.next;
	}
	Node node = new Node(e);
	// 新添加的节点next 指向 index-1位置处的节点
	node.next = prev.next;
	// index-1位置处的节点next 指向 新添加的节点
	prev.next = node;
	
	// prev.next = new Node(e, prev.next);
	size++;
}

/**
 * 在链表头部添加新元素e
 * 
 * @param e
 */
public void addFirst(E e) {
	add(0, e);
}
4. 自定义链表的查询操作
  • 获取链表的第index位置处的元素
publicE get(int index) {
	if (isEmpty()) {
		throw new IllegalArgumentException("add(index, e) failed. LinkedList is empty.");
	}
	if (index < 0 || index > size) {
		throw new IllegalArgumentException("add(index, e) failed. Illegal index.");
	}
	// 获取当前真正第一个元素的节点
	Node cur = this.dummyHead.next;
	for (int i = 0; i < index; i++) {
		cur = cur.next;
	}
	return cur.e;
}
  • 获取链表第一个元素 和 获取链表最后一个元素
/**
 * 获取链表第一个元素
 * @return
 */
public E getFirst() {
	return get(0);
}

/**
 * 获取链表最后一个元素
 * 
 * @return
 */
public E getLast() {
	return get(size - 1);
}
5. 自定义链表的修改操作
  • 修改链表第index位置的元素为e
public void set(int index, E e) {
	if (index < 0 || index > size) {
		throw new IllegalArgumentException("add(index, e) failed. Illegal index.");
	}
	Node cur = this.dummyHead.next;
	for (int i = 0; i < index; i++) {
		cur = cur.next;
	}
	cur.e = e;
}
  • 删除链表第index位置的元素
public E remove(int index) {
	if (index < 0 || index > size) {
		throw new IllegalArgumentException("remove(index, e) failed. Illegal index.");
	}

	// 查找删除元素的上一个节点
	Node prev = this.dummyHead;
	for (int i = 0; i < index; i++) {
		prev = prev.next;
	}

	// index处的节点
	Node resNode = prev.next;

	// 上一个节点的next 等于 index处的节点next
	prev.next = resNode.next;
	resNode.next = null;
	size--;
	return resNode.e;
}
6. 自定义链表的删除操作
  • 删除链表第一个的元素 和 删除链表最后一个的元素
/**
 * 删除链表第一个的元素
 * 
 * @return
 */
public E removeFirst() {
	return remove(0);
}

/**
 * 删除链表最后一个的元素
 * 
 * @return
 */
public E removeLast() {
	return remove(size - 1);
}
  • 查找链表种是否存在e
public boolean contains(E e) {
	Node cur = this.dummyHead.next;
	// 链表最后一个元素节点的next 一定为 null
	while(cur != null) {
		if (cur.e.equals(e)) {
			return true;
		}
		cur = cur.next;
	}
	return false;
}
  • 覆盖重写toString()方法
@Override
public String toString() {
	StringBuilder res = new StringBuilder();
	res.append("LinkedList: ");
	for (Node cur = this.dummyHead.next; cur != null; cur = cur.next) {
		res.append(cur.e + " -> ");
	}
	res.append("NULL");
	return res.toString();
}

测试

public static void main(String[] args) {
	LinkedList<Integer> linkedList = new LinkedList<>();
	for (int i = 0; i < 5; i++) {
		linkedList.addFirst(i);
		System.out.println(linkedList);
	}
	
	linkedList.add(2, -1);
	System.out.println(linkedList);
	
	linkedList.set(2, -2);
	System.out.println(linkedList);
	
	linkedList.remove(2);
	System.out.println(linkedList);
}

在这里插入图片描述

(三) 时间复杂度分析

  • 添加操作: 整体时间复杂度为 O(n)
函数时间复杂度分析
addLast(e)O(n)链表尾部添加元素, 需要遍历链表, 与数据规模呈线性关系
addFirst(e)O(1)链表头部添加, 只需要改变虚拟节点的next指向, 此操作消耗的时间与数据规模无关系的, 在常数时间内完成
add(index, e)O(n/2) = O(n)消耗的时间与index的取值有关,范围是 O(1)–O(n), 涉及到概率论知识.平均取值n/2, 2是常数省略
总结:O(n)添加操作整体时间复杂度为 O(n), 分析时间复杂度一般考虑最坏的情况
  • 删除操作: 整体时间复杂度为 O(n)
函数时间复杂度分析
removeLast(e)O(n)删除链表尾部元素, 需要遍历链表, 与数据规模呈线性关系
removeFirst(e)O(1)删除链表头部元素, 只需要改变虚拟节点的next指向, 此操作消耗的时间与数据规模无关系的, 在常数时间内完成
remove(index, e)O(n/2) = O(n)消耗的时间与index的取值有关,范围是 O(1)–O(n), 涉及到概率论知识.平均取值n/2, 2是常数省略
总结:O(n)删除操作整体时间复杂度为 O(n)
  • 查询操作: 复杂度为 O(n)
函数时间复杂度分析
get(index)O(n)需要遍历链表, 与数据规模呈线性关系
contain(e)O(n)需要遍历链表, 与数据规模呈线性关系
总结:O(n)复杂度为 O(n)
  • 修改操作: 时间复杂度为 O(n)
函数时间复杂度分析
set(index, e)O(n)需要遍历链表, 与数据规模呈线性关系
总结:O(n)修改操作整体时间复杂度为 O(n)

(四) 使用链表实现栈

/**
 * 自定义链表栈
 * 
 * @author Admin_Lian
 *
 * @param <E>
 */
public class LinkedListStack<E> implements Stack<E> {

	// 底层采用链表存储数据结构
	private LinkedList<E> linkedList;
	
	public LinkedListStack() {
		linkedList = new LinkedList<>();
	}
	
	/**
	 * 获取栈中的有效元素个数
	 * 
	 * @return
	 */
	@Override
	public int getSize() {
		return linkedList.getSize();
	}

	/**
	 * 返回栈中有效元素是否为空
	 * 
	 * @return
	 */
	@Override
	public boolean isEmpty() {
		return linkedList.isEmpty();
	}

	/**
	 * 向栈(栈顶)中添加元素
	 * 
	 * @param e
	 */
	@Override
	public void push(E e) {
		linkedList.addFirst(e);
	}

	/**
	 * 从栈(栈顶)中取出元素
	 * 
	 * @return
	 */
	@Override
	public E pop() {
		return linkedList.removeFirst();
	}

	/**
	 * 查看栈顶元素
	 * 
	 * @return
	 */
	@Override
	public E peek() {
		return linkedList.getFirst();
	}
	
	@Override
	public String toString() {
		StringBuilder res = new StringBuilder();
		res.append("Stack: top ");
		res.append(linkedList);
		return res.toString();
	}

}

测试

public static void main(String[] args) {
	LinkedListStack<Integer> stack = new LinkedListStack<>();
	for (int i = 0; i < 5; i++) {
		stack.push(i);
		System.out.println(stack);
	}
	
	stack.pop();
	System.out.println(stack);
}

在这里插入图片描述

(五) 使用链表实现队列

借用head头指针和tail尾指针实现队列
在这里插入图片描述

/**
 * 自定义链表队列
 * 
 * @author Admin_Lian
 *
 */
public class LinkedListQueue<E> implements Queue<E>{

	/**
	 * 节点内部类: 可以单独定义出来, 但用户无需关注链表底层实现, 因此定义成LinkedList的内部类
	 * 
	 * @author Admin_Lian
	 *
	 */
	private class Node {
		/**
		 * 存储的数据
		 */
		public E e;

		/**
		 * 下一个节点
		 */
		public Node next;

		@SuppressWarnings("unused")
		public Node() {
			this(null, null);
		}

		public Node(E e) {
			this(e, null);
		}

		public Node(E e, Node next) {
			this.e = e;
			this.next = next;
		}

		@Override
		public String toString() {
			return e.toString();
		}
	}

	/**
	 *  头部节点: 链表第一个元素 
	 */
	private Node head;
	
	/**
	 * 尾部节点: 链表最后一个元素
	 */
	private Node tail;
	
	/**
	 * 链表队列元素个数
	 */
	private int size;
	
	public LinkedListQueue() {
		this.head = null;
		this.tail = null;
		this.size = 0;
	}
	
	/**
	 * 获取链表队列中元素的个数
	 * 
	 */
	@Override
	public int getSize() {
		return size;
	}

	/**
	 * 返回链表队列是否为空
	 */
	@Override
	public boolean isEmpty() {
		return size == 0;
	}
	
	/**
	 * 入队: 向链表队列(队尾)中添加元素
	 */
	@Override
	public void enqueue(E e) {
		// 链表队列为空
		if (this.tail == null) {
			// 尾节点 等于 要添加元素节点
			this.tail = new Node(e);
			// 头节点 等于 尾节点
			this.head = this.tail; 
		} else {
			// 尾部节点的next 等于 要添加元素节点
			this.tail.next = new Node(e);
			// 尾部节点 等于 尾部节点的next
			this.tail = this.tail.next;
		}
		size++;
	}

	/**
	 * 出队: 从链表队列(队首)中取出一个元素
	 * 
	 * @return
	 */
	@Override
	public E dequeue() {
		if (this.tail == null) {
			throw new IllegalArgumentException("dequeue() failed. LikedListQueue is empty."); 
		}
		Node resNode = this.head;
		// 新头节点 等于 要出队的节点的next 
		this.head = resNode.next;
		resNode.next = null;
		// 链表队列只存在一个元素, 且要出队
		if (this.head == null) {
			this.tail = null;
		}
		size--;
		return resNode.e;
	}

	/**
	 * 查看链表队列队首元素
	 * 
	 * @return
	 */
	@Override
	public E getFront() {
		if (isEmpty()) {
			throw new IllegalArgumentException("getFront() failed. LikedListQueue is empty."); 
		}
		return this.head.e;
	}
	
	@Override
	public String toString() {
		StringBuilder res = new StringBuilder();
		res.append("LinkedListQueue: front ");
		
//		Node node = this.head;
//		for (int i = 0; i < size; i++) {
//			res.append(node.e + " -> ");
//			node = node.next;
//		}
		
//		Node node = this.head;
//		while (node != null) {
//			res.append(node.e + " -> ");
//			node = node.next;
//		}
		
		for (Node node = this.head; node != null; node = node.next) {
			res.append(node.e + " -> ");
		}
		
		res.append("NUll tail");
		return res.toString();
	}

}

测试

public static void main(String[] args) {
	LinkedListQueue<Integer> queue = new LinkedListQueue<>();
	// 向队列中添加元素: 0-9
	for (int i = 0; i < 10; i++) {
		queue.enqueue(i);
		System.out.println(queue);
		
		// 每添加三个元素, 移除队列队首元素
		if(i % 3 == 2) {
			queue.dequeue();
			System.out.println(queue);
		}
	}
}

在这里插入图片描述

又十七
关注
专栏目录
数据结构与算法之单链表的增删查改
07-03
总结，单链表是理解和掌握数据结构与算法的基础，熟练运用增删查改操作对于编写高效代码至关重要。在实际应用中，根据具体需求选择合适的数据结构和操作方法，能有效提升程序的性能。通过不断实践和学习，你可以更好...
2020-08-26
m0_49295337的博客
08-26 265
c语言79 一般给定程序中,已建立一一个带有头结点的单向链表 ,链表中的各结点包含数据域(data)和指针域(next) ,数据域为整型。函数fum的作用 是:找出链表各结点数据域中的最大值, 其最大值由函数值返回。 ...
设单链表的数据为互不相等的整数，建立一个单链表，并设计一个算法,找出单链表中元素值最大的结点。
南岛鹋
03-31 3007
设单链表的数据为互不相等的整数，建立一个单 链表，并设计一个算法,找出单链表中元素值最大 的结点。 要求： （1）单链表的数据从键盘输入； （2）输出单链表所有结点的数据和最大值结点序号。 #include "iostream" using namespace std; #include "malloc.h" #include "stdio.h" #define N 10 typedef int ...
数据结构与算法（三）——单链表
最新发布
weixin_67660500的博客
08-12 613
链表是由一系列结点组成的，每个节点包含两域，一个是数据域，用来保存用户数据，另外一个是指针域，保存下一个节点的地址且在内存中是非连续的存储模式。是链表中的附着在首元结点之前的节点数据域存储当前链表特性（长度），指向链表的第一个结点（这里我们可以理解为数组的首地址元素，但不能混淆），链表中的最后一个结点的指针部分为NULL,表示链表的结束。②降低了磁盘数据的存储密度，容易产生碎片（磁盘碎片是指文件在磁盘上的不连续存储，这会导致空闲空间的浪费和访问性能的下降），碎片会影响磁盘的存储效率和性能。
设 L 为单链表的头结点地址，其数据结点的数据都是正整数且无相同的，试设计利用直接插入的原则把该链表整理成数据递增的有序单链表的算法。
thq_kuqi的博客
10-21 508
【代码】设 L 为单链表的头结点地址，其数据结点的数据都是正整数且无相同的，试设计利用直接插入的原则把该链表整理成数据递增的有序单链表的算法。
数据结构线性表之单链表（C语言）
zcx0913的博客
03-24 1606
数据结构线性表之单链表（C语言） C语言中链表是精华所在，最近遇到两道个人感觉不错的单链表的题，由于目前只会C,所以只能用C来做。 先放题： 1. 已知一个带头结点的单链表 L，设计算法实现：以表中第一个元素作为标准， 将单链表中所有值小于第一个元素的结点均放在第一个元素结点之前，所有值大 于第一个元素的结点均放在第一个元素结点之后（请使用函数设计）。 // 单链表中节点的结构体类型定义 … typedef struct LNode { int data; // 数据 ... struct LNode
数据结构和算法-单链表
weixin_49429082的博客
12-05 194
单链表及其应用
【Java数据结构与算法】单链表
12-21
【Java数据结构与算法】单链表 单链表是一种基本的数据结构，它在计算机科学中扮演着重要的角色。链表是由一系列节点构成的，每个节点包含两部分：data域用于存储数据，以及next域用于指向下一个节点。与数组不同，...
java数据结构与算法.pdf
01-04
在编程领域，数据结构与算法是核心组成部分，它们直接影响到程序的效率和性能。Java作为广泛应用的编程语言，其在实现数据结构和算法时有着丰富的库支持和优秀的可读性。下面将对标题和描述中提到的一些关键知识点...
数据结构与算法-单链表的排序
04-21
数据结构与算法-单链表的排序
恋上数据结构与算法课件.rar
11-23
数据结构与算法是计算机科学的基础，对于理解和设计高效的软件至关重要。本课程的资源"恋上数据结构与算法课件.rar"涵盖了多个核心概念，旨在...爱数据结构与算法，就立即行动，打开这个压缩包，开始你的学习之旅吧！
【王道数据结构编程题】- 链表算法题
m0_56051805的博客
06-20 4370
王道代码题具体实现，可以运行，19. 设有一个带头结点的循环单链表，其结点值均为正整数。设计一个算法，反复找出单链表中结点值最小的结点并输出，然后将该结点从中删除，直到单链表空为止，再删除表头结点。20.设头指针为L的带有表头结点的非循环双向链表，其每个结点中除有pred(前驱指针)、data (数据)和next (后继指针)域外，还有一个访问频度域freq。在链表被启用前，其值均初始化为零。每当在链表中进行一-次Locate(L,x)运算时，令元素值为x的结点中freq域的值增1,并使此链表中结点保持按访
[Python]数据结构--链表
Festinatione facit vastum
01-11 683
[Python]数据结构–链表 ‘Festinatione facit vastum’ 链表的概念 单链表的实现 循环单链表的实现 链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另
数据结构与算法——单链表
WXH0722的博客
07-17 415
文章目录 1.单链表的性质及其优、缺点 2.不带头节点的链表的插入删除操作 3.带头节点的单链表 4.不带头节点的链表的基础操作： (1)插入（头插法与尾插法） (2)删除 (3)链表的逆置 (4)获取链表倒数第K个节点的值 (5)判断链表是否有环 (6)合并两个有序链表 1.单链表的性质及其优、缺点 性质： 1.链表是以节点的方式来存储的 2.每个节点包含data域和next域 3.链表的各个节...
四、数据结构与算法 （二）单向链表 删除
sunweihao2019的博客
03-01 534
项目地址：在SingleLinkedListDemo模块 1.代码 1.删除代码 public void delete(int no) { //判断队列是否为空 if (head.next==null) { System.out.println("队列为空，无法删除"); return; } HeroNode temp = head.next;
数据结构单链表线性表创建插入查找显示判断是否为空删除C语言描述算法
c673929079的博客
03-22 1753
未命名数据结构单链表线性表创建插入查找显示判断是否为空删除C语言描述算法
【数据结构与算法】深入理解 单链表
2302_78391795的博客
05-07 1371
单链表是一种基本的线性数据结构，它通过链式存储方式而非连续的内存位置来存储元素。（逻辑上连续，物理上不一定连续）在单链表中，每个元素（或称为节点）包含两部分：数据域和指针域。 数据域用于存储实际的数据，而指针域则存储指向下一个节点的地址。 这样，每个节点都链接到列表中的下一个节点，形成一个链条。 本篇文章要介绍的是无头结点，单向，不循环链表，即通常我们所熟知单链表，以下如无特殊说明，均代表此含义。
数据结构与算法-单链表
nameofworld的博客
05-01 896
本文包括单链表的添加删除修改链表（Linked List）链表是有序列表，但在内存中存储情况如下比如这里的头指针是150，我们就找到地址为150的这行，即data域是a1，它的next域是110，那么就指向地址为110的这行，它的data域是a2，next域是180，那么就指向地址为180的这行，data域是a3.以此类推。它的每个节点并不是连续存储的。就是地址不是连续的。
数据结构与算法：单链表创建与练习解析
"完善算法-数据结构习题" 在数据结构的学习中，算法的设计和实现是至关重要的。这里给出的题目是关于单链表的创建，这是数据结构中的基本操作。首先，我们来看一下单链表的节点定义： ```c typedef struct ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值