Java数据结构之链表(观看前，请查看上一篇关于递归的调用,查看内部类的用法)

/**
 链表是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，
 而是在每一个节点里存到是下一个节点的指针(Pointer)
 */
public class lianbiao{
    public static void main(String[] args) {
        Nodemanager nm =new Nodemanager();
        System.out.println("-------add-------");
        nm.add(5);
        nm.add(4);
        nm.add(3);
        nm.add(2);
        nm.add(1);
        nm.print();
        System.out.println("------del--------");
        nm.del(3);
        nm.print();
        System.out.println("------find--------");
        System.out.println(nm.find(1));
        System.out.println("-------update-------");
        nm.update(1,10);
        nm.print();
        System.out.println("-------insert-------");
        nm.insert(2,20);
        nm.print();
       
       
    }
}

class Nodemanager{
private Node root;//根节点
private int currentIndex=0;//节点当前序号，每次操作从0开始
public void add(int data){
    if(root==null){
        root=new Node(data);
    }else{
        root.addNode(data);
    }
}
public void del(int data){
    if(root.getData()==data){
        root=root.next;
    }else{
        root.delNode(data);
    }
}
public void print(){
    if(root!=null){
        System.out.print(root.getData()+"->");
        root.printNode();
        System.out.println();
    }
}
//查找是否存在结点
public boolean find(int data){
    if(root==null){
        return false;
    }
    if(root.getData()==data){
        return true;
    }else{
        return root.findNode(data);
    }
   
}
public boolean update(int oldData,int newData){
    if(root==null)return false;
    if(root.getData()==oldData){
        root.setData(newData);
        return true;
    }else{
        root.updateNode(oldData, newData);
         return true;
    }
}
//想索引之前插入
public void insert(int index,int data){
        if(index<0){return ;}
        currentIndex=0;
        if(index==currentIndex){
            Node newNode=new Node(data);
            root.next=newNode;//后插
            //newNode.next=root;前插
            root=newNode;
        }else{
            root.insertNode(index, data);
        }
}

//内部类
    private class Node{
        private int data;//什么都可以存
        private Node next;//把当前类型作为属性
        public Node(){}
        public Node(int data){
            this.data=data;
        }
        public void setData(int data){
            this.data=data;
        }
        public int getData(){
            return data;
        }
        //添加节点
        public void addNode(int data){
          //谁调用方法当前对象就是谁
          if(this.next==null){
              this.next=new Node(data);
          }else{
              this.next.addNode(data);
          }
           
        }
        //删除节点
        public void delNode(int data){
            if(this.next!=null){
                if(this.next.data==data){
                    this.next=this.next.next;
                }else{
                    this.next.delNode(data);
                }
            }
        }
        //输出所有节点
        public void printNode(){
            if(this.next!=null){
                System.out.print(this.next.data+"->");
                this.next.printNode();
            }
        }
        //查找结点是否存在
        public boolean findNode(int data){
           if(this.next!=null){
               if(this.next.data==data){
                   return true;
               }else{
                   return this.next.findNode(data); 
               }
           }
           return false;
        }
        //修改节点
        public boolean updateNode(int oldData,int newData){
            if(root!=null){
                if(this.next.data==oldData){
                    this.next.data=newData;
                    return true;
                }else{
                    this.next.updateNode(oldData, newData);
                    return true;
                }
            }
            return false;
        }
        //插入节点
        public void insertNode(int index,int data){
            currentIndex++;//比第二个
            if(index==currentIndex){
                Node newNode=new Node(data);
                newNode.next=this.next;
                this.next=newNode;
            }else{
                this.next.insertNode(index, data);
            }

        }
    }
}