《恋上数据结构第1季》单向链表、双向链表

最新推荐文章于 2023-07-01 17:58:00 发布
最新推荐文章于 2023-07-01 17:58:00 发布
阅读量3.7k 收藏 9
点赞数 15
分类专栏： # 《恋上数据结构》 文章标签： 链表 数据结构 java 单向链表 双向链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43734095/article/details/104609375
版权

链表（Linked List）

数据结构与算法笔记目录：《恋上数据结构》 笔记目录

想加深 Java 基础推荐看这个： Java 强化笔记目录

动态数组有个明显的缺点：

  • 可能会造成内存空间的大量浪费。

能否用到多少就申请多少内存？

  • 链表可以办到这一点

链表是一种链式存储的线性表，所有元素的内存地址不一定是连续的;

在这里插入图片描述

链表的接口设计

在这里插入图片描述
由于链表的大部分接口和动态数组一致，我们抽取出一个共同的 List 接口；

package com.mj;

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);
}

再将一些通用的字段与方法放到一个抽象类中，无论是动态数组还是链表都只需要继承这个抽象类即可。

package com.mj;

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);
	}

}

单向链表（SingleLinkedList）

单向链表的结构如下图所示：
在这里插入图片描述

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;
		}
	}
	
}

获取元素 – get()

@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;
}

清空元素 – clear()

在这里插入图片描述

  • next 不需要设置为 null，因为 first 指向了 null，后面的 Node 没有被指向，在 Java 中会自动被垃圾回收。
@Override
public void clear() {
	size = 0;
	first = null;
}

添加元素 – add(int index, E element)

在这里插入图片描述
添加元素尤其要注意 0 位置，给空链表添加第一个节点是个特殊情况：

@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++;
}

删除元素 – remove(int index)

在这里插入图片描述

@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;
}

单向链表完整源码

package com.mj.single;

import com.mj.AbstractList;

/**
 * 单向链表
 * @author yusael
 */
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;
		}
	}

	/**
	 * 根据索引找到节点对象
	 */
	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 E get(int index) {
		/*
		 * 最好:O(1)
		 * 最坏:O(n)
		 * 平均:O(n)
		 */
		return node(index).element;
	}

	@Override
	public E set(int index, E element) {
		/*
		 * 最好:O(1)
		 * 最坏:O(n)
		 * 平均:O(n)
		 */
		E old = node(index).element;
		node(index).element = element;
		return old;
	}

	@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;
	}

	@Override
	public int indexOf(E element) {
		// 有个注意点, 如果传入元素为null, 则不能调用equals方法, 否则会空指针
		// 因此需要对元素是否为null做分别处理
		if (element == null) {
			Node<E> node = first;
			for (int i = 0; i < size; i++) {
				if (node.element == null) 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;
	}

	@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();
	}

}

带虚拟头结点的单向链表

有时候为了让代码更加精简，统一所有节点的处理逻辑，可以在最前面增加一个虚拟的头结点（不存储数据）。
在这里插入图片描述
带虚拟头结点的单向链表与普通单向链表代码类似：但是 add、reomove 略有不同；

package com.mj.single;

import com.mj.AbstractList;

/**
 * 增加一个虚拟头结点
 * @author yusael
 */
public class SingleLinkedList2<E> extends AbstractList<E> {

	private Node<E> first;

	//**********************************
	public SingleLinkedList2() { // 初始化一个虚拟头结点
		first = new Node<>(null, null);
	};
	//**********************************

	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 void clear() {
		size = 0;
		first = 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);
		Node<E> prev = (index == 0) ? first : node(index - 1);
		prev.next = new Node<>(element, prev.next);
		size++;
	}

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

		Node<E> prev = (index == 0) ? first : node(index - 1);
		Node<E> node = prev.next;
		prev.next = node.next;

		size--;
		return prev.element;
	}

	@Override
	public int indexOf(E element) {
		// 有个注意点, 如果传入元素为null, 则不能调用equals方法, 否则会空指针
		// 因此需要对元素是否为null做分别处理
		if (element == null) {
			Node<E> node = first;
			for (int i = 0; i < size; i++) {
				if (node.element == null) 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;
	}
	
	/**
	 * 根据索引找到节点
	 * 
	 * @param index
	 * @return
	 */
	private Node<E> node(int index) {
		rangeCheck(index);
		Node<E> node = first.next;
		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.next;
		for (int i = 0; i < size; i++) {
			if (i != 0) {
				string.append(", ");
			}
			string.append(node.element);
			node = node.next;
		}
		string.append("]");
		return string.toString();
	}

}

动态数组、链表复杂度分析

数组的随机访问速度非常快：elements[n] 的效率与 n 是多少无关；
在这里插入图片描述

双向链表（LinkedList）

双向链表可以提升链表的综合性能；
在这里插入图片描述
双向链表只有一个元素的情况：first、last 指向同一个节点
在这里插入图片描述

/**
 * 双向链表
 * @author yusael
 */
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 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();
		}
	}
}

双向链表 – get(int index)

@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;
	}
}

双向链表 – add(int index, E element)

在这里插入图片描述

@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++;
}

双向链表 – remove(int index)

在这里插入图片描述

@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.mj;

import com.mj.AbstractList;

/**
 * 双向链表
 * @author yusael
 */
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 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();
		}
	}
	
	@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) {
		Node<E> node = node(index);
		E old = node.element;
		node.element = element;
		return old;
	}

	@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;
	}

	@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;
	}

	/**
	 * 根据索引找到节点
	 * 
	 * @param index
	 * @return
	 */
	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 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);
			node = node.next;
		}
		string.append("]");
		return string.toString();
	}

}

双向链表 vs 单向链表

粗略对比一下删除的操作数量：操作数量缩减了近一半
在这里插入图片描述
有了双向链表，单向链表是否就没有任何用处了？

  • 并非如此，在哈希表的设计中就用到了单链表
  • 至于原因，在哈希表章节中会讲到

双向链表 vs 动态数组

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

  • 如果频繁在尾部进行添加、删除操作，动态数组、双向链表均可选择
  • 如果频繁在头部进行添加、删除操作，建议选择使用双向链表
  • 如果有频繁的 （在任意位置）添加、删除操作，建议选择使用双向链表
  • 如果有频繁的查询操作（随机访问操作），建议选择使用动态数组

练习题

练习 – 删除链表中的节点

237_删除链表中的节点：https://leetcode-cn.com/problems/delete-node-in-a-linked-list/
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public void deleteNode(ListNode node) {
        node.val = node.next.val;
        node.next = node.next.next;
    }
}

练习 – 反转一个链表（递归、非递归解法）

206_反转链表：https://leetcode-cn.com/problems/reverse-linked-list/
在这里插入图片描述
递归解法：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
    	if(head == null) return null; // 空链表
    	if(head.next == null) return head; // 只有一个节点
    	ListNode newHead = reverseList(head.next);
    	head.next.next = head; // newHead->1->2->3->4->5->null
    	head.next = null;
    	return newHead;
    }
}

非递归解法 - 头插法：
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode newHead = null;
        while (head != null) {
            ListNode tmp = head.next;
            head.next = newHead;
            newHead = head;
            head = tmp;
        }
        return newHead;
    }
}

练习 – 判断一个链表是否有环（快慢指针）

141_环形链表：https://leetcode-cn.com/problems/linked-list-cycle/
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
快慢指针解法：
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head == null || head.next == null) return false;
        ListNode slow = head;
        ListNode fast = head.next; // 快指针每次都比慢指针快一步(包括开始)
        while (fast != null && fast.next != null) {
            if (slow.val == fast.val) return true;
            slow = slow.next;
            fast = fast.next.next;
        }
        return false;
    }
}
萌宅鹿同学
关注
  • 15
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
小码哥《恋上数据结构与算法》笔记（三）：双向链表
Guizy
04-09 488
具体代码在 LinkedList , 欢迎 star 目录 一、双向链表（LinkedList） 二、双向链表接口设计 三、双向链表的实现 1、构造方法 2、查找结点 3、清空结点 4、插入结点 (重点) 5、删除结点 6、测试双向链表 六、双向链表和动态数组比较 一、双向链表 跳转到目录 单向链表只能通过Node中next属性从头遍历链表，完成搜索。 双向链表中的Node增加p...
数据结构笔记：单向链表
12-22
原文地址 分类目录——数据结构笔记 离散存储，手拉手，每一块有指向下一块的指针（形象描述，python中没有指针），就好像形成了一条链 一个元素包括两部分：value 和 next 链表与顺序表都是线性表 知识点补充 b = 20 a = 'achar' a = b # 在python中，所有的变量保存的都是值的地址（就相当于c语言中的指针） # 等号右边表示执行，=b中的b就是执行，根据值的地址取到b的值，就成了a=20，而这时的操作，是把20的地址返给a；也因此，在python中，之前给a的字符串变量可以在之后换成int的变量，这次其他语言中是不能实现的。 # 等号实质上是改变了数据指向
【Java数据结构与算法】双向链表
12-21
双向链表 单向链表的缺点分析 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找 单向链表不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除，所以前面删除单向链表节点时，需要找到temp的下一个节点来删除 如若未了解单链表请参考–>单链表点这里 双向链表示意图如下： 分析双向链表的遍历，添加，修改，删除的操作思路 遍历方式和单向链表一样，只是可以向前，也可以向后查找 添加（默认添加到双向链表的最后） 先找到双线链表的最后节点 temp.next指向新的节点，temp.next=newHeroNode newHerNOde.pre=temp; 修改思路和单向链表一样 删除
[Python]数据结构--链表
Festinatione facit vastum
01-11 589
[Python]数据结构–链表 ‘Festinatione facit vastum’ 链表的概念 单链表的实现 循环单链表的实现 链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另
【数据结构】——单链表的基本操作（带头结点）
weixin_51398574的博客
07-01 3834
1.在单链表的定义中不能省略结构体名称LNode（第2行中）。原因：在该结构体内部使用到了该结构体类型去定义next指针域。2.第5行中的重命名LNode和*LinkList的意义：//将结构体重命名为LNode//将结构体的指针重命名为LinkList。
恋上数据结构之【常见的数据结构、List集合及其子类、Set集合及其子类】
派拉斯兔子的博客
07-06 298
第一章 数据结构 1.1 数据结构有什么用？ 当你用着java里面的容器类很爽的时候，你有没有想过，怎么ArrayList就像一个无限扩充的数组，也好像链表之类的。好用吗？好用，这就是数据结构的用处，只不过你在不知不觉中使用了。 现实世界的存储，我们使用的工具和建模。每种数据结构有自己的优点和缺点，想想如果Google的数据用的是数组的存储，我们还能方便地查询到所需要的数据吗？而算法，在这么多的数据中如何做到最快的插入，查找，删除，也是在追求更快。 我们java是面向对象的语言，就好似自动档轿车，C语言好似
《恋上数据结构第1季》单向循环链表、双向循环链表以及约瑟夫环问题
萌宅鹿的技术小屋
03-04 1654
双向链表List.java 接口AbstractList.java双向链表 LinkedList.java双向循环链表 CircleLinkedList.java双向循环链表解决约瑟夫环问题 List.java 接口 public interface List<E> { static final int ELEMENT_NOT_FOUND = -1; /** * 清除所有元素 ...
恋上数据结构完整笔记（第1季 + 第2季）
热门推荐
萌宅鹿的技术小屋
03-13 2万+
Java 数据结构目录 整理一下。。。 【动态扩容数组】动态扩容数组 ArrayList实现源码（Java、C++） 【链表List】单向链表 SingleLinkedList、双向链表 LinkedList 实现源码 【循环链表CircleList】单向循环链表、双向循环链表以及约瑟夫环问题 【队列Queue】队列 Queue、双端队列 DeQueue、循环队列 CircleQueue、双端循环...
【恋上数据结构】 双向链表(JDK-LinkedList底层)
Javaer
12-29 585
恋上数据结构——双向链表的实现，gitee同步更新。
数据结构与算法:单向链表实现与封装
08-26
今天小编就为大家分享一篇关于数据结构与算法:单向链表实现与封装，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
python数据结构链表之单向链表(实例讲解)
01-21
单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。 表元素域elem用来存放具体...
【恋上数据结构与算法 第一季】链表LinkedList
Keep Reading Keep Writing Keep Thinking
08-20 163
持续学习&持续更新中… 学习态度：脚踏实地 链表单向链表双向链表图示单向链表图示单向循环链表图示双向链表图示双向循环链表接口设计List接口AbstractList 抽象类代码实现单向链表单向循环链表双向链表双向循环链表动态数组、链表复杂度分析复杂度分析—双向链表双向链表 vs 单向链表双向链表 vs 动态数组约瑟夫问题拓展虚拟头结点静态链表动态数组能否进一步优化注意参考 单向链表 双向链表 图示单向链表 只有一个元素的情况： 图示单向循环链表 只有一个元素的情况： 图示双向链表 .
恋上数据结构与算法第一季笔记（一）——单链表、双向链表、单向循环链表
JohnnyLin
04-25 141
链表 链表设计 接口设计 LinkedList 类 构造方法和头结点 /** * 头结点 */ private Node<E> head; /** * 构造方法 * @param <E> */ private static class Node<E>{ E element; Node<E> next; public N
《恋上数据结构第1季》动态扩容数组原理及实现
萌宅鹿的技术小屋
03-01 5500
动态扩容数组接口设计Java实现int型动态数组Java实现泛型动态数组Java实现泛型动态数组优化C++实现动态数组 接口设计 int size(); // 元素的数量 boolean isEmpty(); // 是否为空 boolean contains (E element); // 是否包含某个元素 void add (E element); // 添加元素到最后面 E get (int...
【恋上数据结构】排序算法前置知识及代码环境准备
萌宅鹿的技术小屋
03-26 3727
排序准备工作何为排序？何为稳定性？何为原地算法？时间复杂度的知识写排序算法前的准备项目结构Sort.javaAsserts.javaIntegers.javaTimes.javaStudent.java排序算法测试BubbleSort1.javaMain.java 感谢小码哥的恋上数据结构，记录课程笔记。 建议先看一下这篇博客： 复杂度知识以及LeetCode刷题指南。 何为排序？ 排序前：3...
【恋上数据结构】复杂度知识以及LeetCode刷题指南
萌宅鹿的技术小屋
03-26 3691
基础知识什么是算法？如何评判一个算法的好坏？大O表示法（Big O）对数阶的细节常见的复杂度多个数据规模的情况LeetCode刷题指南斐波那契数列复杂度分析斐波那契数列-递归斐波那契数列-循环fib函数的时间复杂度分析斐波那契的线性代数解法-特征方程算法的优化方向 什么是算法？ 算法是用于解决特定问题的一系列的执行步骤。 以下算法是为了解决两数相加的问题。 // 计算a和b的和 public st...
《恋上数据结构第1季》二叉树基础、真二叉树、满二叉树、完全二叉树、二叉树的遍历（重点）
萌宅鹿的技术小屋
05-04 3076
二叉树树（Tree）的基本概念有序树、无序树、森林二叉树（Binary Tree）二叉树的性质真二叉树（Proper Binary Tree）满二叉树（Full Binary Tree）完全二叉树（Complete Binary Tree）面试题（完全二叉树）二叉树的遍历 + 练习题前序遍历（Preorder Traversal）中序遍历（Inorder Traversal）后序遍历（Postor...
《恋上数据结构第1季》二叉树代码实现
萌宅鹿的技术小屋
05-06 2315
二叉树BinaryTree 基础遍历（先序、中序、后序、层次遍历）先序遍历: preorder()中序遍历: inorder()后序遍历: postorder()层次遍历: levelOrder()求二叉树的高度: height()递归实现迭代实现是否为完全二叉树: isComplaete()求二叉树的节点前驱节点: predecessor()后继节点: successor()BinaryTree...
广工数据结构第二章+双向链表
最新发布
10-20
广工数据结构第二章主要介绍了线性表的顺序存储和链式存储两种方式，以及它们的实现和应用。其中，链式存储包括单向链表、双向链表和循环链表三种形式。 双向链表是一种常见的链式存储结构，它与单向链表相比，每个节点除了指向后继节点的指针外，还有指向前驱节点的指针。这样可以方便地实现双向遍历和在任意位置插入或删除节点等操作。 在双向链表中，每个节点包含三个部分：数据域、指向前驱节点的指针和指向后继节点的指针。头节点不存储数据，只是为了方便操作而存在。双向链表的插入和删除操作需要修改前驱节点和后继节点的指针，因此需要注意指针的顺序和细节。 双向链表的优点是可以方便地实现双向遍历和在任意位置插入或删除节点等操作，缺点是需要额外的空间存储前驱节点的指针，同时插入和删除操作需要修改两个指针，比较繁琐。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

萌宅鹿同学

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值