单向链表实现
Posted guardwhy
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了单向链表实现相关的知识，希望对你有一定的参考价值。
1.1 基本介绍
链表(linked list)是一种在物理上非连续、非顺序的数据结构，由若干节点（node）所组成。链表中数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域(data)，另一个是存储下一个结点地址的指针域(next)。（百度百科）
1.2 存储原理
链表的每一个节点分布在内存的不同位置，依靠next指针关联起来。这样可以灵活有效地利用零散的碎片空间。链表的第1个节点被称为头节点(3)，没有任何节点的next指针指向它，或者说它的前置节点为空头结点用来记录链表的基地址。有了它就可以遍历得到整条链表链表的最后1个节点被称为尾节点(2)，它指向的next为NULL。
1.3 添加操作
1、思路分析
- 为了让代码更加精简，统一所有节点的处理逻辑，可以在最前面增加一个虚拟的头结点（不存储数据）
- 新节点的
next指针，指向插入位置的节点。插入位置前置节点的next指针，指向新节点。 - 只要内存空间允许，能够插入链表的元素是无限的，不需要像数组那样考虑扩容的问题。
头部添加
当链表为空时，头部插入
当链表不为空时，从头部插入。
先让新的节点指向头结点，然后再让头结点指向新节点！！！
尾部添加
先让尾指针指向的节点，指向新节点
然后tail从新指向新节点
中间添加
定义一个指针prev，将prev的当前下一跳给新节点的下一跳。然后再让prev节点重新指向新节点
2、代码示例
接口实现：List
package cn.linkedlist.demo01;
/***
* List接口方法
* @param <E>
*/
public interface List<E> extends Iterable<E>
void add(E element);
void add(int index, E element) ;
void remove(E element);
E remove(int index);
E get(int index);
E set(int index, E element) ;
int size();
int indexOf(E element) ;
boolean contains(E element);
boolean isEmpty();
void clear();
链表实现：LinkedSinglyList
package cn.linkedlist.demo01;
import java.util.Iterator;
public class LinkedSinglyList<E> implements List<E>
// 创建Node节点
private class Node
//数据域 用来存储数据的
public E data;
//指针域 用来存储下一个结点对象的地址
public Node next;
// 构造方法
public Node()
this(null, null);
public Node(E data)
this(data, null);
public Node(E data, Node next)
this.data = data;
this.next = next;
@Override
public String toString()
return data.toString();
// 链表元素的数量
private int size;
//链表当中的头指针指向第一个结点对象
private Node head;
//链表当中的头指针指向最后一个结点对象
private Node tail;
// 初始化链表
public LinkedSinglyList()
head = null;
tail = null;
size = 0;
public LinkedSinglyList(E[] arr)
for (E e : arr)
add(e);
/***
* 在链表末尾添加新的元素e
* @param element
*/
@Override
public void add(E element)
add(size, element);
/***
* 根据链表的index位置添加新的元素e
* @param index
* @param element
*/
@Override
public void add(int index, E element)
if (index < 0|| index > size)
throw new ArrayIndexOutOfBoundsException("add index out of bounds");
// 创建新的结点对象
Node node = new Node(element);
if(isEmpty())
// 链表为空
head = node;
tail = node;
else if(index == 0)
// 在链表头部添加元素
node.next = head;
head = node;
else if(index == size)
// 在链表尾部添加元素
tail.next = node;
tail = node;
else
// 在链表中添加元素
Node prev = head;
for(int i=0; i < index -1; i++)
prev = prev.next;
node.next = prev.next;
prev.next = node;
size++;
@Override
public int size()
return size;
/***
* 判断链表是否为空
* @return
*/
@Override
public boolean isEmpty()
return size == 0 && head == null && tail == null;
@Override
public void clear()
head = null;
tail = null;
size = 0;
@Override
public String toString()
StringBuilder res = new StringBuilder();
res.append("size=").append(size).append(", [");
// 定义一个指针变量
Node cur = head;
while(cur != null)
res.append(cur + "->");
cur = cur.next;
res.append("NULL");
res.append("]");
return res.toString();
/***
* 迭代器实现
* @return
*/
@Override
public Iterator<E> iterator()
return new LinkedListIterator();
class LinkedListIterator implements Iterator<E>
// 定义游标
private Node cur = head;
@Override
public boolean hasNext()
return cur != null;
@Override
public E next()
E ret = cur.data;
cur = cur.next;
return ret;
3、测试代码:LinkedSinglyListDemo
package cn.linkedlist.demo01;
public class LinkedSinglyListDemo
public static void main(String[] args)
LinkedSinglyList<Integer> linkedList = new LinkedSinglyList<>();
System.out.println("===链表头部插入===");
linkedList.add(0,1);
linkedList.add(0,3);
linkedList.add(0,5);
linkedList.add(0,8);
System.out.println(linkedList);
System.out.println("==链表尾部插入==");
linkedList.add(12);
System.out.println(linkedList);
System.out.println("===链表中间插入===");
linkedList.add(2, 23);
System.out.println(linkedList);
4、执行结果
1.4 查询和修改
1、查询操作
链表：SingleLinkedList
/***
* 得链表的第index个位置的元素
* @param index
* @return
*/
@Override
public E get(int index)
if (index < 0|| index > size)
throw new ArrayIndexOutOfBoundsException("get index out of bounds");
// 获取头部
if(index == 0)
return head.data;
else if(index == size -1)
// 获取尾部
return tail.data;
else
// 获取中间
Node prev = head;
for (int i = 0; i < index; i++)
prev = prev.next;
return prev.data;
/***
* 查找元素在链表中第一次出现的索引
* @param element
* @return
*/
@Override
public int indexOf(E element)
// 判断链表是否为空
if(isEmpty())
return -1;
// 定义prev指针
Node prev = head;
// 定义索引值
int index = 0;
while (!prev.data.equals(element))
prev = prev.next;
index++;
// 如果没有找到，则返回-1
if(prev == null)
return -1;
return index;
/***
* 查找链表中是否有元素element
* @param element
* @return
*/
@Override
public boolean contains(E element)
return indexOf(element)!= -1;
测试代码:LinkedSinglyListDemo
package cn.linkedlist.demo01;
public class LinkedSinglyListDemo
public static void main(String[] args)
LinkedSinglyList<Integer> linkedList = new LinkedSinglyList<>();
System.out.println("===插入元素===");
linkedList.add(0,1);
linkedList.add(0,3);
linkedList.add(0,5);
linkedList.add(0,8);
linkedList.add(12);
linkedList.add(2, 23);
System.out.println(linkedList);
System.out.println("===查找元素===");
Integer integer = linkedList.get(2);
System.out.println("通过索引获取元素:" + integer);
boolean b = linkedList.contains(23);
System.out.println("是否存在该元素:" + b);
int element = linkedList.indexOf(12);
System.out.println("该元素的索引:" + element);
2、执行结果
3、修改节点
找到要更新的节点，然后把旧数据替换成新数据。
4、代码示例
链表：LinkedSinglyList
/***
* 修改链表中指定index的元素为element
* @param index
* @param element
* @return
*/
@Override
public E set(int index, E element)
if (index < 0|| index > size)
throw new ArrayIndexOutOfBoundsException("update index out of bounds");
// 定义返回值
E result = null;
if(index == 0)
// 修改头部
result= head.data;
head.data = element;
else if(index == size -1)
// 修改尾部
result = tail.data;
tail.data = element;
else
// 修改中间的元素
Node prev = head;
for (int i = 0; i < index; i++)
prev = prev.next;
result = prev.data;
prev.data = element;
return result;
测试代码:LinkedSinglyListDemo
package cn.linkedlist.demo01;
public class LinkedSinglyListDemo
public static void main(String[] args)
LinkedSinglyList<Integer> linkedList = new LinkedSinglyList<>();
System.out.println("===插入元素===");
linkedList.add(0,1);
linkedList.add(0,3);
linkedList.add(0,5);
linkedList.add(0,8);
linkedList.add(12);
linkedList.add(2, 23);
System.out.println(linkedList);
System.out.println("===修改节点元素===");
System.out.println("LinkedSinglyList(修改前)" + linkedList);
linkedList.set(4, 38);
System.out.println("LinkedSinglyList(修改后)" + linkedList);
5、执行结果
1.5 删除操作
1、思路分析
把要删除节点的前置节点的next指针，指向要删除元素的下一个节点即可。
删除头结点
head 指向下一个元素
然后让之前的元素断开
删除尾节点
定义一个prev指针,直接找到尾节点前面那个元素。
让当前prev的下一个元素，执行置空操作。
然后让尾指针指向该元素
删除中间元素
先找到要删除节点的前驱，让删除节点前一个元素指向要删除元素的后继
然后将要删除节点的后继置空
链表只有一个元素
直接让head 和tail置空即可
2、代码示例
链表：LinkedSinglyList
/***
* 删除链表中指定的元素element
* @param element
*/
@Override
public void remove(E element)
int index = indexOf(element);
if(index != -1)
remove(index);
/***
* 删除链表中指定索引处index的元素
* @param index
* @return
*/
@Override
public E remove(int index)
if (index < 0|| index > size)
throw new ArrayIndexOutOfBoundsException("remove index out of bounds");
// 定义返回值
E result = null;
// 当链表只剩下一个元素
if(size == 1)
result = head.data;
head = null;
tail = null;
else if(index == 0)
// 删除链表头部
Node prev = head;
result 以上是关于单向链表实现的主要内容，如果未能解决你的问题，请参考以下文章