数据结构---链表以及LinkedList源码分析

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

链表是通过一组任意的存储单元来存储线性结构的数组元素的，为了建立起数据元素之间的线性关系，对于链表的每个节点，除了数据元素的自身信息外，还需要存放后继元素的存放地址（单链表），还有双链表存放前置元素和后置元素的存放地址。还有循环链表，将单链表的首尾相连组成环。

单链表的实现：

 

public class LinkNode<V> {
	//数据
	V data;
	//下一个节点
	LinkNode<V> next =null;
	public LinkNode(V data,LinkNode<V> next) {
		this.data=data;
		this.next=next;
	}
}


public class LinkListDemo<V> {
	// 初始化头节点
	LinkNode<V> header = new LinkNode<V>(null, null);
	LinkNode<V> last = header;
	int size = 0;

	/*
	 * 添加元素 头部插入
	 */
	public void addToHeader(V data) {
		LinkNode<V> node = new LinkNode<V>(data, null);
		// 第一次插入
		if (header.next == null) {
			header.next = node;
			last = node;
		} else {
			node.next = header.next;
			header.next = node;
		}
		size++;
	}

	/*
	 * 添加元素 尾部插入
	 */
	public void addToLast(V data) {
		LinkNode<V> node = new LinkNode<V>(data, null);
		last.next = node;
		last = node;
		size++;
	}

	/*
	 * 删除节点 通过位置删除
	 */
	public void removeNode(int index) {
		if (index > size-1) {
			System.err.println("index超出范围");
			return;
		}
		LinkNode<V> node = header;
		// 找到该节点
		for (int i = 0; i < index; i++) {
			node = node.next;
		}
		// 修改待删除节点的前一个节点指向
		node.next = node.next.next;
		size--;
	}

	/*
	 * 删除节点 通过data删除
	 */
	public void removeNode(V data) {
		LinkNode<V> node = header;
		while (true) {
			// 找到元素
			if (node.next != null && node.next.data.equals(data)) {
				// 删除尾元素的时调整last位置
				if (node.next == last) {
					last = node;
				}
				node.next = node.next.next;
				size--;
				return;
			} else if (node.next == null) {
				System.err.println("没有此元素");
				return;
			}
			node = node.next;
		}
	}

	/*
	 * 查找节点
	 */
	public V search(int index) {
		if (index > size-1) {
			System.err.println("index超出范围");
			return null;
		}
		LinkNode<V> node = header;
		for (int i = 0; i < index; i++) {
			node = node.next;
		}
		return node.data;
	}

	/*
	 * 更新节点
	 */
	public boolean unpdata(int index, V data) {
		if (index > size-1) {
			System.err.println("index超出范围");
			return false;
		}
		LinkNode<V> node = header;
		for (int i = 0; i < index; i++) {
			node = node.next;
		}
		node.data = data;
		return true;
	}
}

这个测试的时候遇到一个小问题：

public static void main(String[] args) {
		LinkListDemo<Integer> link = new LinkListDemo<>();
		link.addToHeader(11);
		link.addToHeader(12);
		link.addToHeader(13);
		link.addToHeader(14);
		link.addToHeader(15);
		
		link.removeNode(10);
		link.removeNode((Integer)15);
		link.unpdata(3, 10000);
		int temp = link.search(3);
		System.out.println(temp);
	}

由于自动拆装箱的时候，要调用的时候注意参数类型，不得不说好轮子不好造啊。

双向链表实现：

 

public class DoubleNode<V> {
	V data;
	DoubleNode<V> next;
	DoubleNode<V> prev;
	public DoubleNode(V data,DoubleNode<V> next,DoubleNode<V> prev) {
		this.data=data;
		this.next=next;
		this.prev=prev;
	}
}


public class DoubleLinkDemo<V> {
		//初始化头节点
		DoubleNode<V> header = new DoubleNode<V>(null, null,null);
		DoubleNode<V> last=header;
		int size=0;
		
		/*
		 * 添加元素
		 * 头部插入
		 */
		public void addToHeader(V data) {
			DoubleNode<V> node = new DoubleNode<V>(data, null,null);
			//第一次插入
			if(header.next==null) {
				header.next=node;
				node.prev=header;
				last=node;
			}else {
				node.next=header.next;
				node.prev=header;
				node.next.prev=node;
				header.next=node;
			}
			size++;
		}
		/*
		 * 添加元素
		 * 尾部插入
		 */
		public void addToLast(V data) {
			DoubleNode<V> node = new DoubleNode<V>(data, null,null);
			last.next=node;
			node.prev=last;
			last=node;
			size++;
		}
		/*
		 * 删除节点
		 * 通过位置删除
		 */
		public void removeNode(int index) {
			if(index>size-1) {
				System.err.println("index超出范围");
				return;
			}
			//判断一下位置，从前找还是从后找更快
			if(index>size/2) {
				DoubleNode<V> node = last;
				//找到该节点
				for(int i=size;i>index-1;i--) {
					node=node.prev;
				}
				//修改待删除节点的前一个节点指向,以及后一个节点指向
				node.next=node.next.next;
				node.next.prev=node;
			}else {
				DoubleNode<V> node = header;
				//找到该节点
				for(int i=0;i<index;i++) {
					node=node.next;
				}
				//修改待删除节点的前一个节点指向,以及后一个节点指向
				node.next=node.next.next;
				node.next.prev=node;
			}
			size--;
		}
		/*
		 * 删除节点
		 * 通过data删除
		 */
		public void removeNode(V data) {
			DoubleNode<V> node = header;
			while(true) {
				//找到元素
				if(node.next!=null&&node.next.data.equals(data)) {
					//删除尾元素的时调整last位置
					if(node.next==last) {
						last=node;
					}
					node.next=node.next.next;
					node.next.prev=node;
					size--;
					return;
				}else if(node.next== null) {
					System.err.println("没有此元素"); 
					return;
				}
				node=node.next;
			}
		}
		/*
		 * 查找节点
		 */
		public V search(int index) {
			if(index>size-1) {
				System.err.println("index超出范围");
				return null;
			}
			DoubleNode<V>  node = null;
			if(index>size/2) {
				node = last;
				for(int i=size;i>=index;i--) {
					node=node.prev;
				}
				return node.data;
			}else {
				node = header;
				for(int i=0;i<=index;i++) {
					node=node.next;
				}
				return node.data;
			}
		}
		/*
		 * 更新节点
		 */
		public boolean unpdata(int index,V data) {
			if(index>size-1) {
				System.err.println("index超出范围");
				return false;
			}
			DoubleNode<V> node = header;
			for(int i=0;i<index;i++) {
				node=node.next;
			}
			node.data=data;
			return true;
		}
}

下面分析一下LinkedList源码：

 

//属性：
//长度
transient int size = 0;
//首节点
transient Node<E> first;
//尾节点
transient Node<E> last;

//节点（采用的双向链表）
  private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }
//构造方法
 //空构造方法
  public LinkedList() {}

//插入函数
/*
*头节点插入
*/
 public void addFirst(E e) {
        linkFirst(e);
    }
  private void linkFirst(E e) {
        final Node<E> f = first;
        final Node<E> newNode = new Node<>(null, e, f);
        first = newNode;
        //判断是否是第一个节点
        if (f == null)
            last = newNode;
        else
            f.prev = newNode;
        size++;
        modCount++;
    }
    
    /*
    *尾节点插入
    */
     public void addLast(E e) {
        linkLast(e);
    }
     public boolean add(E e) {
        linkLast(e);
        return true;
    }
      void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        //同样判断是否为第一个节点
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }
    //通过头插和尾插可以看出。linkList中没有头元素（一个空元素起点）
    
 //删除函数
 /*
 *循环找到待删除的元素，源码中对待删除的元素是否为空进行了判断
 */
  public boolean remove(Object o) {
        if (o == null) {
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }
     E unlink(Node<E> x) {
        // assert x != null;
        final E element = x.item;
        final Node<E> next = x.next;
        final Node<E> prev = x.prev;
        //判断删除后，他的上一个节点是否为首节点
        if (prev == null) {
            first = next;
        } else {
            prev.next = next;
            x.prev = null;
        }
        //判断删除后，他的下一个节点是否为尾节点
        if (next == null) {
            last = prev;
        } else {
            next.prev = prev;
            x.next = null;
        }

        x.item = null;
        size--;
        modCount++;
        return element;
    }  
    //删除首节点
     private E unlinkLast(Node<E> l) {
        final E element = l.item;
        final Node<E> prev = l.prev;
        l.item = null;
        l.prev = null; // help GC
        last = prev;
        if (prev == null)
            first = null;
        else
            prev.next = null;
        size--;
        modCount++;
        return element;
    }

    public E remove(int index) {
        //检查index是否合法
        checkElementIndex(index);
        //通过index查找到对应的值，然后删除
        return unlink(node(index));
    } 
     private void checkElementIndex(int index) {
        if (!isElementIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
      private boolean isElementIndex(int index) {
        return index >= 0 && index < size;
    }
    //循环找到index对应的元素
     Node<E> node(int index) {
        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }
    /*
    *清空函数
    */
     public void clear() {
       //清空所有节点
        for (Node<E> x = first; x != null; ) {
            Node<E> next = x.next;
            x.item = null;
            x.next = null;
            x.prev = null;
            x = next;
        }
        first = last = null;
        size = 0;
        modCount++;
    }
    
    /*
    *获取函数
    */
     public E get(int index) {
         //检查index是否合法
        checkElementIndex(index);
        //循环找到index对应的对应，然后取值
        return node(index).item;
    }
    /*
    *更新函数
    */
     public E set(int index, E element) {
        checkElementIndex(index);
        Node<E> x = node(index);
        E oldVal = x.item;
        x.item = element;
        return oldVal;
    }
//除了这些函数以后还有好多对首节点，尾节点操作的函数，就不一一讨论了。
//但是下面LinkList封装了队列的操作，瞅上那么一瞅
/*
*操作函数
*/
  public void push(E e) {
        addFirst(e);
    }
    
  public E poll() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }

 

骚小孩呀
关注
专栏目录
数据结构之链表及LinkedList源码分析
Hannen的博客
03-08 238
链表 1：概念 ​ 链表（Linked list）是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一 个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 2：存储结构 ​ 相比数组，链表是一种稍微复杂一点的数据结构。对于初学者来说，掌握起来也要比数组稍难一些。这两个非常基础、非常常用的数据结构，我们常常将会放到一块儿来比较。所以我们先来看，这两者
LinkedList双向链表源码分析（附详细图解！！）
A_diligent_man的博客
07-18 1197
本文章分析LinkedList源码。
Java双向链表（通过源码分析）
ligaogui的博客
05-28 218
如上图就是我们的链表的结构，这些节点游离在内存中，位置不连续；一个节点包括三个部分：prior，element，next；prior部分指向上一个节点，如果prior的值为null,则表示它是第一个节点，也就是链表的开始；element指向储存对象的地址；next与prior相似，next指向下一个节点，如果为null，则为最后一个节点。这种结构使它变更的能力大大增强，变更只需要修改它的前后...
深入理解链表结构和LinkedList源码分析
蒋蒋
05-28 238
深入理解链表结构和LinkedList源码分析链表的概念LinkedList分析继承的类和接口特殊的关键字transient源码关键部分分析自己实现一个单向链表面试相关 链表的概念 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素...
链表详解（动画，源码，详解）
Only Sun
07-22 1022
用最简单的逻辑，最少的代码实现链表的基本功能 本文使用图文结合的方式用50行代码，写出了链表的头插法，尾差法，修改，删除，返回链表长度，判断链表是否为空一系列功能。
【Java数据结构】LinkedList-链表
Carefree_State的博客
03-13 1503
此文章详细讲解数据结构：链表，以模拟LinkedList的视角去研究链表，学习单链表以及双向链表的基础知识，后续我们可以靠这些知识，进攻更难的oj题，更特殊的链表类型~
LinkedList数据结构链表
qq_43012298的博客
02-16 822
LinkedList在Java中是一个实现了List和Deque接口的双向链表。它允许我们在列表的两端添加或删除元素，同时也支持在列表中间插入或移除元素。在分析LinkedListLinkedList。
java linkedlist源码分析_Java源码分析 - LinkedList双向链表源码分析
weixin_39737111的博客
02-24 114
LinkedList就传说中的双向链表了。是List 接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素(包括 null)。除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。查看LinkedList的构造函数：/*** Constructs an e...
Java数据结构源码分析-LinkedList
CWeeYii的专栏
06-05 539
1.LinkedListLinkedList是通过双向链表来维护链表的顺序性。 首先，我们看下类的构成，LinkedList通过两个iterator来顺序和倒序的访问数据。public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java
数据结构 - 数组、链表
it_lihongmin的博客
02-24 1165
目录 1、数组 2、链表 最简单是数据结构就是线性表，包括数组、链表、栈和队列。线性表就是数据像线一样连城一条线，线上的每个节点都只有前后两个方向。其他的就是非线性结构，包括树（一个节点可以链接到多个节点）、图（节点可能成环），或者散列表、跳表等。用一个对比图展示： 1、数组 数组的特点： 1）、属于线性表 2）、数组创建时会申请一片连续的内存空间，并且存储每个位置上的数据类型相同（即创建完成后，内存空间已定，不能再扩展）。 ...
链表(数据结构--Java版)
03-17
链表是一种常用的数据结构，它在计算机科学中扮演着重要的角色。相较于数组，链表的主要优点在于其动态性，可以在运行时高效地插入和删除元素，而无需移动大量的内存数据。在Java中，链表主要通过实现接口`List`、`...
javalist数据结构-Java数据结构-------List.pdf
07-11
以下是ArrayList添加元素到尾部的源码分析： ```java public boolean add(E e) { ensureCapacityInternal(size + 1); elementData[size++] = e; return true; } private void ensureCapacityInternal(int ...
细说 单链表、双向链表 、LinkedList类（附 add 源码解读）和 ArrayList 和 LinkedList 的区别 —— 数据结构
honglan297的博客
07-25 748
本篇文章将从链表的相关概念入手，对单向、双线链表进行模拟实现，再回到 LinkedList 集合内当中进行简单分析，最后结合上一篇文章，阐述四点 LinkedList 和 ArrayLIst 区别。
数据结构_2.2、顺序表插入删除查找
cfy2401926342的博客
09-29 391
线性表：是具有相同数据类型的n （n≥0）个数据元素的有限序列顺序表：用顺序存储的方式实现线性表顺序存储：把逻辑上相邻的元素存储在物理 位置上也相邻的存储单元中，元素之间的关 系由存储单元的邻接关系来体现。ElemType ：就是你的顺序表中存放的数据元素类型。
数据结构（栈和队列的实现）
2301_80475151的博客
09-30 1115
这里介绍了栈的实现和队列的实现，还有栈和队列的OJ题例如用栈实现队列和用队列实现栈等‘；
数据结构-3.10.队列的应用
ADCvbV的博客
10-01 301
与5结点相邻的结点只有7，8结点没被处理过(6结点已经入队列了)，因此只需7，8结点入队列，之后5结点出队列；同理处理2结点，与2相邻的1结点已经被处理过，因此无需入队，与2相邻的4结点没被处理过，4结点入队列，最后。之后的结点处理方式与上述同理，直到队列为空就完成了对图的广度优先遍历。遍历到4时，发现它没有子节点，所以4直接出队列即可，无需入子节点。
排序算法之归并排序
qq_64039411的博客
10-01 479
需要注意的是，在实际应用中，归并排序的空间复杂度较高，需要额外的空间来存储临时数组。如果对空间复杂度有要求，可以考虑使用其他排序算法。归并排序是一种分治算法，它将一个数组分成两个子数组，然后递归地对子数组进行排序，最后将两个有序的子数组合并成一个有序的数组。归并排序的时间复杂度是O(nlogn)，其中n是数组的长度。它是一种稳定的排序算法，适用于各种数据类型的排序。合并排序的关键在于合并操作。
【数据结构】链表-1
最新发布
2301_79740539的博客
10-04 301
链表与数组
数据结构（链表的操作算法）
m0_61903191的博客
09-30 479
编写一个程序exp2_2.cpp,采用单链表表示集合(假设同一个集合中不存在重复素)，将其按递增方式排序，构成有序单链表，并求这样的两个集合的并、交和差。(2)依次采用尾插法插入a、b、c、d、e元素。(8)在第4个元素位置上插人1元素。(10)删除单链表h的第3个元素。(6)输出单链表h的第3个元素。(5)判断单链表h是否为空。(4)输出单链表h长度。(7)输出元素a的位置。(1)初始化单链表h。(11)输出单链表h。(12)释放单链表h。(3)输出单链表h。(9)输出单链表h。
Java数据结构与算法源码分析
在Java中，这些基本的数据结构都有对应的实现，比如java.util.ArrayList代表动态数组，java.util.LinkedList代表链表，等等。 2. 算法原理与实现： 算法是一系列解决问题的清晰指令，算法设计往往涉及时间复杂度和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值