链表-----Java中LinkedList类的实现

目录

一、链表的简单介绍

1,单链表

2,双链表

二、LinkedList类的实现详解

1,MyLinkedList类设计思路

1.1 实现的功能:

1.2 头尾节点的引入

2、MyLinkedList类详细解析

2.1 Node类

2.2 doClear()方法 

2.3 addBefore方法

2.4 getNode方法

2.5 迭代器中方法的实现

2.6 删除节点的实现

三、一些想说的


 

一、链表的简单介绍

1,单链表

        

        链表由一系列节点组成,这些节点不必在内存中相连。每个节点包含一个元素(A1,A2,...)和

一条指向下一节点的链。单链表,顾名思义,一个节点存在一条链指向下一节点,最后一个节点的链则指向null。

 

2,双链表

         双链表,相较于单链表,不仅有一根指向后一节点的链(next),还多了一根指向前一节点的链(prev)。

        我们今天要实现的LinkedList类则是基于双链表的。

二、LinkedList类的实现详解

LinkedList类是Java已存在的一个类,我们自己去设计并实现他,这里将其命名为MyLinkedList类,并且使用到泛型去实现。

1,MyLinkedList类设计思路

1.1 实现的功能:

add(e) 

add(int idx,e) 

添加元素的操作
remove(int idx)删除元素
size()返回表大小
get(int idx)获得索引处元素的值
set(int idx, e)设置索引元素处的值
clear()清空链表
iterator()迭代器,可用于遍历表


 

1.2 头尾节点的引入

        在链表的头和尾引入头节点和尾节点,分别表示链表开始和结束,头节点不包含指向前驱元素的链,而尾节点不存在指向后驱元素的链,至于其原因,在实现删除元素功能时,会详解,先记住有这个头尾的引入。

2、MyLinkedList类详细解析

这部分将采用代码+图解的形式去解析各个功能的实现

首先提供完整代码,对这个类的全局有个认知,可以尝试去阅读这个源码,布局可能有点乱,因为笔者也是萌新一枚QAQ

import java.util.*;

public class MyLinkedList<AnyType> implements Iterable<AnyType> {

    private int theSize;
    private int modCount = 0;
    private Node<AnyType> beginMarker;
    private Node<AnyType> endMarker;

    @Override
    public Iterator<AnyType> iterator() {
        return new LinkedListIterator();
    }

    private class LinkedListIterator implements Iterator<AnyType>{
        private Node<AnyType> current = beginMarker.next;
        private int expectedModCount = modCount;
        private boolean okToRemove = false;

        @Override
        public boolean hasNext() {
            return current != endMarker;
        }

        @Override
        public AnyType next() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            if (!hasNext())
                throw new NoSuchElementException();

            AnyType nextItem = current.data;
            current = current.next;
            okToRemove = true;
            return nextItem;
        }

        @Override
        public void remove() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            if (!okToRemove)
                throw new IllegalStateException();

            MyLinkedList.this.remove(current.prev);
            expectedModCount++;
            okToRemove = false;
        }
    }


    //Node类
    private static class Node<AnyType>{
        public AnyType data;
        public Node<AnyType> prev;
        public Node<AnyType> next;

        public Node(AnyType d, MyLinkedList.Node<AnyType> p, MyLinkedList.Node<AnyType> n){
            data = d;
            prev = p;
            next = n;
        }
    }

    public MyLinkedList(){
        doClear();
    }

    public void clear(){
        doClear();
    }

    public int size(){
        return theSize;
    }

    public boolean isEmpty(){
        return size() == 0;
    }

    public boolean add(AnyType x){
        add(size(),x);
        return true;
    }

    public boolean add(int idx, AnyType x){
        addBefore(getNode(idx,0,size()), x);
        return true;
    }

    public AnyType get(int idx){
        return getNode(idx).data;
    }

    public AnyType set(int idx,AnyType newVal){
        Node<AnyType> p = getNode(idx);
        AnyType oldVal = p.data;
        p.data = newVal;
        return oldVal;
    }

    public AnyType remove(int idx){
        return remove(getNode(idx));
    }


    private void addBefore(Node<AnyType> p, AnyType x){
       Node<AnyType> newNode = new Node<>(x, p.prev,p);
       newNode.prev.next = newNode;
       p.prev = newNode;
       theSize++;
       modCount++;
    }

    private AnyType remove(Node<AnyType> p){
        p.next.prev = p.prev;
        p.prev.next = p.next;
        theSize--;
        modCount++;

        return p.data;
    }

    private Node<AnyType> getNode(int idx){
        return getNode(idx, 0, size()-1);
    }

    private Node<AnyType> getNode(int idx, int lower, int upper){
        Node<AnyType> p;

        if (idx < lower || idx > upper)
            throw new IndexOutOfBoundsException();

        if (idx < size()/2){
            p = beginMarker.next;
            for (int i =0; i < idx; i++)
                p = p.next;
        }else {
            p = endMarker;
            for (int i = size(); i > idx ; i--) {
                p = p.prev;
            }
        }

        return p;
    }



    private void doClear(){
        beginMarker = new Node<AnyType>(null,null,null);
        endMarker = new Node<AnyType>(null,beginMarker,null);
        beginMarker.next = endMarker;

        theSize = 0;
        modCount++;
    }


}

2.1 Node类

在53~63行处,创建了一个Node类,即我们的节点

//Node类
    private static class Node<AnyType>{
        public AnyType data;
        public Node<AnyType> prev;
        public Node<AnyType> next;
 
        public Node(AnyType d, MyLinkedList.Node<AnyType> p, MyLinkedList.Node<AnyType> n){
            data = d;
            prev = p;
            next = n;
        }
    }

其中包含三个变量和一个构造器: 

data        节点上的数据
prev        指向前驱元素的链
next        指向后驱元素的链

Node构造器需要接收三个参数:数据d,指向前驱的链p,指向后驱的链n。

2.2 doClear()方法 

        在65行,可以看到MyLinkedList的构造器调用了一个doClear()(150~157行)的私有方法,包括clear()方法也是调用了doClear(),

public MyLinkedList(){
        doClear();
    }
 
    public void clear(){
        doClear();
    }
private void doClear(){
        beginMarker = new Node<AnyType>(null,null,null);
        endMarker = new Node<AnyType>(null,beginMarker,null);
        beginMarker.next = endMarker;
 
        theSize = 0;
        modCount++;
    }

        doClear()的实际作用就是上文提到的创建一个头,尾节点,并且将链表长度改为0。 

 

 

endMarker = new Node<AnyType>(null,beginMarker,null);

尾节点指向前驱元素的链指向头节点,第二个参数为beginMarker 完成了2操作。

beginMarker.next = endMarker;

这行则完成了1操作,将头节点指向后驱元素的链指向了尾节点。

modCount将会在迭代器部分进行详解,可以先跳过该语句。

2.3 addBefore方法

        在107~113行,提供了一个addBefore()私有方法用于添加节点到表中,add()方法就是通过调用它来实现的。

private void addBefore(Node<AnyType> p, AnyType x){
       Node<AnyType> newNode = new Node<>(x, p.prev,p);
       newNode.prev.next = newNode;
       p.prev = newNode;
       theSize++;
       modCount++;
    }

 

第一步,先创建一个新节点newNode,其中包含数据x,指向前驱元素(b)的prev链(p.prev指的就是b这个节点),和指向后驱元素的next链。(完成了1,2的操作)

第二步,让b这个节点(newNode.prev)的next链指向newNode(所标的3)

第三步,将p节点的前驱元素的prev链指向newNode(所标的4),并将链表长度加1,完成节点的添加

两种add方法

//在链表末尾添加一个节点
public boolean add(AnyType x){
        add(size(),x);
        return true;
    }

//根据索引添加节点
 
public boolean add(int idx, AnyType x){
        addBefore(getNode(idx,0,size()), x);
        return true;
    }

2.4 getNode方法

在add方法中出现了一个getNode方法,getNode通过提供索引返回所查找的节点。

private Node<AnyType> getNode(int idx){
        return getNode(idx, 0, size()-1);
    }
 
private Node<AnyType> getNode(int idx, int lower, int upper){
        Node<AnyType> p;
         //安全性校验
        if (idx < lower || idx > upper)
            throw new IndexOutOfBoundsException();
 
        if (idx < size()/2){
            //找前半段
            p = beginMarker.next;
            for (int i =0; i < idx; i++)
                p = p.next;
        }else {
            //找后半段 倒序查找
            p = endMarker;
            for (int i = size(); i > idx ; i--) {
                p = p.prev;
            }
        }
 
        return p;
    }

其中分为前后两段去查找节点,减少了查找的次数。

get和set方法就调用此方法去实现

public AnyType get(int idx){
        return getNode(idx).data;
    }
 
public AnyType set(int idx,AnyType newVal){
        Node<AnyType> p = getNode(idx);
        AnyType oldVal = p.data;
        p.data = newVal;
        return oldVal;
    }

2.5 迭代器中方法的实现

 @Override
    public Iterator<AnyType> iterator() {
        return new LinkedListIterator();
    }
 
    private class LinkedListIterator implements Iterator<AnyType>{
        private Node<AnyType> current = beginMarker.next;
        private int expectedModCount = modCount;
        private boolean okToRemove = false;
 
        @Override
        public boolean hasNext() {
            return current != endMarker;
        }
 
        @Override
        public AnyType next() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            if (!hasNext())
                throw new NoSuchElementException();
 
            AnyType nextItem = current.data;
            current = current.next;
            okToRemove = true;
            return nextItem;
        }
 
        @Override
        public void remove() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            if (!okToRemove)
                throw new IllegalStateException();
 
            MyLinkedList.this.remove(current.prev);
            expectedModCount++;
            okToRemove = false;
        }
    }

modCount的引入:

        modCount代表自从构造器以来对链表所做改变的次数,每次对add和remove的调用都将更新modCount。其想法在于,当一个迭代器被建立时,他将存储集合的modCount。每次对一个迭代器方法(next或remove) 的调用都将用该链表内当前的modCount检测迭代器所存储的modCount,并且当这两个数不匹配时,抛出一个ConcurrentModificationException异常。

2.6 删除节点的实现

private AnyType remove(Node<AnyType> p){
        p.next.prev = p.prev;
        p.prev.next = p.next;
        theSize--;
        modCount++;
 
        return p.data;
    }

p.next.prev指的是节点d的prev链指向前驱元素,将其修改为了p.prev,即指向了节点b。

另外一条链的删除和这个类似,不再叙述。

三、一些想说的

        有部分较为简单的功能,未展开详解,就交给聪明的你们啦,有许多疏漏和错误的地方还望大家批评指正。

        测试部分的代码未给出,这个就留给大家自己去测了主要还是因为作者太懒,这个类实现参考了《数据结构与算法分析---Java语言描述》一书,有兴趣的朋友可以去看看,里面的代码和思路及其优雅,使得编程更像是一门艺术,而不是枯燥乏味的yi'hang'ha

  • 0
    点赞
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

压力小子呀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值