动态链表1线性表的链式存储结构(LinkedList实现)

最新推荐文章于 2023-12-05 13:45:40 发布
最新推荐文章于 2023-12-05 13:45:40 发布
阅读量311 收藏 1
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zh_tnis/article/details/100833005
版权

  1.线性表的链式图。

 

  2.头结点和头指针的异同。

      头指针head

  •     头指针是指链表指向第一 个结点的指针，若链表有头结点，则是指向头结点的指针。
  •     头指针具有标识作用，所以常用头指针冠以链表的名字。
  •     无论链表是否为空，头指针均不为空。头指针是链表的必要元素。

      尾指针rear

  •     同头指针一样，但是指向链表中最后一个节点，最后一个节点指向的是一个null。

      头结点

  •      虚拟头结点：为了操作的统一和方便而设立的，放在第一元素的结点之前，其数据域般无意义(也可存放链表的长度)有了                              头结点，对在第一元素结点前插入结点和删除第一结点，其操作与其它结点的操作就统一了。
  •      真实头结点：第一个节点，也就是存储元素的一个节点。

  3.数据域和指针域

 

   4.线性表的链式存储结构LinkedList的定义。

      

    分析：

    1、单链表的插入----插入元素e。

    头插法：1.当该链表是一个空链表时：

                       将头结点的下一跳赋给插入元素e的下一跳，然后将该元素e赋给头结点的下一跳。最后将尾指针rear移动到元素e对                        应的节点。

                 2.当该链表是一个存在元素的链表时：

                       将头结点的下一跳赋给插入元素e的下一跳，然后将该元素e赋给头结点的下一跳。这里的尾指针rear则不需要移                              动。

     尾插法：将该元素e赋给尾指针对应的结点的下一跳，然后将尾指针rear移动到元素e对应的结点。

     一般插入(中间某个位置插入)：比如说在A和B中间插入一个元素。

                     将A的下一跳赋给元素e的下一跳，然后将元素e赋给A的下一跳，由于中间插入，尾指针rear不需要移动。

    思路算法 ：

                         1. 声明一个节点p指向链表虚拟头节点，初始化i从0开始。

                         2. 当i<index时，就遍历链表，让p的指针向后移动，不断指向下一个节点，i累加1。

                         3. 若查到末尾p为空，则说明第index个元素不存在，抛异常throw new IllegalArgumentException("插入角标非                                      法!")。

                         4. 否则查找成功，在系统生成一个空节点n。

                         5. 将插入元素e赋值给n.data。

                         6. 单链表的插入标准语句n.next=p.next;  p.next=n;

public void add(int index, E e) {
		if(index<0||index>size){
			throw new IllegalArgumentException("插入角标非法!");
		}
		Node n=new Node(e,null);
		if(index==0){	               //头插
			n.next=head.next;
			head.next=n;
			if(size==0){
				rear=n;
			}
		}else if(index==size){	       //尾插
			rear.next=n;
			rear=rear.next;
		}else{                         //一般插入
			Node p=head;
			for(int i=0;i<index;i++){
				p=p.next;
			}
			n.next=p.next;
			p.next=n;
		}
		size++;
		
	}

     2、单链表的删除----删除index处的元素

    删头：1.当该链表只存在一个元素时：

                   将真实头结点的下一跳赋给虚拟头结点的下一跳。这里的尾指针rear移动到虚拟头结点处。

               2.当该链表不止一个元素的时候：

                   将真实头结点的下一跳赋给虚拟头结点的下一跳。这里的尾指针rear不需要移动。

    删尾：将尾结点的下一跳赋给尾结点上一跳的下一跳，这里的尾指针rear移动到上一个位置处。

    一般删除(删除中间某个位置index处元素)：       

                 将index处的下一跳赋给index处上一跳的下一跳，这里的尾指针rear不需要移动。

    思路算法:

             1. 声明一个节点p指向链表的虚拟头结点，初始化i从0开始。

             2. 当i<index时，就遍历链表，让p的指针向后移动，不断指向下一个结点，i累加1。

             3. 若到链表末尾p为空，则说明第index个元素不存在，抛异常 。                                                                                              

             4. 否则查找成功，将欲删除的结点p.next赋值给del。                                                                                                                    

             5. 单链表的删除标准语句res=del.data; p.next=del.next;   del.next=null;   del=null;                                                                  

             6. 将del.data赋值给res，也就是要删除的元素，作为返回。                                                                                                        

             7.  释放res值。

public E remove(int index) {
		if(index<0||index>=size){
			throw new IllegalArgumentException("删除角标非法!");
		}
		E res=null;                        //定义一个返回值，初始值为空
		if(index==0){	                      //删头
			Node p=head.next;
			res=p.data;
			head.next=p.next;
			p.next=null;
			p=null;
			if(size==1){
				rear=head;
			}
		}else if(index==size-1){              //删尾
			Node p=head;
			res=rear.data;
			while(p.next!=rear){
				p=p.next;
			}
			p.next=null;
			rear=p;
		}else{                               一般删除
			Node p=head;
			for(int i=0;i<index;i++){
				p=p.next;
			}
			Node del=p.next;       //将下一跳也就是删除元素赋给del
			res=del.data;          //将要删除的元素具体值赋给res
			p.next=del.next;       //将要删除元素的下一跳给p的下一跳
			del.next=null;         //删除元素的下一跳清空
			del=null;              //删除元素清空
		}
		size--;
		return res;
	}

    3、单链表的获取----index处元素。

      算法思路：

      1. 对index进行判断，若index<或者index>=size，抛异常throw new IllegalArgumentException("查找角标非法!");。

      2. 如果index==0，直接返回头结点下一跳元素，也就是return head.next.data;。

      3. 如果index==size-1，直接返回尾指针对应的元素，也就是return rear.data;。

      4.如果index在链表中间的某元素，创建一个Node类型的p变量，将头结点的地址给p。然后定义一个for循环，将p的地址移动          到目标index处的结点。最后返回return p.data;。

public E get(int index) {
		if(index<0||index>=size){
			throw new IllegalArgumentException("查找角标非法!");
		}
		if(index==0){
			return head.next.data;
		}else if(index==size-1){
			return rear.data;
		}else{
			Node p=head;
			for(int i=0;i<=index;i++){
				p=p.next;
			}
			return p.data;
		}
	}

    4、单链表的修改----(index,e)

      算法思路：

      1.  对index进行判断，若index<或者index>=size，抛异常throw new IllegalArgumentException("修改角标非法!");。

      2. 若index==0，直接令头结点的下一跳的数据data等于e。

      3. 如果index==size-1，直接令尾指针对应的元素等于e，也就是rear.data=e;。

      4. 如果角标在链表中间某位置，创建一个Node类型的变量p，等于head的地址。

      5. 建立一个for循环，从0~idnex，令p到达修改元素位置，最后p.data=e;。

public void set(int index, E e) {
		if(index<0||index>=size){
			throw new IllegalArgumentException("修改角标非法!");
		}
		if(index==0){
			head.next.data=e;
		}else if(index==size-1){
			rear.data=e;
		}else{
			Node p=head;
			for(int i=0;i<=index;i++){
				p=p.next;
			}
			p.data=e;
		}
	}

    5、单链表的查找----e

      1. 令未查找到元素返回初值为int index=-1；

      2. 判断链表是否为空，空返回定义的初值return index；

      3. 创建一个Node类型的p变量，让头指针的地址指向p。

      4. 开始一个循环，让p从头结点走向尾结点，每走一步index++，然后与e判断是否相等，相等返回index当前值，不等则返回定义的初值。

public int find(E e) {
		int index=-1;
		if(isEmpty()){
			return index;
		}
		Node p=head;
		while(p.next!=null){
			p=p.next;
			index++;
			if(p.data==e){
				return index;
			}
		}
		return -1;
	}

    6、toString方法的创建。

      1. 使用StringBuilder创建一个对象sb。

      2. 对单链表进行判空，空则打印"[ ]"   

      3. 非空，先打印"[ "  当创建一个Node类型的p变量，将头结点的地址赋给p，开启一个0~rear的循环，每次都将新的地址对应            的元素打印出来，然后元素后边加上"，"  除非打印到最后一个元素后边才加上"] "

      4. 最后返回sb.toString

public String toString() {
		StringBuilder sb=new StringBuilder();
		sb.append("LinkedList:size="+getSize()+"\n");
		if(isEmpty()){
			sb.append("[]");
		}else{
			sb.append("[");
			Node p=head;
			while(p.next!=null){
				p=p.next;
				if(p==rear){
					sb.append(p.data+"]");
				}else{
					sb.append(p.data+",");
				}
			}
			
		}
		return sb.toString();
	}

  代码的全部实现：

package com.oupeng.p5链表;

import com.oupeng.p1线性表.List;

public class LinkedList<E> implements List<E> {
	/**
	 * 单向链表的结点类
	 * */
	private class Node{
		E data;		//数据域
		Node next;	//指针域
		public Node(){
			this(null,null);
		}
		public Node(E data,Node next){
			this.data=data;
			this.next=next;
		}
		@Override
		public String toString() {
			return data.toString();
		}
	}
	
	private Node head;	//指向虚拟头结点的头指针
	private Node rear;	//指向尾结点的尾指针
	private int size;	//记录元素的个数
	
	public LinkedList(){
		head=new Node();
		rear=head;
		size=0;
	}
	public LinkedList(E[] arr){
		head=new Node();
		rear=head;
		size=0;
	}
	
	@Override
	public int getSize() {
		return size;
	}

	@Override
	public boolean isEmpty() {
		return size==0&&head.next==null;
	}

	@Override
	public void add(int index, E e) {
		if(index<0||index>size){
			throw new IllegalArgumentException("插入角标非法!");
		}
		Node n=new Node(e,null);
		if(index==0){	//头插
			n.next=head.next;
			head.next=n;
			if(size==0){
				rear=n;
			}
		}else if(index==size){	//尾插
			rear.next=n;
			rear=rear.next;
		}else{
			Node p=head;
			for(int i=0;i<index;i++){
				p=p.next;
			}
			n.next=p.next;
			p.next=n;
		}
		size++;
		
	}

	@Override
	public void addFirst(E e) {
		add(0,e);
	}

	@Override
	public void addLast(E e) {
		add(size,e);
	}

	@Override
	public E get(int index) {
		if(index<0||index>=size){
			throw new IllegalArgumentException("查找角标非法!");
		}
		if(index==0){
			return head.next.data;
		}else if(index==size-1){
			return rear.data;
		}else{
			Node p=head;
			for(int i=0;i<=index;i++){
				p=p.next;
			}
			return p.data;
		}
	}

	@Override
	public E getFirst() {
		return get(0);
	}

	@Override
	public E getLast() {
		return get(size-1);
	}

	@Override
	public void set(int index, E e) {
		if(index<0||index>=size){
			throw new IllegalArgumentException("修改角标非法!");
		}
		if(index==0){
			head.next.data=e;
		}else if(index==size-1){
			rear.data=e;
		}else{
			Node p=head;
			for(int i=0;i<=index;i++){
				p=p.next;
			}
			p.data=e;
		}
	}

	@Override
	public boolean contains(E e) {
		
		return find(e)!=-1;
	}

	@Override
	public int find(E e) {
		int index=-1;
		if(isEmpty()){
			return index;
		}
		Node p=head;
		while(p.next!=null){
			p=p.next;
			index++;
			if(p.data==e){
				return index;
			}
		}
		return -1;
	}

	@Override
	public E remove(int index) {
		if(index<0||index>=size){
			throw new IllegalArgumentException("删除角标非法!");
		}
		E res=null;
		if(index==0){	//头删
			Node p=head.next;
			res=p.data;
			head.next=p.next;
			p.next=null;
			p=null;
			if(size==1){
				rear=head;
			}
		}else if(index==size-1){//尾删
			Node p=head;
			res=rear.data;
			while(p.next!=rear){
				p=p.next;
			}
			p.next=null;
			rear=p;
		}else{
			Node p=head;
			for(int i=0;i<index;i++){
				p=p.next;
			}
			Node del=p.next;
			res=del.data;
			p.next=del.next;
			del.next=null;
			del=null;
		}
		size--;
		return res;
	}

	@Override
	public E removeFirst() {
		return remove(0);
	}

	@Override
	public E removeLast() {
		return remove(size-1);
	}

	@Override
	public void removeElement(E e) {
		int index=find(e);
		if(index==-1){
			throw new IllegalArgumentException("元素不存在");
		}
		remove(index);
	}

	@Override
	public void clear() {
		head.next=null;
		rear=head;
		size=0;
	}
	
	@Override
	public String toString() {
		StringBuilder sb=new StringBuilder();
		sb.append("LinkedList:size="+getSize()+"\n");
		if(isEmpty()){
			sb.append("[]");
		}else{
			sb.append("[");
			Node p=head;
			while(p.next!=null){
				p=p.next;
				if(p==rear){
					sb.append(p.data+"]");
				}else{
					sb.append(p.data+",");
				}
			}
			
		}
		return sb.toString();
	}
     public boolean equals(Object obj){
		if(obj==null){
			return false;
		}
		if(obj==this){
			return true;
		}
		if(obj instanceof LinkedList){
			LinkedList<E> l=(LinkedList<E>) obj;
			if(l.getSize()==getSize()){
				for(int i=0;i<getSize();i++){
					if(get(i)!=l.get(i)){
						return false;
					}
				}
				return true;
			}
		}
		return false;
	}
}

    5.单链表结构与顺序存储结构的优缺点。

      存储分配方式：

  •     顺序存储结构用一段连续的存储单元依次存储线性表的数据元素。
  •     单链表采用链式存储结构，用一组任意的存储单元存放线性表的元素。

      时间性能：

  •     查找   顺序存储结构O(1)   单链表O(n)
  •     插入和删除   顺序存储结构需要平均移动表长一半的元素，时间为O(n)
  •                            单链表在线出某位置的指针后，插入和删除时间仅为O(1)

      空间性能：

  •     顺序存储结构需要预分配存储空间，分大了，浪费，分小了容易发生上溢。
  •     单链表不需要分配存储空间，只要有就可以分配，元素个数也不受限制。

 

zh_Tnis
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态链表（一）概述及单链表
weixin_44151598的博客
09-19 2483
一、动态链表的产生 前面的博客我们简单了介绍了线性表，而链表是线性表的一种，所谓的线性表包含顺序线性表和链表，顺序线性表是用数组实现的，在内存中有顺序排列，通过改变数组大小实现。而链表不是用顺序实现的，用指针实现，在内存中不连续。意思就是说，链表就是将一系列不连续的内存联系起来，将那种碎片内存进行合理的利用，解决空间的问题。 说的通俗一点，就是链表的出现弥补了顺序线性表对空间的浪费问题，同时他...
线性表:动态链表
Sock的博客
12-07 578
在数据结构中我们经常会用到链表来处理一些问题, 链表同顺序表一样, 包括静态链表和动态链表, 静态链表并不是很常用, 但动态链表的重要性是不言而喻的. 接下来我们看一下动态链表的基本操作, 以书上的资料为参考, 同时自己对动态链表增加了新的认识和总结 动态链表的基本操作 动态链表的定义 //定义一个动态链表 typedef int ElemType; typedef struct LNode ...
线性存储结构-LinkedList
dengxi7116的博客
11-14 238
LinkedList内部采用链表的形式构建，是一个双向链表。除了继承List外，还继承了Deque接口，可以当做堆栈结构使用。 private static final class Link<ET> { ET data; //数据 Link<ET> previous, next; //前节点、后节点 Link(ET o, Link&...
深度解析C#中LinkedList＜T＞的存储结构
Reische的博客
12-05 417
通过循环遍历链表中的每个节点，根据节点的值与目标值的比较，找到匹配的节点并返回。以上代码展示了AddLast()的实现代码，这个方法是在双向链表的末尾添加一个新节点的操作，并根据链表是否为空采取不同的插入策略，确保插入操作的有效性，并返回了对新插入节点的引用。本节中主要介绍了链表的元素插入、元素的查询、元素的移除等操作，在不同的场景中，其实现的方式都存在着不同，在C#内部维护的链表结构相对简化，没有对其内部进行很强的优化，因此我们在实际的项目中对于链表的应用时，需要充分的分析使用的场景诉求进行调整优化。
数据结构与算法学习（二）链式存储结构LinkedList源码分析
qq_21158307的博客
09-29 222
待编辑
java线性表的存储结构及其代码实现
08-29
在 Java 中，可以使用 LinkedList 类来实现链式存储结构。 三、线性表的基本特征 线性表的基本特征如下： * 总存在唯一的第一个数据元素 * 总存在唯一的最后一个数据元素 * 除第一个数据元素外，集合中的每一个...
线性表的链式存储结构.zip
12-27
链式存储结构是实现线性表的一种方式，相较于顺序存储，它在处理动态变化的数据集时具有更大的灵活性。 链式存储结构不像数组那样需要连续的内存空间，每个元素（也称为节点）在内存中可以分散存放，每个节点除了...
线性表的存储结构与顺序表的存储实现共4页.pdf.zip
11-25
在给定的文件"线性表的存储结构与顺序表的存储实现共4页.pdf.zip"中，可能会详细探讨这些概念，并通过实例和图解来阐述它们的原理和使用方法，帮助读者深入理解线性表的这两种基本存储方式。不过，由于文件名中并未...
数据结构 线性表和链表 c++实现
12-14
总结来说，"数据结构 线性表和链表 c++实现"这一主题涵盖了基础数据结构的理论和实践，包括顺序表和链表的概念、优缺点以及在C++中的面向对象实现。通过理解这些内容，开发者可以更好地设计和优化算法，解决实际问题...
简单介绍线性表以及如何实现双链表
09-03
1. 数组：数组是最基础的线性结构，它在内存中是连续存储的，具有固定的大小和索引。数组的优点是随机访问速度快，可以通过索引直接访问任意位置的元素。但是，数组的大小在创建时必须预先确定，且一旦确定就无法...
【Java】自定义LinkedList(链式存储结构)和性能分析
pangpd的博客
08-10 306
链表结构 链表结构分为两种： （1）单向链表：要么从头遍历到尾，要么从尾遍历到头 （2）双向链表：即可以从头遍历到尾，又可以从尾遍历到头。 通过引用关系表示上一个节点和下一个节点的关系 1. 单向链表 class Node { Node next; // 下一个节点 Object ele; // 当前节点的元素 } 2. 双向链表 我们以双链表为例，演示链表的基本操作 class Node { Node next; // 下一个节点 Node prev; // 上一个节
数据结构和算法（5）：链式存储结构——链表、LinkedList
qq_37816847的博客
08-09 299
链表是一种常见的数据结构，用于存储和组织数据。它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。链表中的每个节点都是独立分配的，它们在内存中可以不连续地存储。链表的主要特点是灵活性。相比于数组，链表的长度可以动态地增加或减少，不需要预先分配固定大小的内存空间。这使得链表在需要频繁插入和删除元素的场景中表现优秀。一个单向链表节点基本上是由两个元素，即数据字段和指针所组成，而指针将会指向下一个元素在内存中的地址。在“单向链表”中第一个节点是“链表头指针”。
STL链式存储结构——————list链表
qq_41818544的博客
07-21 555
迭代器的辅助
线性表的链式存储结构(动态链表)
fengel_cs的专栏
05-29 574
/* 一，数据结构书上对程序LinkedList.c的某些定义 1.线性表的链式存储结构 2.对于线性表的链式存储结构，不要求逻辑上相邻的元素在物理位置上也相邻，因此它没有顺序存储结构所具有的弱点,但也同时失去了顺序表可随机存取的优点。 3.链表中的几个定义： （1）首结点，存放第一个有效数据的结点。 （2）尾结点，存放最后一个有效数据的结点，指针域为NULL。 （3）头结
关于线性表的两种储存结构及单链表逆序解析（ArrayList和LinkedList）
梦想是要有的，万一实现了呢！
08-27 918
这是前段时间的一些感悟吧，现在将它写成博客也算是一种总结，和对前边知识的一种回顾。 线性表有两种：1、顺序表（ArrayList）：用一组地址连续的储存单元依次存储线性表的元素。（这个有点像时一个对象数组，在做设计顺序表时的存储结构就是一个对象数组。） 存储结构代码如下（全部代码请查看ArrayList代码）： 2、链表（LinkedList）：用任意的存储单元存储元素。
Java--线性链表(带动态图)
RAVANLALA
10-09 283
线性链表 public class LinkList{ Node head; Node tail; public LinkList(){// head = new Node; tail = head; } void Insert(Node e, Node p){ p.next = e.next; e.next = p; } Insert void Delete...
（C语言）线性表的链式存储的实现
vipchen1997的博客
06-18 1231
//带头结点单链表的实现 #include&lt;stdio.h&gt; #include&lt;malloc.h&gt; typedef struct LinkListNode { int data; struct LinkListNode *next; }Node,*pNode; pNode Create(void); //初始化，创建头结点 int Isempty(pNode...
Java数据结构与算法——链表面试题
baijaiyu的博客
09-13 1337
本文为链表相关面试题，每道题均附讲解及对应连接。 一：反转一个单链表。 链接：206. 反转链表 - 力扣（LeetCode）https://leetcode.cn/problems/reverse-linked-list/description/ 1.题目：给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。2. 2.解题 我的思路是：从第二个结点开始，依次将后一个结点的指向改变为指向前一个结点。如果直接改变指向，那么就无法找到下一个结点了，所.....
关于单链表中temp.next、head.next的理解
weixin_45541037的博客
03-14 5700
关于head.next没有赋值的正确理解
实现线性表的链式存储结构c语言
最新发布
04-08
在C语言中，实现线性表的链式存储结构可以使用指针来实现。链式存储结构是通过节点之间的指针连接来表示线性表中的元素关系。 首先，我们需要定义一个节点结构体，该结构体包含两个成员：数据域和指针域。数据域...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值