2021-2-20 链表结构的一些代码

package Linkeded;

public class Link {
private Node root;//表示链表的根节点
private int foot;//表示链表节点的索引
private int count;//记录链表的长度

public int getFoot() {
    return foot;
}

public void setFoot(int foot) {
    this.foot = foot;
}

private class Node<T> {
    private T data;//保存的数据
    private Node nextNode;//指向下一个节点的引用

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

    public Node() {
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public Node getNextNode() {
        return nextNode;
    }

    public void setNextNode(Node nextNode) {
        this.nextNode = nextNode;
    }

    //定义添加节点的方法
    public void addNode(Node<T> newNode) {
        //判断当前节点的下一个节点是否为空（也就是判断是否有下一个节点）
        if (this.nextNode == null) {
            this.nextNode = newNode;
        } else {
            this.nextNode.addNode(newNode);
        }
    }

    //输出节点数据的方法
    public void printNode() {
        System.out.println(this.data);
        if (this.nextNode != null) {
            this.nextNode.printNode();
        }
    }

    /**
     * 判断链表是否包含指定的数据
     *
     * @param data 要匹配的数据
     * @return 如果匹配上返回true，没有匹配上返回false
     */
    public boolean containsNode(T data) {
        if (this.data.equals(data)) {
            return true;
        } else {
            if (this.nextNode == null) {
                return false;
            } else {
                return this.nextNode.containsNode(data);
            }
        }
    }

    /**
     * 根据索引取得对应节点的数据（data）
     *
     * @param index 传递的参数（表示索引）
     * @return 如果有数据返回对应的数据，否则返回null
     */
    public T getNodeData(int index) {
        if (foot++ == index) {
            return this.data;
        }
        if (this.nextNode == null) {
            return null;
        } else {
            return (T) this.nextNode.getNodeData(index);
        }
    }

    /**
     * 实现节点数据的修改
     *
     * @param index 要修改的节点的索引
     * @param data  新数据
     */
    public void setNode(int index, T data) {
        if (foot++ == index) {
            this.data = data;
        }
        if (this.nextNode == null) {
            return;
        } else {
            this.nextNode.setNode(index, data);
        }
    }

    /**
     * 实现在指定位置增加新节点
     * @param index 指定索引位置
     * @param previousNode 上一个节点
     * @param newNode 新节点
     */
    public void addNode(int index,Node<T> previousNode,Node<T> newNode){
        if(foot++==index){
            previousNode.nextNode=newNode;
            newNode.nextNode=this;
        }else {
             this.nextNode.addNode(index,this,newNode);
        }
    }

    /**
     * 根据索引删除节点
     * @param index 要删除的节点的下标
     * @param previousNode 当前节点的上一个节点
     */
    public void removeNode(int index,Node<T> previousNode){
        if(foot++==index){
            previousNode.nextNode=this.nextNode;
        }else {
            this.nextNode.removeNode(index,this);
        }
    }

    /**
     * 根据传递的数据删除节点
     * @param previousNode 当前节点的上一个节点
     * @param data 要删除节点对应的数据
     */
    public void removeNode(Node<T> previousNode,T data){
        if(this.data.equals(data)){
            previousNode.nextNode=this.nextNode;
        }else {
            this.nextNode.removeNode(this,data);
        }
    }
}

/****************************以下代码是外部类中的代码**************************************/
//在外部类中定义添加节点的方法
public void add(T data) {
    Node<T> newNode = new Node<T>(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 void print() {
    if (this.root == null) {
        return;
    } else {
        this.root.printNode();
    }
}

//判断链表是否包含指定对象
public boolean contains(T data) {
    if (this.root == null) {
        return false;
    } else {
        return this.root.containsNode(data);
    }
}

//根据索引取得对应节点的数据
public T get(int index) {
    if (root == null) {
        return null;
    }
    if (index >= this.count || index < 0) {
        return null;
    } else {
        this.foot = 0;//如果不将foot初始化，只要调用一次就会给foot赋值，那么下一次再次调用就匹配不准了
        return this.root.getNodeData(index);
    }
}

//根据索引实现节点数据的修改
public void set(int index, T data) {
    this.foot = 0;
    if (root == null) {
        return;
    }
    if (index >= this.count || index < 0) {
        return;
    } else {
        this.root.setNode(index, data);
    }
}
//实现在指定位置增加新节点
public void add(int index,T data){
    this.foot=0;
    Node<T> newNode=new Node<T>(data);
    if(index==0){
        newNode.nextNode=this.root;
        this.root=newNode;

    }else {
        this.root.addNode(index,this.root,newNode);
    }
}
//根据索引删除节点
public void remove(int index){
    this.foot=0;
    if(index>=this.count||index<0){
        return;
    }
    if(index==0){
        this.root=this.root.nextNode;
    }else {
        this.root.removeNode(index,this.root);
    }
    this.count--;
}
//根据传递的数据删除节点
public void remove(T data){
    if(this.root.data.equals((data))){
        this.root=this.root.nextNode;
    }else {
        this.root.removeNode(this.root,data);
    }
    this.count--;
}

}

------参考文献http://blog.mbzvip.tech/doc.html