java实现链表的增删改查

java实现单链表的增删改查代码如下

package LinkLIst;
public class linkList {
     
    public static void main(String[] args) {
     
        Link link = new Link();
        link.add("jack");
        link.add("tom");
        link.add("jerry");
        System.out.println(link.get(1));
        System.out.println(link.size());
        link.remove("jack");
        for (String i:link.toArray()){
     
            System.out.println(i);
        }
    }
}
class Link{
       //定义一个链表类
    private Node root;//定义根节点
    private int count = 0; //保存元素的个数
    private int foot = 0; //节点索引
    private String[] retArray;


    private class Node{
       //定义的内部节点类
        private String data; //要保存的数据
        private Node next;  //下一个节点的引用
        public Node(String data){
       //每一个Node类对象都必须保存相应的数据
            this.data = data;
        }
        /**
         * 设置新节点的保存，所有的新节点保存在最后一个节点之后
         * @param newNode
         */
        private void addNode(Node newNode){
     
            //判断当前节点的下一个节点是否为空
            if (this.next==null){
     
                //为空则将新节点保存到当前节点的next
                this.next = newNode;
            }else{
     
                //否则向后继续保存
                this.next.addNode(newNode);
            }
        }
        /**
         * 数据检索，判断数据是否存在于链表中
         * @param data 要查询的数据
         * @return 存在返回true 否则返回false
         */
        public boolean containsNode(String data){
     
            if (data.equals(this.data)){
        //当前节点的数据即为要查询的数据
                return true;                //返回true 停止查询
            }else {
                              //继续向后面查询
                if (this.next!=null) {
           //有后续节点，递归查询
                    return this.next.containsNode(data);
                }else {
                          //没有后续节点，返回false
                    return false;
                }
            }
        }
        /**
         * 根据索引取出数据，此时该索引一定是存在的
         * @param index 要取得数据的索引编号
         * @return 返回指定索引节点包含的数据
         */

        public String getNode(int index){
     
            // 使用当前的foot内容与要查询的索引进行比较，随后将foot内容自增，方便下次查询
            if (Link.this.foot++ == index){
      //当前为要查询的索引
                return this.data;           //返回当前节点的数据
            }else {
                              //否则继续查询
                return this.next.getNode(index);//进行下一个节点的判断
            }
        }

        /**
         * 修改指定索引下的数据
         * @param index 要修改的索引编号
         * @param data 新数据
         */
        public void setNode(int index,String data){
     
            // 使用当前的foot内容与要查询的索引进行比较，随后将foot内容自增，方便下次查询
            if (Link.this.foot++ == index){
      //找到索引，修改数据
                this.data = data;
            }else {
     
                this.next.setNode(index,data); //否则继续查询
            }
        }

        /**
         * 节点的删除操作，匹配每一个节点的数据，如果当前节点数据符合删除数据
         * 则使用"当前节点上一节点.next = 当前节点.next"方式空出当前节点
         * 第一次调用（Link）:previous = Link.root; this = Link.root.next
         * 第二次调用（Node）:previous = Link.root.next; this = Link.root.next.next
         * @param previous 当前节点的上一个节点
         * @param data  要删除的数据
         */
        public void removeNode(Node previous,String 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(); //继续取出数据
            }
        }
    }

    public void add(String data){
      //假设不允许有null
        if (data==null){
               //判断数据是否为空
            return;               //为空则结束方法调用
        }
        Node newNode = new Node(data); //要保存的数据
        if (this.root==null){
               //当前没有根节点
            this.root = newNode;       //保存根节点
        }else {
                             //根节点存在
            this.root.addNode(newNode);//交给Node 类处理节点的保存
        }
        this.count++; //数据保存成功后保存个数加1
    }

    /**
     * 取得链表中保存的数据个数
     * @return 保存的个数，通过count属性取得
     */
    public int size(){
     
        return this.count;
    }

    /**
     * 判断链表是否为空，通过链表的长度来判断
     * @return
     */
    public boolean isEmpty(){
     
        return this.count == 0;
    }

    public boolean contains(String data){
     
        if (data ==null || this.root == null){
      //没有需要查询的数据或者根节点为空，停止查询
            return false;
        }else {
     
            return this.root.containsNode(data); //否则交给Node类查询
        }
    }

    /**
     * 根据索引取出数据，此时该索引一定是存在的
     * @param index 索引数据
     * @return 数据不存在或索引大于链表长度返回null,否则返回数据
     */
    public String get(int index){
     
        if (index>this.count-1){
     
            return null;
        }
        this.foot = 0;
        return this.root.getNode(index);
    }

    /**
     * 根据索引修改数据
     * @param index 要修改的数据的索引
     * @param data 新数据
     */
    public void set(int index,String data){
     
        if (index>this.count-1){
      //判断是否超出范围
            return;
        }
        this.foot=0;   //重新设置foot属性的内容，作为索引出现
        this.root.setNode(index,data); //交给Node类设置数据内容
    }

    /**
     * 链表数据的删除操作，在删除前判断是否存在该数据
     * 如果存在，再判断该数据是否为根节点保存的数据
     * 如果是，则将根节点的下一个节点作为新的根节点
     * 否则，将删除操作交给Node的removeNode方法处理
     * @param data 要删除的数据
     */
    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--; //删除后个数减少
        }
    }
    /**
     * 将链表中的数据转化为对象数组输出
     * @return
     */
    public String [] toArray(){
     
        if (this.root==null){
     
            return null;
        }
        this.foot = 0;  //脚标清零操作
        this.retArray = new String[this.count]; //根据保存的内容开辟数组
        this.root.toArrayNode(); //交给Node类处理
        return this.retArray; //返回数组对象
    }
    /**
     * 清空链表
     */
    public void clear(){
     
        this.root = null;
        this.count = 0;
    }
}