JAVA—修改链表

修改链表：

链表不能实现操作数据的统一，所以就造成了每一次使用链表是都需要重复开发。但由于Object类型可以接收所有的引用数据类型，利用这样的特性就可以弥补之前链表设计的参数不统一问题，也就可以开发出真正的可重用链表操作。

完整代码：

class Link {
    private class Node {
        private Object data ;
        private Node next ;
        public Node(Object data) {
            this.data = data ;
        }
        public void addNode(Node newNode) {
            if (this.next == null) {
                this.next = newNode ;
            }else {
                this.next.addNode(newNode);
            }
        }
        public boolean containsNode(Object data) {
            if (data.equals(this.data)) {
                return true ;
            }else {
                if (this.next != null) {
                    return this.next.containsNode(data) ;
                }else{
                    return false ;
                }
            }
        }
        public Object getNode(int index) {
            if (Link.this.foot++ == index) {
                return this.data ;
            }else{
                return this.next.getNode(index) ;
            }
        }
        public void setNode(int index,Object data) {
            if(Link.this.foot++ == index) {
                this.data = data ;
            }else {
                this.next.setNode(index,data);
            }
        }
        public void removeNode(Node previous,Object data) {
            if (data.equals(this.data)) {
                previous.next = this.next ;
            } else {
                this.next.removeNode (this,data);
            }
        }
        public void toArrayNode() {
            Link.this.retArray[Link.this.foot++] = this.data ;
            if (this.next !=null){
                this.next.toArrayNode();
            }
        }
    }
    private Node root ;
    private int count = 0 ;
    private int foot = 0 ;
    private Object [] retArray ;

    public void add(Object data) {
        if (data == null) {
            return ;
        }
        Node newNode = new Node(data) ;
        if (this.root == null) {
            this.root = newNode ;
        } else {
            this.root.addNode(newNode);  
        }
        this.count ++ ;
    }
    public int size() {
        return this.count ;
    }
    public boolean isEmpty() {
        return this.count == 0 ;
    }
    public boolean contains(Object data) {
        if (data == null || this.root == null) {
            return false ;
        }
        return  this.root.containsNode(data) ;
    }
    public Object get(int index) {
        if (index > this.count) {
            return null ;
        }
        this.foot = 0 ;
        return this.root.getNode(index) ;
    }
    public void set(int index , Object data) {
        if (index > this.count) {
            return ;
        }
        this.foot = 0 ;
        this.root.setNode(index,data);
    }
    public void remove(Object 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 -- ;
        }
    }
    public  Object[] toArray() {
        if (this.root == null) {
            return null ;
        }
        this.foot = 0 ;
        this.retArray = new Object[this.count] ;
        this.root.toArrayNode();
        return this.retArray ;
    }
    public clear() {
        this.root = null ;
        this.count = 0 ;
    }
}

分步解释：

1.

1.class Link {
2.    private class Node {
3.       private Object data ;
4.        private Node next ;
5.        public Node(Object data) {
6.           this.data = data ;
        }

1.创建一个链表类，外部只能看见这个类。
2.定义内部节点类。
3.data表示要保存的数据。
4.表示下一个节点的引用。(其实我觉得这里就像C语言的链表中的next指针）
5.每一个Node类对象都必须保存相应的数据。

2.

1. public void addNode(Node newNode) {
2.            if (this.next == null) {
3.                this.next = newNode ;
4.            }else {
5.                this.next.addNode(newNode);
6.            }
7.       }

1.定义一个增加节点的方法。
2.判断：如果当前节点的下一节点为null。
3.保存节点。
4.否则。
5.向后继续保存。

3.

1. public boolean containsNode(Object data) {
2.            if (data.equals(this.data)) {
3.                return true ;
4.            }else {
5.                if (this.next != null) {
6.                    return this.next.containsNode(data) ;
7.                }else{
8.                    return false ;
9.                }
            }
        }

1.定义一个返回值为布尔型的查询方法。
2.判断当前节点数据是否为要查询的数据。
3.如果是，则返回true。
4.否则（当前节点数据不满足查询要求）
5.判断：是否有后续节点，如果有后续节点。
6.这里是一个递归，我们使用递归调用继续查询。
7.如果没有后续节点。
8.则没有查询到，返回false。

4.

1. public Object getNode(int index) {
2.            if (Link.this.foot++ == index) {
3.                return this.data ;
4.            }else{
5.                return this.next.getNode(index) ;
6.            }
        }

1.定义一个方法：使用当前内容与要查询的索引进行比较，随后foot的内容自增。
2.判断当前要查询的索引。
3.如果相等，则返回当前节点数据。
4.否则，继续向后查询。
5.对下一个节点进行判断。

5.

1. public void setNode(int index,Object data) {
2.            if(Link.this.foot++ == index) {
3.                this.data = data ;
4.            }else {
5.                this.next.setNode(index,data);
6.            }
7.        }

1.定义一个方法：使用当前内容与要查询的索引进行比较，随后foot的内容自增。
2.判断当前要修改的索引。
3.如果相等，则进行内容的修改。
4.否则，继续向后查询。
5.对下一个节点进行判断。

6.

1. public void removeNode(Node previous,Object data) {
2.            if (data.equals(this.data)) {
3.                previous.next = this.next ;
4.            } else {
5.                this.next.removeNode (this,data);
6.            }
7.        }

1.定义一个删除的方法。
2.判断当前节点是否为要删除节点。
3.如果是。则空出当前节点。
4.否则，继续向后查询。
5.继续下一个判断。

7.

1. public void toArrayNode() {
2.            Link.this.retArray[Link.this.foot++] = this.data ;
3.            if (this.next !=null){
4.                this.next.toArrayNode();
5.            }
6.        }
7.    }

1.定义一个取得元素的方法。
2.取出数据并保存在数组中。
3.判断是否有后续元素。
4.如果有则继续下一个元素的取得。

8.

1.	  private Node root ;
2.    private int count = 0 ;
3.    private int foot = 0 ;
4.    private Object [] retArray ;

1.定义根节点。
2.count表示保存元素的个数。
3.foot表示节点索引。
4.表示返回的数组。

9.

1.public void add(Object data) {
2.        if (data == null) {
3.            return ;
4.        }
5.        Node newNode = new Node(data) ;
6.        if (this.root == null) {
7.            this.root = newNode ;
8.        } else {
9.            this.root.addNode(newNode);
10.        }
11.       this.count ++ ;
    }

1.定义一个增加数据的方法。
2.判断数据是否为空。
3.如果为空，则结束方法调用。
4.表示要保存的数据。
5.判断当前有无根节点。
6.如果没有，则保存根节点。
8.否则交给Node类处理节点的保存。
11.数据保存后保存个数加一。

10.

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

取得保存的数据量。

11.

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

判断是否为空链表，表示长度为0，不是null。

12.

1. public boolean contains(Object data) {
2.        if (data == null || this.root == null) {
3.            return false ;
4.        }
5.        return  this.root.containsNode(data) ;
6.    }

1.定义一个判断指定数据是否存在的方法。
2.如果限制没有要查询的数据，根节点也不保存数据。
3.则没有查询结果。
5.否则交给Node类查询。

13.

1. public Object get(int index) {
2.        if (index > this.count) {
3.            return null ;
4.        }
5.        this.foot = 0 ;
6.        return this.root.getNode(index) ;
7.    }

1.定义一个根据索引取得保存的节点数据的方法。
2.判断如果超过了查询范围。
3.则返回null。
5.表示从前向后查询。
6.查询过程交给Node类。

14.

1.public void set(int index , Object data) {
2.        if (index > this.count) {
3.            return ;
4.        }
5.        this.foot = 0 ;
6.        this.root.setNode(index,data);
7.    }

1.定义一个根据索引修改数据的方法。
2.判断如果超过了保存范围。
3.若果是，则结束方法调用。
5.重新设置foot属性的内容，作为索引出现。
6.交给Node类设置数据内容。

15.

 1.public void remove(Object data) {
 2.       if (this.contains(data)) {
 3.           if (data.equals(this.root.data)) {
 4.               this.root = this.root.next ;
 5.           }else {
 6.               this.root.next.removeNode(this.root,data);
 7.           }
 8.           this.count -- ;
 9.       }
    }

1.定义一个根据索引删除数据的方法。
2.判断数据是否存在。
3.判断根节点数据是否为要删除数据。
4.如果是，则空出当前根节点。
6.否则从第二个元素开始判断，即第二个元素的上一个元素为根节点。
8.删除成功后个数要减少。

16.

1.public  Object[] toArray() {
2.        if (this.root == null) {
3.            return null ;
4.        }
5.        this.foot = 0 ;
6.       this.retArray = new Object[this.count] ;
7.        this.root.toArrayNode();
8.        return this.retArray ;
9.    }

1.定义一个将链表中的数据转换为对象数组输出的方法
2.判断该链表是否有数据
3，如果没有则返回null。
5.脚标清零操作。
6.根据保存内容开辟数组。
7.交给Node类处理
8.返回数组对象。

17.

public clear() {
        this.root = null ;
        this.count = 0 ;
    }

清空链表数据。