数据结构复习整理-02链表

最新推荐文章于 2024-05-17 23:32:03 发布
最新推荐文章于 2024-05-17 23:32:03 发布
阅读量52 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/g678678/article/details/115138069
版权

链表

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点组成，每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

链表接口

package com.gc;
public interface List<E> {
	static final int ELEMENT_NOT_FOUND = -1;
	/**
	 * 清除所有元素
	 */
	void clear();

	/**
	 * 元素的数量
	 * @return
	 */
	int size();

	/**
	 * 是否为空
	 * @return
	 */
	boolean isEmpty();

	/**
	 * 是否包含某个元素
	 * @param element
	 * @return
	 */
	boolean contains(E element);

	/**
	 * 添加元素到尾部
	 * @param element
	 */
	void add(E element);

	/**
	 * 获取index位置的元素
	 * @param index
	 * @return
	 */
	E get(int index);

	/**
	 * 设置index位置的元素
	 * @param index
	 * @param element
	 * @return 原来的元素ֵ
	 */
	E set(int index, E element);

	/**
	 * 在index位置插入一个元素
	 * @param index
	 * @param element
	 */
	void add(int index, E element);

	/**
	 * 删除index位置的元素
	 * @param index
	 * @return
	 */
	E remove(int index);

	/**
	 * 查看元素的索引
	 * @param element
	 * @return
	 */
	int indexOf(E element);
}
//继承数组

public abstract class AbstractList<E> implements List<E>{
	
	protected int size;
	
	// 下标越界抛出的异常
	protected void outOfBounds(int index) {
		throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
	}
	// 检查下标越界(不可访问或删除size位置)
	protected void rangeCheck(int index){
		if(index < 0 || index >= size){
			outOfBounds(index);
		}
	}
	// 检查add()的下标越界(可以在size位置添加元素)
	protected void rangeCheckForAdd(int index) {
		if (index < 0 || index > size) {
			outOfBounds(index);
		}
	}
	
	@Override
	public boolean contains(E element) {
		return indexOf(element)!=ELEMENT_NOT_FOUND;
	}
	
	@Override
	public int size() {
		return size;
	}

	@Override
	public boolean isEmpty() {
		return size == 0;
	}
	
	@Override
	public void add(E element) {
		add(size, element);
	}

}

单链表

public class SingleLinkedList<E> extends AbstractList<E> {

	private Node<E> first;

	// 链表中的节点
	private static class Node<E> {
		E element; // 节点元素
		Node<E> next; // 节点指向下一个节点

		public Node(E element, Node<E> next) {
			this.element = element;
			this.next = next;
		}
	}
}

获取元素

@Override
public E get(int index) {
	return node(index).element;
}
/**
 * 根据索引找到节点
 */
private Node<E> node(int index) {
	rangeCheck(index);
	Node<E> node = first;
	for (int i = 0; i < index; i++) {
		node = node.next;
	}
	return node;
}

清空元素

@Override
public void clear() {
	size = 0;
	first = null;
}

添加元素

@Override
public void add(int index, E element) {
	/*
	* 最好：O(1)
	* 最坏：O(n)
	* 平均：O(n)
	*/
	rangeCheckForAdd(index);
	if(index == 0){ // 给空链表添加第一个元素的情况
		first = new Node<>(element, first);
	}else{
	   //指向上一个节点
		Node<E> prev = node(index - 1);
		prev.next = new Node<>(element, prev.next);
	}
	size++;
}

删除元素

@Override
public E remove(int index) {
	/*
	* 最好：O(1)
	* 最坏：O(n)
	* 平均：O(n)
	*/
	rangeCheck(index);
	Node<E> node = first;
	if (index == 0) { // 删除第一个元素是特殊情况
		first = first.next;
	} else {
		Node<E> prev = node(index - 1); // 找到前一个元素
		node = prev.next; // 要删除的元素
		prev.next = node.next; // 删除元素
	}
	size--;
	return node.element;
}

双向链表

public class LinkedList<E> extends AbstractList<E> {

	private Node<E> first;
	private Node<E> last;

	private static class Node<E> {
		E element;
		Node<E> prev;
		Node<E> next;

		public Node(Node<E> prev, E element, Node<E> next) {
			this.prev = prev;
			this.element = element;
			this.next = next;
		}

@Override
public E get(int index) {
	return node(index).element;
}
/**
 * 根据索引找到节点
 */
private Node<E> node(int index) {
	rangeCheck(index);
	
	if (index < (size >> 1)) { // 索引小于一半从前往后找
		Node<E> node = first;
		for (int i = 0; i < index; i++) {
			node = node.next;
		}
		return node;
	} else { // 索引大于一半从后往前找
		Node<E> node = last;
		for (int i = size - 1; i > index; i--) {
			node = node.prev;
		}
		return node;
	}
}

//添加元素
@Override
public void add(int index, E element) {
	rangeCheckForAdd(index);

	// size == 0
	// index == 0
	if (index == size) { // 往最后面添加元素
		Node<E> oldLast = last;
		last = new Node<>(oldLast, element, null);
		if (oldLast == null) { // 这是链表添加的第一个元素
			first = last;
		} else {
			oldLast.next = last;
		}
	} else { // 正常添加元素
		Node<E> next = node(index);
		Node<E> prev = next.prev;
		Node<E> node = new Node<>(prev, element, next);
		next.prev = node;
		if (prev == null) { // index == 0
			first = node;
		} else {
			prev.next = node;
		}
	}
	size++;
}

//删除结点

@Override
public E remove(int index) {
	rangeCheck(index);

	Node<E> node = node(index);
	Node<E> prev = node.prev;
	Node<E> next = node.next;
	
	//删除第一个结点
	if (prev == null) { // index == 0
		first = next;
	} else {
		prev.next = next;
	}
	//删除最后一个结点
	if (next == null) { // index == size - 1
		last = prev;
	} else {
		next.prev = prev;
	}
	size--;
	return node.element;
}

注

动态数组：开辟、销毁内存空间的次数相对较少，但可能造成内存空间浪费（可以通过缩容解决）
双向链表：开辟、销毁内存空间的次数相对较多，但不会造成内存空间的浪费

尾部进行添加、删除操作动态数组、双向链表
头部进行添加、删除操作双向链表
频繁查询动态数组
任意位置添加、删除双向链表

单向循环链表

package com.gc.circle;

import com.gc.AbstractList;

/**
 * 单向循环链表
 */
public class SingleCircleLinkedList<E> extends AbstractList<E> {

	private Node<E> first;
	
	private static class Node<E> {
		E element;
		Node<E> next;

		public Node(E element, Node<E> next) {
			this.element = element;
			this.next = next;
		}

		@Override
		/**
   		* 打印单向循环链表
 		*/
		public String toString() {
			StringBuilder sb = new StringBuilder();
			sb.append(element).append("_").append(next.element);
			return sb.toString();
		}
	}

			
/**
  	* 清除链表
	*/
	@Override
	public void clear() {
		size = 0;
		first = null;
	}
//获取索引结点元素
	@Override
	public E get(int index) {
		return node(index).element;
	}
//替换结点
	@Override
	public E set(int index, E element) {
		Node<E> node = node(index);
		E old = node.element;
		node.element = element;
		return old;
	}
//添加元素
	@Override
	public void add(int index, E element) {
		rangeCheckForAdd(index);
		
		if (index == 0) {
			Node<E> newFirst = new Node<>(element, first);
	
			Node<E> last = (size == 0) ? newFirst : node(size - 1);
			last.next = newFirst;
			first = newFirst;
		} else {
			Node<E> prev = node(index - 1);
			prev.next = new Node<>(element, prev.next);
		}
		size++;
	}

	@Override
	public E remove(int index) {
		rangeCheck(index);

		Node<E> node = first;
		if (index == 0) {
			if (size == 1) {
				first = null;
			} else {
				Node<E> last = node(size - 1);
				first = first.next;
				last.next = first;
			}
		} else {
			Node<E> prev = node(index - 1);
			node = prev.next;
			prev.next = node.next;
		}
		size--;
		return node.element;
	}

	@Override
	public int indexOf(E element) {
		if (element == null) {
			Node<E> node = first;
			for (int i = 0; i < size; i++) {
				if (node.element == element) return i;
				node = node.next;
			}
		} else {
			Node<E> node = first;
			for (int i = 0; i < size; i++) {
				if (node.element.equals(element)) return i;
				node = node.next;
			}
		}
		return ELEMENT_NOT_FOUND;
	}

	/**
	 * 根据索引找到节点
	 */
	private Node<E> node(int index) {
		rangeCheck(index);
		Node<E> node = first;
		for (int i = 0; i < index; i++) {
			node = node.next;
		}
		return node;
	}

	@Override
	public String toString() {
		StringBuilder string = new StringBuilder();
		string.append("[size=").append(size).append(", ");
		Node<E> node = first;
		for (int i = 0; i < size; i++) {
			if (i != 0) {
				string.append(", ");
			}
			string.append(node.element);
			node = node.next;
		}
		string.append("]");
		return string.toString();
	}

}

双向循环链表

package com.gc.circle;

import com.gc.AbstractList;

/**
 * 双向循环链表
 */
public class CircleLinkedList<E> extends AbstractList<E> {

	private Node<E> first;
	private Node<E> last;
	// 指针访问当前节点
	private Node<E> current; 

	private static class Node<E> {
		E element;
		Node<E> prev;
		Node<E> next;

		public Node(Node<E> prev, E element, Node<E> next) {
			this.prev = prev;
			this.element = element;
			this.next = next;
		}

		@Override
		public String toString() {
			StringBuilder sb = new StringBuilder();
			if (prev != null) {
				sb.append(prev.element);
			} else {
				sb.append("null");
			}
			sb.append("_").append(element).append("_");
			if (next != null) {
				sb.append(next.element);
			} else {
				sb.append("null");
			}

			return sb.toString();
		}
	}

	public void reset() {
		current = first;
	}

	public E next() {
		if (current == null) return null;
		current = current.next;
		return current.element;
	}

	/**
	 * 删除 current 当前节点
	 */
	public E remove() {
		if (current == null) return null;
		Node<E> next = current.next;
		E element = remove(current);
		if(size == 0){
			current = null;
		}else{
			current = next;
		}
		return element;
	}

	@Override
	public void clear() {
		size = 0;
		first = null;
		last = null;
	}

	@Override
	public E get(int index) {
		return node(index).element;
	}

	@Override
	public E set(int index, E element) {
		E old = node(index).element;
		node(index).element = element;
		return old;
	}

	@Override
	public void add(int index, E element) {
		rangeCheckForAdd(index);

		if (index == size) { // 往最后面添加元素
			Node<E> oldLast = last;
			last = new Node<>(oldLast, element, first);
			if (oldLast == null) { // 这是链表添加的第一个元素
				first = last;
				first.next = first;
				first.prev = first;
			} else {
				oldLast.next = last;
				first.prev = last;
			}
		} else { // 正常添加元素
			Node<E> next = node(index);
			Node<E> prev = next.prev;
			Node<E> node = new Node<>(prev, element, next);
			next.prev = node;
			prev.next = node;
			if (next == first) { // index==0
				first = node;
			}
		}
		size++;
	}

	@Override
	public E remove(int index) {
		rangeCheck(index);
		return remove(node(index));
	}

	public E remove(Node<E> node) {
		if (size == 1) {
			first = null;
			last = null;
		} else {
			Node<E> prev = node.prev;
			Node<E> next = node.next;
			prev.next = next;
			next.prev = prev;

			if (node == first) { // index == 0
				first = next;
			}

			if (node == last) { // index == size - 1
				last = prev;
			}
		}
		size--;
		return node.element;
	}

	@Override
	public int indexOf(E element) {
		if (element == null) {
			Node<E> node = first;
			for (int i = 0; i < size; i++) {
				if (node.element == element)
					return i;
				node = node.next;
			}
		} else {
			Node<E> node = first;
			for (int i = 0; i < size; i++) {
				if (node.element.equals(element))
					return i;
				node = node.next;
			}
		}
		return ELEMENT_NOT_FOUND;
	}

	/**
	 * 根据索引找到节点
	 */
	private Node<E> node(int index) {
		rangeCheck(index);

		if (index < (size >> 1)) { // 索引小于一半从前往后找
			Node<E> node = first;
			for (int i = 0; i < index; i++) {
				node = node.next;
			}
			return node;
		} else { // 索引大于一半从后往前找
			Node<E> node = last;
			for (int i = size - 1; i > index; i--) {
				node = node.prev;
			}
			return node;
		}
	}

}
语胡言胡
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
题目整理(链表).pdf
08-26
整理的常考的链表题目知识点做了整理算法附代码并导出为pdf版本,做复习用，内容包数据结构中链表部分常考的的题目
数据结构考试提纲（已整理）
07-14
数据结构复习提纲，内含数据结构定义，时间复杂度，线性表，链表，树的考试知识，推荐用于考试复习与数据结构入门学习
数据结构复习整理-02单链表
g678678的博客
03-23 65
链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点组成，每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 链表接口 package com.gc; public interface List<E> { static final int ELEMENT_NOT_FOUND = -1; /** * 清除所有元素 */ void clear(); /** * 元素的数量
数据结构- 环形链表以及约瑟夫问题
qq_53568186的博客
09-10 96
本文是单向循环链表以及约瑟夫环的学习笔记
数据结构整理-链表篇
m0_73469299的博客
03-21 308
链表中插入节点很简单，例如如果在n0与n1之间插入节点新节点T，只需要T的”引用“改为n1，把n0的”引用“改为T，即可。上图中链表的组成单位是节点，节点包含”节点的值“和”下一节点的引用【指针】“，链表节点除了节点的值外还包含下一节点的引用，所以同样数据量的情况下，链表比数组占用更多的内存空间，有两种初始化链表的方法，第一种使用节点指针初始化链表（更常用），第二种使用节点对象初始化链表（不常用）。节点之间通过”引用“相连接，”引用“记录了下一个节点的内存地址，可实现从当前节点访问到下一节点。
数据结构之链表复习
2401_84048671的博客
04-21 595
head=cur;三、返回链表的中间节点定义快慢指针，注意偶数节点和奇数节点的情况注意判断条件 在偶数情况下 如果是判断fast.next.next就会空指针异常，必须把判断条件两个都加上。//定义快慢指针 快指针比慢指针多走一步 注意奇数和偶数情况if(headnull){while(fast!=null){四、删除链表的倒数第K个节点定义快慢指针 快指针先走n-1步 之后慢指针再走,修改地址值即可i
数据结构期末复习--考研知识点
m0_51247882的博客
11-09 368
第一单元 数据与数据结构 数据抽象和抽象数据类型 算法分析的基本方法 第二单元 单向链表 带表头结点的链表 单向循环链表 双向循环链表 各种鬼畜的链表 第三单元 栈 队列 单调栈，单调队列 第四单元 树和森林 哈夫曼和哈夫曼编码 图 第五单元 图的存储 图的遍历 最小生成树 最短路径 AOE和AOV 第六单元 二分查找 二分搜索树及平衡二叉树 B树 B+树 散列表 第七单元 插入排序 冒泡排序 快速排序 希尔排序 计数排序 还有很多没整理出来的，今天先整理这么多 ...
面试数据结构之---链表
不忘初心，方得始终
10-22 650
面试精选：链表问题集锦 文章目录 1. 在O(1)时间删除链表节点2. 单链表的转置3. 求链表倒数第k个节点4. 求链表的中间节点5. 判断单链表是否存在环6. 找到环的入口点7. 编程判断两个链表是否相交8. 扩展：链表有环，如何判断相交9. 扩展：两链表相交的第一个公共节点10. 总结参考文献 链表问题在面试过程中也是很重要也很基础的一部分，链表本身很灵活，很考查编程功
数据结构整理-哈希表篇
m0_73469299的博客
03-28 1793
哈希表又称散列表，通过键值映射，key-value。可实现高效的元素查询。即向哈希表输入一个键key，就可以在O(1)的时间内查找到value。除了哈希表之外，数组和链表也可以实现查询功能，时间复杂度之间的关系如下：发现哈希表的效率是真滴高！1.哈希表的常见操作初始化、查询、添加键值对、删除键值对等哈希表的遍历方式有：遍历键值对、遍历键、遍历值。2.哈希表的实现仅用一个数组实现哈希表，将数组的每个空位成为桶。
数据结构-链表
樱桃的博客
09-04 134
链表(Linked List) 在刷题的时候顺便把涉及到知识复习整理到博客,慢慢把本地的笔记转移到博客上来 介绍 链表是有序的列表 链表是以节点的方式来存储,是链式存储 每个节点包含 data域 next域:指向下一个节点 链表的各个节点不一定是连续存储 链表分带头节点和没有头节点的链表 添加节点 创建一个head头节点,表示单链表的头 后面每增加一个节点,直接加到链表的最后 将节点插入到指定位置 (1). 借助辅助变量(temp;指针)通过遍历找到新的节点位置 (2). 新的节点.next
数据结构整理-栈篇
m0_73469299的博客
03-22 274
将数组的尾部作为栈顶。入栈和出栈分别对应数组尾部的添加和删除元素。由于栈可能会不断的增加，可以使用动态数组实现，这样就不用自己处理数组的扩容问题。对于入栈操作，只需要将元素插入链表头部，这种节点插入方法被称为“头插法”。栈是一种先入先出逻辑的线性结构。栈的实现有两种方式，一种是基于链表的实现，一种基于数组的实现。然而，某些语言可能没有专门提供栈类，这时我们可以将该语言的。此时，链表的头节点是作为栈顶，链表的尾节点作为栈底。当作栈来使用，并在程序逻辑上忽略与栈无关的操作。ii：基于数组的实现。
数据结构---链表（java实现）
Enl0ve的博客
07-02 8714
近来越来越感觉数据结构和算法的重要性，于是决定花时间整理一下数据结构，一来希望自己能够更加深刻地理解数据结构，二来也希望和大家认真分享一下自己的理解，希望能够一起学习，一起进步，开心每一天。今天先复习一下数据结构中比较常见的链表。本文以图示方法和代码演示详细地对链表及相关演变的链表做一个详细的讲解。希望看到这边文章的各位博友能够评论一下，哪怕是发个“已读”也好，感觉这样才有讨论的学习氛围。单链表这...
数据结构复习题（自己整理）
12-13
数据结构 一、单项选择题 1.对一个算法的评价，不包括如下（ ）方面的内容。 A．健壮性和可读性 B．并行性 C．正确性 D．时空复杂度 2.一个栈的输入序列为1 2 3，则下列序列中不可能是栈的输出序列的是( ) A. 2 3 1 ...
algorithm-collation:剑指offer中经典算法题整理，以及相关数据结构复习
05-20
最近在复习数据结构的相关知识，涉及栈、队列、二叉树和哈希表等，现整理部分算法题及对应JS编程代码附上。 3.3 第一题：如何判断B树是A树的子结构？ 3.4 第二题：查找两个链表的第一个公共交点？ 3.5 第三题：输入...
数据结构实验
04-13
2．掌握对二叉树每种操作的具体实现，学会利用递归方法编写对二叉树这种递归数据结构进行处理的算法。 二 、实验要求 1．认真阅读和掌握和本实验相关的教材内容。 2．编写完整程序完成下面的实验内容并上机运行。 3...
数据结构 | 详解栈实现队列&队列实现栈
最新发布
mooridy的博客
05-17 327
step2：此时非空队列中剩下的唯一一个数就是“栈顶”元素，使用QueueFront进行·取值后，直接进行QueuePop删除。step0.先利用假设法假定非空队列notempty和空队列empty，再利用MyStackEmpty函数对进行修正。step1:将notempty队列中的前size-1个元素依次push到empty队列中，再进行删除，实现移动操作。
USB3.0接口——（2）数据结构
dkmknjk的博客
05-14 1064
在 USB 3.0 及更高版本的 xHCI 协议中，"Rings"、"Transfer Request Block (TRB)" 和 "Transfer Descriptor (TD)" 是用于管理 USB 数据传输和事件的重要概念。
「探索数据结构：了解顺序表」
2301_80321602的博客
05-17 528
顺序表是一种线性表的存储结构，它是由一组物理地址连续的存储单元（通常是数组）依次存储线性表中的元素。顺序表中的元素在内存中是连续存储的，通过元素在数组中的下标来访问和操作元素。顺序表的优点是访问元素的时间复杂度为O(1)，即可以通过下标直接访问元素，操作效率高；缺点是插入和删除元素时需要移动其他元素，时间复杂度为O(n)，效率较低。首先，我们需要定义动态顺序表的数据类型SLDataType和结构体SeqList。动态顺序表使用数组arr存储数据，size表示当前有效数据个数，capacity。
“ 树 ” 的概念
2401_82669797的博客
05-14 688
通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址。树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。：若一个结点含有子结点，则这个结点称为其子结点的父结点；：以某结点为根的子树中任一结点都称为该结点的子孙。：一个结点含有的子树的根结点称为该结点的子结点；具有相同父结点的结点互称为兄弟结点；：一个结点含有的子树的个数称为该结点的度；：从根开始定义起，根为第1层，根的子结点为第2层，以此类推；
考研数据结构代码整理
09-09
很抱歉，我无法提供具体的考研数据结构代码整理。考研数据结构的代码整理是一个相对复杂的过程，涉及到多种数据结构和算法的实现。为了更好地应对考研数据结构的编程题目，建议你学习和掌握常见的数据结构，如数组、链表、栈、队列、树、图等，并学会它们的基本操作和常见算法。此外，在考前刷题并进行练习，加深对数据结构的理解和应用。还可以参考一些经典的考研复习资料和教材，如《数据结构与算法分析》、《算法设计与分析》等，这些书籍中通常会提供一些代码范例和习题供你学习和实践。最重要的是多动手编写代码，通过实践来提升自己的编程能力。祝你考研顺利！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值