常见数据结构与算法专题篇之单向链表

因为不是CS科班，一个科研狗偏偏要来码代码，以前没有系统学习过数据结构和算法的知识，后期实践中越来越觉得基础的重要，所以近期开始来刷一波儿基础的数据结构和算法的知识。以下内容是我整理总结的，如果有错误，欢迎指出

链表

链表是一种物理储存结构上非连续、非顺序的储存结构。数据元素的逻辑顺序是依靠链表中指针链接次序实现的。链表有一系列节点组成，这些节点在内存中不必相连。这些节点有数据部分Data和链表指针部分Next组成，其中Next指向下一个节点。这样节点的状态改变可以通过改变指针的指向来实现，效率很高。

这里主要以单链表来说明链表实现基本思路

1. 一个简单的链表示例

首先定义Node类作为数据的载体。
Node 类中需要完成的操作就是添加Node 和输出数据的方法。这里我们先假设数据就是String 数据。我们往Node类添加这两个方法。

class Node {
    private String data;
    private Node next;

    public Node(String data) {
        this.data = data;
    }

    public void setNext(Node next) {
        this.next = next;
    }

    public String getData() {
        return data;
    }

    public Node getNext() {
        return next;
    }

    /**
     * 添加下一个节点
     * @param newNode
     */
    public void addNode(Node newNode){
        if(this.next==null){
            this.next=newNode;
        }else {
            this.next.addNode(newNode);
        }
    }

    /**
     * 输出节点数据，这里以简单输出数据
     */
    public void printNode(){
        System.out.println(this.data);
        if(this!=null){
            this.next.printNode();
        }
    }
}

我们还需要专门定义一个Link类的对象专门操作Node。Link中我们需要保存一个根节点，根节点作为链表的头。

class Link{
    private Node root;
    public void add(String data){
        Node newNode=new Node(data);//数据必须要封装在节点中，封装之后才可以操作数据。
        if(this.root==null){
            this.root=newNode;
        }else {
            this.root.addNode(newNode);
        }
    }
    public void print(){
        if(this.root!=null){
            this.root.printNode();
        }
    }
}

以上我们定义了一个Link 类，主要是要把数据封装在Node 中，通过Link 类操作Node ,避免直接操作Node 数据。

这里我们给出这个简单链表类的完整程序（包含main函数中示例数据）。

class Node {
    private String data;
    private Node next;

    public Node(String data) {
        this.data = data;
    }

    public void setNext(Node next) {
        this.next = next;
    }

    public String getData() {
        return data;
    }

    public Node getNext() {
        return next;
    }

    /**
     * 添加下一个节点
     * @param newNode
     */
    public void addNode(Node newNode){
        if(this.next==null){
            this.next=newNode;
        }else {
            this.next.addNode(newNode);
        }
    }

    /**
     * 输出节点数据，这里以简单输出数据
     */
    public void printNode(){
        System.out.println(this.data);
        if(this.next!=null){
            this.next.printNode();
        }
    }
}
class Link{
    private Node root;
    public void add(String data){
        Node newNode=new Node(data);//数据必须要封装在节点中，封装之后才可以操作数据。
        if(this.root==null){
            this.root=newNode;
        }else {
            this.root.addNode(newNode);
        }
    }
    public void print(){
        if(this.root!=null){
            this.root.printNode();
        }
    }
}


public class simpleLink {
    public static void main(String[] args){
        Link all=new Link();
        all.add("data1");
        all.add("data2");
        all.add("data3");
        all.print();
    }
}

这里为了展示链表的基本操作形式只给出了最简单的一个链表的示例。代码并不具备实用性，数据是直接进行输出的,以上的代码没有真正对Node类进行很好的封装，用户可以直接操作Node类。

2. 进一步完善链表并添加相应方法

我们通过定义内部内类的方式把Node类数据进行封装（这里我们还是以储存String 数据为例）。ps:这里我本来想说这是某种设计模式，但是并没有学过设计模式啥的，等后来把设计模式看了再来完善一下吧。^^大神求放过。

这里我们贴出代码

public class Link {//用户主要关注Link类
   private Node root;//保存根节点
   private class Node{//定义内部类Node，定义内部内的不仅仅对Node类进行了很好的封装，而且Node 类可以直接访问外部内的数据
       private String data;
       private Node next;

       public Node(String data) {
           this.data = data;
       }

       public void setNext(Node next) {
           this.next = next;
       }
       public Node getNext(){
           return this.next;
       }

   }
}

2.1 Link类添加增加和取出数据的操作

通过Link 类中新增add()方法实现数据的添加

public void add(String data){
       Node newNode=new Node(data);
       if(this.root==null){//首先判断root节点是否为空，如果root为空就把新建立的节点设为root节点
           this.root=newNode;
       }else{
           this.root.addNode(newNode);//如果root不为空，将添加交给Node类的addNode方法去处理
       }

Link类中确定根节点，然后调用Node的addNode() 方法来实现数据添加

public void addNode(Node newNode){
           if(this.next==null){
               this.next=newNode;//如果root的下一个节点为空，新节点就加到root后
           }else {
               this.next.addNode(newNode);//如果root的下一个不为空，就判断下一个的下一个，递归
           }
       }

2.2 取得保存对象的个数

Link 类中定义一个count 的变量，对对象数量进行记录。每次添加数据或者删除数据后相应地改变count的值。这样要知道保存多少对象的花就可以直接取出count的值。

定义size()方法

    private int count;//用来保存对象数量
    public int size(){
        return this.size();//返回对象的数量
    }

要注意是，在add()方法中记得添加this.count++，这样再每次添加数据后count值就相应改变。

2.3 判断是否为空链表

如果我们通过判断count是否为0就可以判断链表是否为空了。

public boolean isEmpty(){
        return this.count==0;//如果个数为0 则返回ture，反之false。
    }

2.4 清空链表

整个链表中最关键的就是Link 类的root ,如果我们把root 直接指向null, 那么整个链表就是null了。

public void clean(){
        this.root=null;
        this.count=0;//注意清空链表后count归零
    }

2.5 取得链表中制定索引位置的数据

首先在Link中增加foot属性，用来标记链表索引。然后在Link中增加 get(int index) 方法，用来得到制定索引的数据。

private int foot;
public String get(int index){
        if(index>this.count){
            return null;
        }
        this.foot=0;
        return this.root.getNode(index);//交给Node类中getNode()方法处理。
    }

在Node 类中定义getNode()方法，进行查询并修改foot属性的内容，内部类可以很方便访问外部内属性。

public String getNode(int index){
            if(index==Link.this.foot++){
                return this.data;
            }else{
                return this.next.getNode(index);
            }
        }

2.6 判断制定数据是否存在

首先在Link类中定义一个contains()方法，这个方法首先要判断数据是否为null，如果不为null 继续把判断交给Node类处理。

定义contains()方法

public boolean contains(String data){
        if(data==null){
            return false;
        }
        return this.root.containsNode(data);
    }

在Node类中定义containsNode方法

public boolean containsNode(String data){
            if(data.equals(this.data)){//这里用equals()方法，后期便于扩展数据类型
                return true;
            }
            if(this.next==null){
                return false;
            }else{
                return this.next.containsNode(data);
            }
        }

2.7 删除数据

Link 类中定义remove()方法用于删除节点数据。首先判断要删除的数据是否是根节点，如果是根节点的话就在Link中直接将根节点指向下一个节点。如果删除的不是根节点，则将操作交给Node类去处理。

    public void remove(String data){
        if(data.equals(this.root.data)){
            this.root=this.root.next;//改变根节点指向下一个
        }else{
            this.root.next.removeNode(this.root,data);
        }
        this.count--;
    }

在Node类中定义removeNode()方法，如果某个节点与要删除的数据匹配，那么改节点的前一个节点的next应该指向该匹配节点的下一个节点。如示意图:

定义removeNode()方法

public void removeNode(Node prev,String data){
            if(data.equals(this.data)){
                prev.next=this.next;
            }else {
                this.next.removeNode(this,data);
            }
        }

2.8 返回所有数据

返回所有的数据并保存为对象数组的形式，对象数组必须对用户可见，所以在Link中定义。在Link 中定义toArray()方法，将所有数据以对象数组方式返回。

定义对象数组和 toArray()方法。

private String[] retData;
public String[] toArray(){
        if(this.count==0){
            return null;
        }
        this.foot=0;//设置数组的索引
        this.retData=new String[this.count];
        this.root.toArrayNode();
        return this.retData;
    }

定义toArrayNode()方法，主要是把链表数据取出保存在对象数组中。

public void toArrayNode(){
            Link.this.retData[Link.this.foot++]=this.data;
            if(this.next!=null){
                this.next.toArrayNode();
            }
        }

完整的程序清单

public class Link{
    private class Node {
        private String data;
        private Node next;

        public Node(String data) {
            this.data = data;
        }

        public void addNode(Node node) {
            if (this.next == null) {
                this.next=node;
            } else {
                this.next.addNode(node);
            }
        }

        public void printNode() {
            System.out.println(this.data);
            if (this.next != null) {
                this.next.printNode();
            }
        }
        public String getNode(int index){
            if(index==Link.this.foot++){
                return this.data;
            }else{
                return this.next.getNode(index);
            }
        }
        public boolean containsNode(String data){
            if(data==this.data){
                return true;
            }else {
                if(this.next!=null){
                    return this.next.containsNode(data);
                }else{
                    return false;
                }

            }
        }
        public void removeNode(Node previous,String data){
            if(this.data.equals(data)){
                previous.next=this.next;
            }else {
                this.next.removeNode(this,data);
            }
        }
        public void toArrayNode(){
            Link.this.retData[Link.this.foot++]=this.data;
            if(this.next!=null){
                this.next.toArrayNode();
            }

        }
    }
    private Node root;
    private int count=0;
    private int foot;
    private String[] retData;
    public void add(String data){//向链表中增加数据
        Node newNode=new Node(data);
        if(data==null) return;

        if(this.root==null){
            this.root=newNode;
        }else{
            this.root.addNode(newNode);
        }
        this.count++;
    }
    public void print(){
        if(this.root!=null){
            this.root.printNode();
        }
    }
    public int size(){//链表的大小
        return this.count;
    }
    public boolean isEmpty(){//判断是否为空链表
        return this.count==0;
    }
    public void clean(){//清空链表
        this.root=null;
        this.count=0;
    }
    public String get(int index){
        if(index>this.count){
            return null;
        }else{
            return this.root.getNode(index);
        }

    }
    public boolean contains(String data){
        if(data==null){
            return false;
        }
        return this.root.containsNode(data);
    }
    public void remove(String data){
        if(this.contains(data)){
            if(this.root.data==data){
                this.root=this.root.next;
            }else {
                this.root.next.removeNode(this.root,data);
            }
        }
    }
    public String[] toArray(){
        if(this.count==0){
            return null;
        }
        this.foot=0;
        this.retData=new String[this.count];
        this.root.toArrayNode();
        return this.retData;
    }
}

基本链表的方法都写得差不多了,以上链表为了展示链表结构是以String数据为例。实际使用的大多是用户自定义的对象。

3. 进一步完善简单链表

以上链表中是以保存的String 类型的数据为例的，但是实际生活中更多的是保存用户自己定义的简单JavaBean类对象。我们不想每次定义了Bean类时每次都重新根据这个类来写一个链表，这样不符合代码去重复的初衷。在这里我们通过java 中泛型的特性来改写以上的链表，这样当需要保存用户不同的类对象数据时我们只需要指定相应地泛型类型。

在以上的链表中我们查询数据和删除数据依靠的是String 的equals() 方法，这个方法的实际作用是对象比较，用户指定泛型对象时必须要覆写对象的compare()方法，指定比较规则。

定义泛型的Link类并改写链表，由于基本思路大致相同，所以在这里我们直接贴出完整代码。

public class Link<T>{
    private class Node {
        private T data;
        private Node next;

        public Node(T data) {
            this.data = data;
        }

        public void addNode(Node node) {
            if (this.next == null) {
                this.next=node;
            } else {
                this.next.addNode(node);
            }
        }

        public void printNode() {
            System.out.println(this.data);
            if (this.next != null) {
                this.next.printNode();
            }
        }
        public T getNode(int index){
            if(index==Link.this.foot++){
                return this.data;
            }else{
                return this.next.getNode(index);
            }
        }
        public boolean containsNode(T data){
            if(data==this.data){
                return true;
            }else {
                if(this.next!=null){
                    return this.next.containsNode(data);
                }else{
                    return false;
                }

            }
        }
        public void removeNode(Node previous,T data){
            if(this.data.equals(data)){
                previous.next=this.next;
            }else {
                this.next.removeNode(this,data);
            }
        }
        public void toArrayNode(){
            Link.this.retData.add(this.data);
            //Link.this.retData[Link.this.foot++]=this.data;
            if(this.next!=null){
                this.next.toArrayNode();
            }

        }
    }
    private Node root;
    private int count=0;
    private int foot;
    private ArrayList<T> retData;//定义一个ArrayList<T>来保存链表全部数据
    public void add(T data){//向链表中增加数据
        Node newNode=new Node(data);
        if(data==null) return;

        if(this.root==null){
            this.root=newNode;
        }else{
            this.root.addNode(newNode);
        }
        this.count++;
    }
    public void print(){
        if(this.root!=null){
            this.root.printNode();
        }
    }
    public int size(){//链表的大小
        return this.count;
    }
    public boolean isEmpty(){//判断是否为空链表
        return this.count==0;
    }
    public void clean(){//清空链表
        this.root=null;
        this.count=0;
    }
    public T get(int index){
        if(index>this.count){
            return null;
        }else{
            return this.root.getNode(index);
        }

    }
    public boolean contains(T data){
        if(data==null){
            return false;
        }
        return this.root.containsNode(data);
    }
    public void remove(T data){
        if(this.contains(data)){
            if(this.root.data==data){
                this.root=this.root.next;
            }else {
                this.root.next.removeNode(this.root,data);
            }
        }
    }
    public ArrayList<T> toArray(){
        if(this.count==0){
            return null;
        }
        this.foot=0;
        this.retData=new ArrayList<T>(this.count);
        this.root.toArrayNode();
        return this.retData;
    }
}

以上就是我们改写的链表代码。值得注意的是前面String数据我们通过把链表数据赋给对象数组retData[]来取出数据。在定义了泛型后，没办法进行 T[] retData=new T[this.count]这样类似的初始化一个对象数组。后来在网上看到有人通过T[] retData=(T[])new object[this.count]来进行初始化，但是这种方法可能隐含着ClassCastException的报错。

链表还有很多其他的实现方式，常见的有循环单链表、双向链表、循环双链表。循环单链表实际上就是上面我们链表的最后一个节点指向第一个节点，整体构成一个链环。双向链表主要是链表中包含两个指针，一个指向前驱元，一个指向后继元(LinkList就是双向链表)，循环双向链表就是最后一个节点指向第一个节点。

文中的一部分内容是参考了网易云课堂李兴华老师的java课程。这个课程很适合想要入门Java的初学者，内容很全面。

最后编辑于：2017.12.08 15:38:09

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 159,569评论 4赞 363
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 67,499评论 1赞 294
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 109,271评论 0赞 244
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 44,087评论 0赞 209
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 52,474评论 3赞 287
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 40,670评论 1赞 222
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 31,911评论 2赞 313
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 30,636评论 0赞 202
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 34,397评论 1赞 246
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 30,607评论 2赞 246
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 32,093评论 1赞 261
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 28,418评论 2赞 254
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 33,074评论 3赞 237
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 26,092评论 0赞 8
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 26,865评论 0赞 196
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 35,726评论 2赞 276
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 35,627评论 2赞 270