双向链表实现
Posted guardwhy
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了双向链表实现相关的知识，希望对你有一定的参考价值。
1.1 基本介绍
1、单向链表优缺点
- 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。
- 单向链表不能自我删除，需要靠辅助节点 ，而双向链表则可以自我删除。
2、双向链表基本介绍
双向链表也叫双向表，是链表的一种，它由多个结点组成，每个结点都由一个数据域和两个指针域组成，数据域(data)用来存储数据，其中一个指针域(next)用来指向其后继结点，另一个指针域用来指向前驱结点(prev指针)。链表的头结点的数据域不存储数据，指向前驱结点的指针域值为null，指向后继结点的指针域指向第一个真正存储数据的结点。
1.2 添加操作
1、思路分析
头部插入
-
新建插入节点
newNode。 -
first前驱指向newNode。 -
newNode后驱指向first。 -
first指向newNode，这时候head只是表示第二个节点，而head需要表示第一个节点故改变指向。
尾部插入
- 新建插入节点
newNode。 newNode前驱指向last。last后驱指向newNode。last指向newNode，这时候last只是表示倒数第二个节点，而last需要表示最后节点故指向newNode。
中间插入
新建插入节点newNode
找到要插入newNode的前一个节点preNode。和后一个节点nextNode
newNode后驱指向nextNode,nextNode前驱指向newNode，此时newNode和后面与链表已经联立，但是和前面处理分离状态。
preNode后驱指向newNode，newNode前驱指向preNode，此时插入完整操作完毕。
2、代码示例
链表类：DoubleLinkedList
package cn.linkedlist.demo03;
public class DoubleLinkedList<E>
// 链表元素的数量
private int size;
// 声明头结点
private Node first;
// 声明尾节点
private Node last;
// 创建Node节点
private class Node
// 存放内容
public E data;
// 指向链表的上一个节点
public Node prev;
// 指向下一个节点
public Node next;
// 构造方法
public Node()
public Node(Node prev, E data, Node next)
this.prev = prev;
this.data = data;
this.next = next;
@Override
public String toString()
return data.toString();
// 初始化头结点
public DoubleLinkedList()
first = null;
last = null;
size = 0;
/***
* 获取链表中的元素个数
* @return
*/
public int getSize()
return size;
/***
* 返回链表是否为空
* @return
*/
public boolean isEmpty()
return size == 0;
/***
* 根据链表的index位置添加新的元素e
* @param index
* @param data
*/
public void add(int index, E data)
// 调用方法
rangeCheckAdd(index);
if (index == size) // 往最后面添加元素
addLast(data);
else if(index == 0)
addLast(data);
else
// 新添加节点下一个元素
Node nextNode = node(index);
// 新添加节点的上一个元素
Node prevNode = nextNode.prev;
// 新添加节点
Node newNode = new Node (prevNode, data, nextNode);
// next节点的上一个prev指向新节点
nextNode.prev = newNode;
// prevNode节点的下一个next指向新节点
prevNode.next = newNode;
size++;
/***
* 在链表头添加新的元素e
* @param data
*/
public void addFirst(E data)
// 创建一个新节点
Node newNode = new Node(null, data, null);
if(isEmpty())
last = newNode; // last -> newNode
else
first.prev = newNode; // first.prev->newNode
newNode.next = first; // newNode.next -> first;
first = newNode;
size++;
/***
* 在链表末尾添加新的元素e
* @param data
*/
public void addLast(E data)
// 创建一个新节点
Node newNode = new Node(null, data, null);
if(isEmpty())
first = newNode; // first->newNode
else
last.next = newNode; // last指向的节点指向新节点
newNode.prev = last; // 新节点的前驱指向last指针
last = newNode; // last指针指向新节点
size++;
/**
* 获取index位置对应的节点对象
* @param index
* @return
*/
private Node node(int index)
rangeCheck(index);
Node node;
if (index < (size >> 1))
node = first;
for (int i = 0; i < index; i++)
node = node.next;
else
node = last;
for (int i = size - 1; i > index; i--)
node = node.prev;
return node;
@Override
public String toString()
StringBuilder res = new StringBuilder();
res.append("size=").append(size).append(", [");
// 定义一个指针变量
Node cur = first;
while(cur != null)
res.append(cur + "->");
cur = cur.next;
res.append("NULL");
res.append("]");
return res.toString();
// 索引值检查范围方法
private void rangeCheck(int index)
if(index < 0 || index >=size)
// 调用越界处理方法
outOfBounds(index);
// 添加方法索引检查范围
private void rangeCheckAdd(int index)
if(index < 0 || index >size)
// 调用越界处理方法
outOfBounds(index);
// 数组索引越界处理
private void outOfBounds(int index)
throw new IndexOutOfBoundsException("index:" + index + ", Size:" + size);
测试类：DoubleLikedListTest
package cn.linkedlist.demo03;
public class DoubleLinkedListDemo01
public static void main(String[] args)
DoubleLinkedList<Integer> list = new DoubleLinkedList<>();
System.out.println("===链表头部插入===");
for(int i=0; i<5; i++)
list.addFirst(i);
System.out.println(list);
System.out.println("===链表尾部插入===");
list.addLast(12);
list.addLast(111);
list.addLast(123);
list.addLast(15);
System.out.println(list);
System.out.println("===链表中间插入===");
list.add(2, 23);
list.add(7, 66);
list.add(8, 39);
System.out.println(list);
3、代码示例
1.3 修改和查询操作
1、查询操作
链表类：DoubleLinkedList
/***
* 得链表的第index个位置的元素
* @param index
* @return
*/
public E get(int index)
return node(index).data;
/***
* 获得链表的第一个元素
* @return
*/
public E getFirst()
return get(0);
/***
* 获得链表的最后一个元素
* @return
*/
public E getLast()
return get(size - 1);
/***
* 查找链表中是否有元素e
* @param data
* @return
*/
public boolean contains(E data)
Node cur = first.next;
while(cur != null)
if(cur.data.equals(data))
return true;
cur = cur.next;
return false;
测试类：DoubleLikedListTest
package cn.linkedlist.demo03;
public class DoubleLinkedListDemo01
public static void main(String[] args)
DoubleLinkedList<Integer> list = new DoubleLinkedList<>();
for(int i=0; i<5; i++)
list.addFirst(i);
list.addLast(12);
list.addLast(111);
list.addLast(123);
list.addLast(15);
list.add(2, 23);
list.add(7, 66);
list.add(8, 39);
System.out.println("===查找元素===");
Integer integer = list.get(2);
System.out.println("通过索引获取元素:" + integer);
Integer first = list.getFirst();
System.out.println("第一个链表元素:" + first);
Integer last = list.getLast();
System.out.println("最后链表元素:" + last);
boolean b = list.contains(23);
System.out.println("是否存在该元素:" + b);
2、执行结果
3、修改操作
链表类：DoubleLinkedList
/***
* 修改链表的第index(0-based)个位置的元素为e
* @param index
* @param data
*/
public void update(int index, E data)
// 调用索引检测方法
rangeCheck(index);
// 创建cur指针，指向虚拟头结点
Node cur = first;
for(int i = 0 ; i < index ; i ++)
cur = cur.next;
cur.data = data;
测试类：DoubleLikedListTest
package cn.linkedlist.demo03;
public class DoubleLinkedListDemo01
public static void main(String[] args)
DoubleLinkedList<Integer> list = new DoubleLinkedList<>();
for(int i=0; i<5; i++)
list.addFirst(i);
list.addLast(12);
list.addLast(111);
list.addLast(123);
list.addLast(15);
list.add(2, 23);
list.add(7, 66);
list.add(8, 39);
System.out.println("===修改节点元素===");
System.out.println("linkedList(修改前)" + list);
list.update(4, 38);
System.out.println("linkedList(修改后)" + list);
4、执行结果
1.4 删除操作
1、思路分析
因为是双向链表，因此可以实现自我删除某个节点，直接找到要删除的这个节点。
头结点删除
first节点的后驱节点的前指针prev改为null。
first节点指向first.next，这样first就指向需要的第一个节点。
尾节点删除
尾删除就是删除双向链表中的最后一个节点，也就是尾指针所指向的那个节点，思想和头删除的思想一致。
last.prev.next=null尾节点的前一个节点(prev)的后驱节点等于null。
last = last.prev尾节点指向它的前驱节点，此时尾节点由于步骤1next已经为null，完成删除。
中间删除
找到待删除节点deleteNode的前驱节点preNode，preNode.next是要删除的节点
preNode.next.next.pre=preNode，将待删除deleteNode的后驱节点nextNode的prev指针指向preNode，等价于nextNode.pre=preNode。
preNode.next=preNode.next.next;，此时deleteNode被跳过成功删除。
2、代码示例
链表类：DoubleLinkedList
/***
* 从链表中删除index位置的元素, 返回删除的元素
* @param index
*/
public void remove(int index)
// 调用索引检测方法
rangeCheck(index);
// 条件判断
if(index == 0)
removeFirst();
else if(index == size -1 )
removeLast();
else
//删除位置的前一个元素
Node preNode = first;
for(int i=0; i < index-1; i++)
preNode = preNode.next;
//要删除位置的元素
Node deleteNode = preNode.next;
//要删除元素的下一个元素
Node nextNode = deleteNode.next;
preNode.next = nextNode;
nextNode.prev = preNode;
size--;
/***
* 从链表中删除第一个元素, 返回删除的元素
*/
public void removeFirst()
if (size == 1)
first = null;
last = null;
else
first =first.next;
size--;
/***
* 从链表中删除最后一个元素, 返回删除的元素
*/
public void removeLast()
if (size == 1)
first = null;
last = null;
else
last.prev.next = null;
last = last.prev;
size--;
/***
* 从链表中删除元素e
* @param data
*/
public void removeElement(E data)
// 创建头结点
Node prev = first;
while(prev.next != null)
if(prev.next.data.equals(data))
break;
prev = prev.next;
if(prev.next != null)
Node delNode = prev.next;
prev.next = delNode.next;
delNode.next = null;
size --;
以上是关于双向链表实现的主要内容，如果未能解决你的问题，请参考以下文章
代码解析双向链表实现贪吃蛇游戏！简单易学，开发自己第一个游戏！