链表的定义与使用

最新推荐文章于 2022-12-10 16:05:09 发布

playJavaBoy

最新推荐文章于 2022-12-10 16:05:09 发布

阅读量211

点赞数

分类专栏： Java基础学习笔记

本文链接：https://blog.csdn.net/sinat_25358009/article/details/89410372

版权

Java基础学习笔记专栏收录该内容

39 篇文章 1 订阅

订阅专栏

1. 链表的基本形式

链表主要知识点

此次的内容属于引用部分的实际应用，所以需要依赖两点：

依赖于引用传递
this表示当前对象。

链表的实现基本模式；
开发并且使用可用链。

链表基本形式

链表是一种最为简单的数据结构，它的主要目的是依靠引用关系来实现多个数据的保存。

链表模型图

范例：定义一个Node类

假设本次保存的数据是String型，同时拥有下一个引用；

//每一个链表实际上就是有多个节点所组成的
class Node {
    //定义一个节点
    private String data; //要保存的数据
    private Node next;  //要保存下一个节点
    //每一个Node类对象都必须保存有相应的数据
    public Node(String data) {  //必须有数据才有Node
        this.data = data;
    }
    public void setNext(Node next) {
        this.next = next;
    }
    public Node getNext() {
        return this.next;
    }
    public String getData() {
        return this.data;
    }
}

以上只是一个专门负责保存节点的类，具体怎么保存并不是Node类负责，需要由其它的类来负责Node的关系匹配
范例：使用第一种形式设置和取出数据

public class LinkDemo {
    public static void main(String[] args) {
        //第一步：准备出所有数据
        Node root = new Node("火车头");
        Node n1 = new Node("No1");
        Node n2 = new Node("No2");
        root.setNext(n1);
        n1.setNext(n2);
        //第二步：取出所有数据
        Node currentNode = root;    //从根节点开始读取
        while (currentNode != null) {
            System.out.println(currentNode.getData());
            //将下一个节点设置为当前节点
            currentNode = currentNode.getNext();
        }
    }
}

实际以上的操作使用的循环并不方便，最好的做法还是应该使用递归操作完成。

范例：使用第二种方式设置和取得数据

public class LinkDemo2 {
    public static void main(String[] args) {
        //第一步：准备出所有数据
        Node root = new Node("火车头");
        Node n1 = new Node("No1");
        Node n2 = new Node("No2");
        root.setNext(n1);
        n1.setNext(n2);
        print(root);
    }
    public static void print(Node current) {
        if (current == null) {
            return ;
        }
        System.out.println(current.getData());
        print(current.getNext());
    }
}

由于所有的节点并不知道具体的操作次数，所以只能用while使用，但是在节点的操作中，递归比while更加的直观。

疑问?整个代码实际上就是完成设置数据和取去数据的过程，为什么需要Node呢?
因为，数据本身不具备先后的关系，所以使用Node类的封装数据，同时利用Node类来指向下一个节点。

2. 链表的基本雏形

通过分析发现：

用户在操作的过程之中完全没有必要去Node类是否存在；
所有的节点的引用关系不应该由用户去处理，应该有一个专门的工具类来进行处理。
定义一个类，使客户端隐藏所有的链表中给出的细节操作。
范例：链表的基本形式

//每一个链表实际上就是有多个节点所组成的
class Node {
    //定义一个节点
    private String data; //要保存的数据
    private Node next;  //要保存下一个节点
    //每一个Node类对象都必须保存有相应的数据
    public Node(String data) {  //必须有数据才有Node
        this.data = data;
    }
    public void setNext(Node next) {
        this.next = next;
    }
    public Node getNext() {
        return this.next;
    }
    public String getData() {
        return this.data;
    }

    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();  
        }
    }
}

//对Node类对象的关系处理
class Link {
    //根节点
    private Node root;
    public void add(String data) {
        //为了可以设置数据的先后关系，所以将data包装在一个Node类对象
        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 LinkDemo3 {
    public static void main(String[] args) {
        //由这个类负责所有的数据操作
        Link link = new Link(); 
        link.add("hello");  //存放数据
        link.add("world");  //存放数据
        link.add("WWWW");   //存放数据
        link.print();       //展示数据
    }
}

链表的基本特点：

客户端代码不实现Node以及引用关系的细节，只使用Link类中提供的方法；
Link类的主要功能时控制Node类对象的产生和根节点；
Node类主要负责数据的保存以及引用关系的分配。

3. 开发可用链表

可以使用链表实现数据的增加、修改、删除、查询操作

1. 程序基本结构

Node类负责所有的节点数据的保存以及节点关系的匹配，所以Node类，不可能单独去使用，而以上的代码里面Node时可以单独使用的，外部可以荣国Link类直接操作Node类，这样是没有意义的；所以修改代码，是Node为内部类，只能被Link类使用。
内部类可以使用private定义，这样内部类只能被外部类使用，而且，内部类可以方便的与外部类之间进行私有属性的直接访问。
范例：链表的开发结构

class Link {    //链表类，外部能够看见的只有这一个类
    //之所以定义在内部，主要是之让Link类能调用
    private class Node {
        private String data;
        private Node next;
        public Node(String data) {
            this.data = data;
        }
        public void addNode(Node newNode) {
            if (this.next == null) {
                this.next = newNode;
            }else {
                this.next.addNode(newNode);
            }
        }
    }
}
//=================以上为内部类=====================

2. 数据增加 `public void add(数据类型变量)`

如果要进行新数据的增加，则应该由Link类负责节点对象的产生，并且由Link类维护根节点，所有的节点的关系匹配交给Node类处理。

class Link {    //链表类，外部能够看见的只有这一个类
    //之所以定义在内部，主要是之让Link类能调用
    private class Node {
        private String data;
        private Node next;
        public Node(String data) {
            this.data = data;
        }
        public void addNode(Node newNode) {
            if (this.next == null) {
                this.next = newNode;
            }else {
                this.next.addNode(newNode);
            }
        }
    }
//=================以上为内部类=====================
    private Node root;
    public void add(String data) {
        //判断链表不能为空，但不是所有的链表都不许为空
        if (data == null) {
            return;
        }
        Node newNode = new Node(data);
        if (this.root == null) {
            this.root = newNode;
        }else {
            this.root.addNode(newNode);
        }
    }
}

public class LinkDemo4 {
    public static void main(String[] args) {
        Link all = new Link();
        all.add("hello");
        all.add("world");
        all.add("null");
    }
}

3. 取链表元素个数 `public int size()`

每个链表都有长度，可以直接在Link类里面设置一个count属性，随后每一次数据添加之后，可以进行个数自增。
范例：修改Link.java类

class Link {    //链表类，外部能够看见的只有这一个类
    private Node root;
    //增加一个count属性
    private int count = 0;  //保存元素的个数
    public void add(String data) {
        //判断链表不能为空，但不是所有的链表都不许为空
        if (data == null) {
            return;
        }
        Node newNode = new Node(data);
        if (this.root == null) {
            this.root = newNode;
        }else {
            this.root.addNode(newNode);
        }
        this.count ++ ; //每一次保存完成后元素个数+1
    }
    public int size() {
        return this.count;
    }
}

再在Link类里面添加一个新的方法：size（）

    public int size() {
        return this.count;
    }

此程序中null不会保存

4. 判断链表是否为空 `public boolean isEmpty()`

空链表的两种判断方式：

判断root是否有对象(是否为null)；
判断保存的数据量的值(count)。
范例：判断是否为空链表

    public boolean isEmpty() {
        return this.count == 0;
    }

5. 数据查询 `public boolean contains(数据类型变量)`

在链表中一定会保存多个数据，判断数据存在的方式，以：String类型为例，循环查询链表中的内容，并且要与查询的数据进行匹配(equals())，如果查找到了返回true，否则返回false。
范例：修改Link.java 类

    public boolean contains(String data) {
        //现在没有要查询的数据，根节点也不保存数据
        if (data == null || this.root == null) {
            return false;   
        }
        return this.root.containsNode(data);
    }

范例：在Node类中增加方法

        public boolean containsNode(String data) {
            //当前节点数据为要查询的数据
            if (data.equals(this.data)) {
                return true;
            } else {
                //当前节点不是要查询的数据
                //判断时候后下一个节点
                if (this.next != null) {
                    return this.next.containsNode(data);
                } else {
                    return false;
                }
            }
        }

6. 根据索引取得数据 `public 数据类型 get(int index)`

示例图

范例：在Link类里面添加一个foot属性，表示Node元素编号

private int foot = 0;

范例：foot每一次查询都应该从头开始

    public String get(int index) {
        if (index > this.count) {
            return null;
        } else {
            this.foot = 0;
            return this.root.getNode(index);
        }
    }

范例：在Node类实现getNode()方法，

        public String getNode(int index) {
            //使用当前的foot内容与要查询的内容比较
            //foot自增，目的是为了下次查询
            if (Link.this.foot ++ ==index) {    //要查询的索引
                return this.data;   //返回当前节点数据
            } else {    //向后查询
                return this.next.getNode(index);
            }
        }

内部类和外部类之间可以方便的进行私有属性的互相访问。

7. 修改指定索引内容`public void set(int index , 数据类型变量)`

修改数据和查询的区别不大，查询的时候当满足索引值的时候，只是进行了一个数据的返回，那么此处只需要将数据返回改成数据的重新赋值即可。
范例：在Link类里面增加set()方法

    public void set(int index , String data) {
        if (index > this.count) {
            return ;
        } else {
            this.foot = 0;
            this.root.setNode(index , data);
        }
    }

范例：在Node类里面增加setNode方法

    public void setNode(int index , String data) {
        if (Link.this.foot ++ ==index) {
            this.data = data;
        } else {
            this.next.setNode(index , data);
        }
    }

8. 数据删除`public void remove(数据类型变量)`

数据删除分两种情况：

删除根节点，则root应该指向"root.next" ， Like类中处理这种情况
要删除的不是根节点，而是其它的普通节点，应该在Node类里面处理，所以此处从第二个节点开始判断的。
范例：在Node类里增加一个removeNode()方法，此方法处理非根节点的删除

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

范例：在Link类里面增加remove()方法和根节点的判断

    public void remove(String data) {
        if (this.contains(data)) {  //判断数据是否存在
            if (data.equals(this.root.data)) {
                this.root = this.root.next;
            } else {
                this.root.next.removeNode(this.root , data);
            }
            this.count -- ;
        }
    }

9. 将链表转换为数组`public 数组类型[] toArray`

在任何情况下，不管是什么样的类，都不可能总理类中使用输出语句，只要是想输出数据一定将数据返回到调用处进行输出，而由于链表属于动态对象数组，所以此处最好的做法是将链表以对象数组的形式返回。
范例：修改Link类的定义

增加一个返回数组类型的属性，内部类和外部类都可以访问

private String[] retArray

增加toArray()方法

    public String[] toArray() {
        if (this.root == null) {
            return null;
        }
        this.foot = 0;
        //根据保存内容开辟数据    
        this.retArray = new String[this.count];
        this.root.toArrayNode();
        return this.retArray;
    }
}

范例：在Node类里面处理数组数据的保存

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

实现的前提：内部类与外部类之间可以直接进行私有属性的访问。

playJavaBoy

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
链表的定义与使用

1. 链表的基本形式链表主要知识点此次的内容属于引用部分的实际应用，所以需要依赖两点：依赖于引用传递this表示当前对象。链表的实现基本模式；开发并且使用可用链。链表基本形式链表是一种最为简单的数据结构，它的主要目的是依靠引用关系来实现多个数据的保存。链表模型图范例：定义一个Node类假设本次保存的数据...
复制链接

扫一扫