单链表（Linked List）的clear、add、remove、indexOf以及toString方法的底层封装

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

单链表（Linked List）

  • 定义一个接口List类
public interface List<E> {
	static final int ELEMENT_NOT_FOUND = -1;
	/* 清除所有元素 */
	void clear();

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

	/* 是否为空 */
	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);
}
  • 定义一个AbstractList类继承List接口
public abstract class AbstractList<E> implements List<E>  {
	/* 元素的数量 */
	protected int size;
	/* 元素的数量 */
	public int size() {
		return size;
	}

	/* 是否为空 */
	public boolean isEmpty() {
		 return size == 0;
	}

	/**
	 * 是否包含某个元素
	 * @param element
	 * @return
	 */
	public boolean contains(E element) {
		return indexOf(element) != ELEMENT_NOT_FOUND;
	}

	/* 添加元素到尾部 */
	public void add(E element) {
		add(size, element);
	}
	protected void outOfBounds(int index) {
		throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
	}
	protected void rangeCheck(int index) {
		if (index < 0 || index >= size) {
			outOfBounds(index);
		}
	}
	protected void rangeCheckForAdd(int index) {
		if (index < 0 || index > size) {
			outOfBounds(index);
		}
	}
}
  • 动态数组有个明显的缺点：可能会造成内存空间的大量浪费
  • 而对于链表来说可以解决这个缺点
  • 链表：是一种链式存储的线性表，所有元素的内存地址不一定是连续的
    在这里插入图片描述

链表的设计

在这里插入图片描述

public class LinkedList<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;
		}
	}
}
  • 链表的大部分接口和动态数组是一致的；两者都继承List接口。
（1）清空元素 - clear()
  • LinkedList底层封装clear元素清空
@Override
public void clear() {
	size = 0;
	first = null;
}

因为只需要将first赋值为null，那么就无法指向下一个第一个元素的element，也就无法调取后面的数值；相当于将LinkedList清空。

  • LinkedList底层封装获取index位置对应节点对象
/**
 * 获取index位置对应节点对象
 * @param index
 * @return
 */
private Node<E> node(int index){
	rangeCheck(index);
	Node<E> node = first;
	for (int i = 0; i < index; i++) {
		node = node.next;
	}
	return node;
}
protected void rangeCheck(int index) {
	if (index<0 || index>=size) {
		outBounds(index);
	}
}
（2）set、get节点元素
  • LinkedList底层封装获取节点元素和设置节点元素的值
@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;
}

  • get：通过node(index)方法来获取对应节点对象中的值。

  • set：通过Node<E> node = node(index);来获取index对应节点对象；然后通过node.element来获取节点的值，通过交换的方式给index位置上赋值新的数值。

  • LinkedList底层封装添加元素- add()

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

protected void rangeCheckForAdd(int index) {
    if (index < 0 || index > size) {
        outBounds(index);
    }
}
  • LinkedList底层封装删除元素- remove()
@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;
}
protected void rangeCheck(int index) {
	if (index<0 || index>=size) {
		outBounds(index);
	}
}
  • LinkedList底层封装查看元素的位置- indexOf()
/* 查看元素的位置 */
@Override
public int indexOf(E element) {
	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 (element.equals(node.element)) return i;
			
			node = node.next;
		}
	}
	return -1;
}
  • LinkedList底层封装toString方法
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();
}

练习题1—删除链表中的节点

  • 请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点。传入函数的唯一参数为 要被删除的节点 。
    现有一个链表 – head = [4,5,1,9]，它可以表示为:
    在这里插入图片描述
    来源：力扣（LeetCode）
    链接：https://leetcode-cn.com/problems/delete-node-in-a-linked-list
输入：head = [4,5,1,9], node = 1
输出：[4,5,9]
解释：给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.

提示：
①、链表至少包含两个节点。
②、链表中所有节点的值都是唯一的。
③、给定的节点为非末尾节点并且一定是链表中的一个有效节点。
④、不要从你的函数中返回任何结果。

public class Main {
	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;
	    }
	}
}

解题思路：先找到我们需要删除的节点A，然后找到我们需要删除的节点A的下一个节点B的数值覆盖掉我们要删除的节点A的数值node.val = node.next.val;；覆盖之后，我们需要将删除的节点A的next指向next的next（相当于我们将B节点的数值覆盖掉A节点的值后，A节点的next指向B节点后面C节点）

练习2—反转链表

class ListNode {
    int val;//存放数据
     ListNode next;//用来指向下一个节点
     ListNode(int x) { 
    	 val = x; 
     }
}
class Solution {
    public ListNode reverseList(ListNode head) {
		if (head == null || head.next == null) return head;
    	
    	ListNode newHead = reverseList(head.next);
    	head.next.next = head;
    	head.next = null;
    	
		return newHead;
    }
}
  • 方法二：迭代
class ListNode {
    int val;//存放数据
     ListNode next;//用来指向下一个节点
     ListNode(int x) { 
    	 val = x; 
     }
}
class Solution {
    public ListNode reverseList(ListNode head) {
		if (head == null || head.next == null) return head;
    	
    	ListNode newHead = null;
    	while (head != null) {
    		ListNode tmp = head.next;
        	head.next = newHead;
        	newHead = head;
        	head = tmp;
		}
		return newHead;
    }
}

练习3—环形链表

给定一个链表，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

如果链表中存在环，则返回 true 。 否则，返回 false 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/linked-list-cycle
在这里插入图片描述

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

在这里插入图片描述

输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

在这里插入图片描述

输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

在这里插入图片描述

class ListNode {
    int val;//存放数据
     ListNode next;//用来指向下一个节点
     ListNode(int x) { 
    	 val = x; 
     }
}
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) {
			slow = slow.next;
			fast = fast.next.next;
			
			if (slow == fast) return true;
		}
		return false;
    }
}
bfhonor
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
重写LinkedList toString()方法 两种写法
今天有写了好多新bug
11-06 2479
先写一个自己的LInedList 类 第一种重写toString()方案 每次循环在后面加一个 .next; public class MyLinkedList{ private Node firstNode; //首节点 private Node lastNode; //尾节点 private int size; //元素个数 //定义一个节点类（这...
linked-list:C用于单链表和双链表
05-12
linked-list C for single linked list and double linked list single_list 结点结构体 创建结点 创建链表 显示链表的数据 获取链表长度 插入结点 删除结点 查找链表中指定的数据 修改链表中指定位置结点的值 修改...
LinkedList源码深度剖析
qq_45537774的博客
07-04 163
深入剖析LinkedList源代码，不管是设计原理还是细枝末节，一点也不放过！！！
java带条件的tostring输出,Java 中 linkedList 类的没有按照Object类toString 方法输出
weixin_34357209的博客
03-22 204
Java 中 linkedList 类的 toString() 没什么输出的是一个 return getClass().getName() + “@” + Integer.toHexString(hashCode());，我在它的继承中也没有找到 toString 类的重写你说的这个是Object类的默认实现public String toString() {return getClass().g...
Java LinkedList 自定义双链表功能（高老师java300级第143集笔记）add方法和重写toString
weixin_45293996的博客
06-23 255
一，先定义一个Node类（节点） （高琪老师java300级第143级不懂的同学可以来参考以下，注解详细） 这里要搞清楚一个节点包括三个部分：用于指向上一个节点的“节点头”，节点本身“elemen”（这个是用来存储对象的所以类型为Object），节点尾（next）三个属性。还有链表是怎么连接的。 以下为Node类代码 /**2019-6-23 本类为一个节点类 定义了一个节点包括节点 头（pre...
数据结构34-链表toString方法实现
qq_41632427的博客
12-12 93
前端
LinkedList中的remove方法
热门推荐
93吸血鬼的学习笔记
11-04 1万+
实在是太坑爹了！！！！！jdk7的api里面，他有三个remove方法 return type method Description E remove() Retrieves and removes the head (first element) of this list. E remove(int index) Removes the element at th
Java进阶（7）——手动实现LinkedList & 内部node类的实现 & 增删改查的实现 & toString方法 & 源码的初步理解
最新发布
Perley620的博客，专注后端领域
08-23 1506
1.linkedList的节点，当前，上一个，下一个的思想； 2.根据index找node的方法，根据index确定从头部还是尾部； 3.linkedlist的增删改查的实现，本质是改变节点的信息； 4.递归方法实现自定义链表的toString方法；
java clear_Java中LinkedList clear()的方法 - Break易站
weixin_28997879的博客
02-19 418
Java.util.LinkedList.clear()方法用于从链接列表中删除所有元素。使用clear()方法只会清除列表中的所有元素，而不会删除列表。换句话说，我们可以说clear()方法仅用于清空现有的LinkedList。句法：void clear()参数：该函数不接受任何参数。返回值：此方法不返回任何值。Java.util.LinkedList.clear()方法示例：// Java c...
java linkedlist 删除_Java LinkedList.remove() 删除数据
weixin_33417904的博客
02-12 4123
首页>基础教程>集合框架>LinkedList类Java LinkedList.remove() 删除数据方法remove()：获取并移除此列表的头(第一个元素)。remove(int index)：移除此列表中指定位置处的元素。remove(Objec o)：从此列表中移除首次出现的指定元素(如果存在)。removeFirst()：移除并返回此列表的第一个元素。re...
单链表（Linked-List）
11-28
但链表代码，参考我的博客：https://blog.csdn.net/weixin_45571585/article/details/127479607?spm=1001.2014.3001.5502
Java链表（Linked List）基本原理与实现方法入门示例
08-19
主要介绍了Java链表（Linked List）基本原理与实现方法,结合实例形式分析了Java链表（Linked List）的功能、原理、实现方法与操作注意事项,需要的朋友可以参考下
build_linked_list:构建链接列表。 方法
05-17
链接列表 构建链接列表。 方法：reverseLinkedList，getKthFromTheEnd，toArray，大小，indexOf，包含，deleteLast，deleteFirst，addFirst，addLast
Lazy Linked-List(论文实现方法)
12-19
在https://github.com/gramoli/synchrobench上进行修改更适于Synchrobench’s Lazy Linked-List进行内存回收，解决了内存泄漏问题
二叉树的四种遍历方式（前序遍历、中序遍历、后序遍历、测层序遍历）
派拉斯兔子的博客
12-02 5895
二叉树的遍历 遍历是数据结构中的常见的操作，把所有元素都访问一遍。 线性数据结构的遍历比较简单 ①、正序遍历 ②、逆序遍历 根据节点访问顺序的不同，二叉树的常见遍历方式用四种 ①、前序遍历（Preorder Traversal） ②、中序遍历（Inorder Traversal） ③、后序遍历（Postorder Traversal） ④、层序遍历（Level Order Traversal） 前序遍历（Preorder Traversal） 访问顺序 根节点、前序遍历左子树、前序遍历右子
查找二叉树的前驱节点和后继节点
派拉斯兔子的博客
12-05 3024
前驱节点 前驱节点：中序遍历时的前一个节点。 如果是二叉搜索树，前驱节点就是前一个比它小的节点。 node.left != null 举例：6、13、8 predecessor = node.left.right.right.right...，终止条件：right为null node.left == null && node.parent != null，举例：7、11、9、1 predecessor = node.parent.parent.parent...终止条件：node在p
二叉树的相关概念及其性质
派拉斯兔子的博客
11-10 1524
树型结构 树（Tree）的基本概念 节点：每个元素称为结点 根节点：一棵树最多有一个根节点， 父节点：若一个结点含有子结点，则这个结点称为其子结点的父结点 子节点：一个结点含有的子树的根结点称为该结点的子结点 兄弟节点：具有相同父结点的结点互称为兄弟结点 一棵树可以没有任何节点，称为空树。 一棵树可以只有1个节点，也就是只有根节点。 子树、左子树、右子树 节点的度（degree）：子树的个数 树的度：所有节点度中最大值。 叶子节点（leaf）：度为0的节点
红黑树（Red Black Tree）删除操作及其平衡性能
派拉斯兔子的博客
01-30 1169
一、红黑树（Red Black Tree）删除操作 B树中，最后真正被删除的元素都在叶子节点中 1、删除 – RED节点 直接删除，不用作任何调整 2、删除 – BLACK节点 有 3 种情况 ①、拥有 2 个RED 子节点的BLACK 节点 ✓ 不可能被直接删除，因为会找它的子节点替代删除 ✓ 因此不用考虑这种情况 ②、拥有 1 个 RED子节点的BLACK 节点 ③、BLACK 叶子节点 3、删除 – 拥有1个RED子节点的BLACK节点 判定条件：用以替代的子节点是 RED 将替代的子节点染成 BLA
Java代码实现声明双链表类DoublyLinkedList，实现public boolean remove(E element)方法
05-04
好的，我理解您的问题是要求我用Java代码实现一个双链表类DoublyLinkedList，并实现public boolean remove(E element)方法。以下是实现的代码： ```java public class DoublyLinkedList<E> { private Node<E> ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值