双向链表实现

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后驱指向newNodenewNode前驱指向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的前驱节点preNodepreNode.next是要删除的节点

preNode.next.next.pre=preNode,将待删除deleteNode的后驱节点nextNodeprev指针指向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 --;
    
以上是关于双向链表实现的主要内容,如果未能解决你的问题,请参考以下文章

代码模板实现双向链表的去重拼接合并排序

代码解析双向链表实现贪吃蛇游戏!简单易学,开发自己第一个游戏!

代码解析双向链表实现贪吃蛇游戏!简单易学,开发自己第一个游戏!

链表的java实现(单向双向链表,单向链表的反转)

链表的java实现(单向双向链表,单向链表的反转)

双向链表的实现(双向链表与单向链表的简单区别联系和实现)