JAVA基础---（链表）

链表的结构：链表没有长度的限制—>动态的（对象）数组

以下实现链表的增删改查以及遍历输出：

package 链表;
//链表没有长度的限制，--->动态的（对象）数组
class 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)//当前节点对象的next为空
            {
                this.next=newNode;//把新节点的地址赋给当前节点的next
            }
            else//当前节点next不为空，即当前节点后还有节点
            {
                this.next.addNode(newNode);
                //递归，直到找到某一个节点的next为空，再把新节点地址赋给这个节点的next
            }
        }
        /*判断节点是否存在*/
        //第一次调用：Link类的link.root对象
        //第二次及以后调用：Node类的link.root.next对象
        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;
                }
            }

        }
        /*查询在指定节点的数据*/
        public String getNode(int index)
        {
            //一边查询一边给节点编号,索引动态生成
            if( foot++ == index)
            {
                return this.data;
            }
            else
            {
                return this.next.getNode(index);
            }
        }
        /*修改节点的数据*/
        public void setNode(int index,String data)
        {
                if(Link.this.foot++==index)
                {
                   this.data=data;
                }
                else
                {
                     this.next.setNode(index,data);
                }
        }
        /*删除非根节点，previous当前节点的前一个节点*/
        public void removeNode(Node previous,String data)
        {
            if(data.equals(this.data))//当前节点是要删除的
            {
                previous.next = this.next;
                //将当前节点的下一个节点的地址赋给当前节点的前一个节点的next
            }
            else//如果当前节点不是要删除的
            {
                //递归，直到找到
                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;//记录节点的个数
    private int foot;//记录每个节点的编号
    private String []retArray;//对象数组接收节点数据，便于输出
    /*添加数据*/
    public void add(String data)
    {
        if(data==null)
        {
            return ;
        }
        Node newNode = new Node(data);
        if(this.root==null)//没有根节点，将新节点作为根节点
        {
            this.root=newNode;
        }
        else//根节点存在，将新节点交给Node类处理
        {
           this.root.addNode(newNode);
        }
        this.count++;//统计节点的个数
    }
    /*链表长度--->节点的个数*/
    public int Size()
    {
        return this.count;
    }
    /*判断空链表*/
    public boolean isEmpty()
    {
        return this.count==0;
    }
    /*判断数据是否存在链表---->遍历链表并比较值是否相等*/
    public boolean contains(String data)
    {
        if(data==null||this.root==null)
        {
            return false;
        }
        else//链表存在并且有数据
        {
            //将数据交给Node类处理
            return this.root.containsNode(data);
        }
    }
       /*根据链表的索引查询节点数据*/
       public String get(int index)
       {
           if(index > this.count)//索引超过节点的个数
           {
               return null;
           }
               this.foot=0;//从前往后查找
               return this.root.getNode(index);
       }
       /*修改指定索引的数据*/
       public void  set(int index,String data)
       {
           if(index>this.count)
           {
               return ;
           }
           this.foot=0;
           this.root.setNode(index,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--;//节点的个数减一
           }
           else
           {
               System.out.println("该数据不存在无法删除！！！");
           }
       }
       /*链表数据转化对象数组*/
       public String []toArray()
       {
           if(this.root==null)
           {
               return null;
           }
           this.foot=0;
           this.retArray=new String[this.count];
           this.root.toArrayNode();
           return this.retArray;
       }
}
public class LinkDemo {
    public static void main(String[] args) {
        /*创建链表*/
        Link link = new Link();
        /*向链表中添加数据*/
        link.add("aaa");
        link.add("bbb");
        link.add("ddd");
        /*取得链表的长度*/
        System.out.println("链表的长度为： "+link.Size());
        /*判断某个数据是否存在链表*/
        System.out.println(link.contains("bbb"));
        System.out.println(link.contains("bb"));
        /*通过链表的索引查找链表的内容*/
        System.out.println(link.get(1));
        /*修改某个节点的数据*/
        link.set(1,"ccc");
        System.out.println(link.get(1));
        /*删除某个节点*/
        link.remove("ccc");
        System.out.println(link.get(1));
        /*遍历链表输出*/
        String[] linkArray = link.toArray();
        for (int i = 0; i < linkArray.length; i++) {
            System.out.println(linkArray[i]);
        }
    }
}

链表的基本结构：

删除根节点：

删除非根节点：

链表内容的输出：类中不建议出现输出语句，转化为对象数组输出