链表

　　现在在进行面试的时候，很多公司都会要求你编写数组排序，链表，二叉树等，所以对于数据结构的掌握成为面试的基本功，数据结构主要的核心组成：引用+递归。

链表的基本介绍

如果要想保存多个对象，我们现在能想到的概念就只有对象数组，也就是说，如果该数组可以保存任意对象，那么又可以想到Object型的数组：

　　Object data[]=new Object[3];

但在实际开发中，我们就要面临一些问题，数组的不足是长度固定的线性结构，虽然以上的代码可以存放多个内容，但是一旦我们的内容不足或者是内容过多就会产生内存的浪费，如果此时要解决此类问题最好的办法就是不定义一个长度固定的数组 有多少数据就保存多少数据，应该采用火车车厢的设计模式，动态的进行车厢的挂载，那么假设每截车厢只保留一个数据，那么现在假设可以不受内存的限制，就可以证明解决了数组长度的问题

class Node{ //因为只有Node类才可以保存数据的同时设置数据的先后关系
    private Object data;//真正保存的数据
    private Node next;//定义下一个节点
    public Node(Object data){//车厢里面一定要去保存有数字
        this.data=data;
    }
    public void setData(Object data){
        this.data=data;
    }
    public Object getData(){
        return this.data;    
    }
    public void setNext(Node next){
        this.next=next;
    }
    public Node getNext(){
        return this.next;
    }
}
public class Newbegin{
    public static void main(String args[]) throws Exception{
        //1.封装几个节点
        Node root=new Node("火车头");//现在假设存放的数是String
        Node n1=new Node("车厢A");
        Node n2=new Node("车厢B");
        Node n3=new Node("车厢C");
        //2.需要设置节点关系
        root.setNext(n1);
        n1.setNext(n2);
        n2.setNext(n3);
        //3.输出节点
        print(root);
    }  
    public static void print(Node node){
        if(node!=null){//表示当前存在有节点
            System.out.println(node.getData());
            print(node.getNext());
        }
    }
}     

　　如果你要定义一个火车车厢你肯定不可能保留一个数据，因为只需要另一个指向，指向下一个节点，

在整个链表的实现过程之中Node类的核心作用：保存数据，连接节点关系，但是以上的代码麻烦，发现客户端（主方法）需要自己来进行节点的创建，所谓的链表就是需要一个单独的类，假设：Link通过这个类实现Node类的数据保存以及关系处理。

链表实现结构说明

　　如果按照以上的方式来进行链表的实现，那我们对开发者是非常痛苦，因为所有的使用者必须自己来处理数据的关系，所以为了更好的处理应该追加一个程序类来完成，假设这个类叫做Link类

　　

 　　但是如果现在对于程序的初期结构采用如下的方式定义那么也会出现问题。

class Link{    //负责链表的操作
    //将Node定义为内部类，表示Node类只为Link类
    private class Node{        //负责数据与节点关系的匹配
    
    }
}
public class Newbegin{
    public static void main(String args[]) throws Exception{

    }  
}     

使用私有的内部类才可以保证只有link类才有权操作 Node类，而且使用了内部类之后还有一个最明显的特点，内部类和外部类之间可以方便的进行私有属性的访问，也就避免了seter和geter方法调用的尴尬， 

class Link{    //负责链表的操作
    //将Node定义为内部类，表示Node类只为Link类
    private class Node{        //负责数据与节点关系的匹配
        private Object data;//保存节点的数据
        private Node next;//保存下一个节点
        public Node(Object data){
            this.data=data;
        }
    }
    //----------------以下为link类------------//

}
public class Newbegin{
    public static void main(String args[]) throws Exception{

    }  
}      

　　按照以上的模式可以编写代码，但是对于链表的核心功能：增加，修改，删除。判断某一数据是否存在。

 增加链表的数据　　public void add（Object data）

　　如果要想在链表之中实现一个数据的增加操作，则应该首先在链表里面提供有一个 追加方法，而这个追加方法上的参数是Object类型，

1.在Link类中追加新方法定义 

    public void add(Object data){
        if(data==null){//人为的追加了规定，不允许存放空值
            return ;//方法结束调用
        }
    }

2.那么该如何进行数据的保存呢？应该首先定义一个根节点，才可以添加后面的子节点，这个根节点的类型一定是Node。则应该在Link类里面追加有一个Node类的属性，

 private Node root;//属于根节点，没有根节点就无法进行数据的保存

3.后续节点操作：

class Link{    //负责链表的操作
    //将Node定义为内部类，表示Node类只为Link类
    private class Node{        //负责数据与节点关系的匹配
        private Object data;//保存节点的数据
        private Node next;//保存下一个节点
        public Node(Object data){
            this.data=data;
        }
        //第1次调用：this=Link.root
        //第2次调用：this=Link.root.next;
        //第3次调用：this=Link.root.next;
        public void addNode(Node newNode){//处理节点关系
            if(this.next==null){//当前节点下一个为空
                this.next=newNode；
            }else{//现在当前节点的下一个不为空
                this.next.addNode(newNode);
            }
        }
    }
    //----------------以下为link类------------//
    private Node root;//属于根节点，没有根节点就无法进行数据的保存
    public void add(Object data){
        if(data==null){//人为的追加了规定，不允许存放空值
            return ;//方法结束调用
        }
        //如果要想进行数据的保存，那么就必须将数据封装在Node节点类里面
        //如果没有封装，则无法确认好节点的先后顺序
        Node newNode=new Node(data);
        if(this.root==null){  //当前并没有根节点
            this.root=newNode;//第一个节点设置为根节点
        }else{    //根节点已经存在了
            //应该把此时的节点顺序的处理交给Node类自己完成
            this.root.addNode(newNode);
        }
    }
}
public class Newbegin{
    public static void main(String args[]) throws Exception{
        Link all=new Link();
        all.add("hello");
        all.add("world");
        all.add("gl");
    }  
}       

Node的数据保存和节点关系的匹配

4.取得元素个数：public  int size()

一个链表之中可以保存多个元素数据，那么为了操作方便，就需要知道其一共保存的数据个数，所有需要有一个计数的统计操作

1.在Link类中追加一个统计个数的属性

private int count=0;//当前的保存个数 

2.随后在每次进行数据追加的时候都应该进行一个个数的累加

    public void add(Object data){
        if(data==null){//人为的追加了规定，不允许存放空值
            return ;//方法结束调用
        }
        //如果要想进行数据的保存，那么就必须将数据封装在Node节点类里面
        //如果没有封装，则无法确认好节点的先后顺序
        Node newNode=new Node(data);
        if(this.root==null){  //当前并没有根节点
            this.root=newNode;//第一个节点设置为根节点
        }else{    //根节点已经存在了
            //应该把此时的节点顺序的处理交给Node类自己完成
            this.root.addNode(newNode);
        }
        count++;
    }

3.可以直接取得元素的个数

5，判断是否为空链表：public boolean isEmpty()

　　现在如果根元素为null或者保存的元素个数为0，则认为链表是一个空的链表。则isEmpty()返回的就应该是true；  

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

为空判断与个数可以结合在一起完成，不需要过多的复杂的操作逻辑，

6，取得全部数据：public Object [] toArray()

　　首先链表是一个动态对象数组，那么既然是动态对象数组，返回的内容也一定就应该是一个对象数组，但是如果要想进行数组的返回，首先必须要开辟一个数组（数组长度就是count属性内容），同时这个的数组内容的填充应该依次将节点中的数据取出，才可以正常完成，

1.在Link类中一定会存在有一个toArray（）的方法，该方法的返回值一定是Object[]

 2.所有在返回的对象数组中的数据都在Node类里面，那么就证明这些数据应该Node类中利用递归来依次取出那么在外部类中Link中定义一个返回类型的属性，

3.在Node类中处理节点数据

4.数据的存储和返回是链表开发中使用最多的功能 

class Link{    //负责链表的操作
    //将Node定义为内部类，表示Node类只为Link类
    private class Node{        //负责数据与节点关系的匹配
        private Object data;//保存节点的数据
        private Node next;//保存下一个节点
        public Node(Object data){
            this.data=data;
        }
        //第1次调用：this=Link.root
        //第2次调用：this=Link.root.next;
        //第3次调用：this=Link.root.next;
        public void addNode(Node newNode){//处理节点关系
            if(this.next==null){//当前节点下一个为空
                this.next=newNode;
            }else{//现在当前节点的下一个不为空
                this.next.addNode(newNode);
            }
        }
        //第一次调用:this=Link.root
        //第一次调用:this=Link.root.next
        public void toArrayNode(){
            Link.this.retData[Link.this.foot++]=this.data;
            if(this.next!=null){//现在还有下一个节点
                this.next.toArrayNode();
            }
        }
    }
    //----------------以下为link类------------//
    private Object[] retData;//返回类型
    private int foot=0;//操作脚标
    private int count=0;//当前的保存个数    
    private Node root;//属于根节点，没有根节点就无法进行数据的保存
    public void add(Object data){
        if(data==null){//人为的追加了规定，不允许存放空值
            return ;//方法结束调用
        }
        //如果要想进行数据的保存，那么就必须将数据封装在Node节点类里面
        //如果没有封装，则无法确认好节点的先后顺序
        Node newNode=new Node(data);
        if(this.root==null){  //当前并没有根节点
            this.root=newNode;//第一个节点设置为根节点
        }else{    //根节点已经存在了
            //应该把此时的节点顺序的处理交给Node类自己完成
            this.root.addNode(newNode);
        }
        count++;
    }
    public int size(){//取得元素个数
        return this.count;
    }
    public boolean isEmpty(){
        return this.root==null&&this.count==0;
    }
    public Object[] toArray(){
        if(this.count==0){
            return null;
        }
        //现在链表中存在有数据，则开辟指定长度的数组
        //该数组一定要交给Node类进行处理
        this.retData=new Object[this.count];
        this.foot=0;//进行清零的处理，需要进行脚标操作
        this.root.toArrayNode();//将数据的取出处理交给Node类完成
        return this.retData;
    }
}
public class Newbegin{
    public static void main(String args[]) throws Exception{
        Link all=new Link();    
        all.add("hello")  ;
        all.add("world");
        all.add("gl");
        Object result[]=all.toArray();
        for(int x=0;x<result.length;x++){
            System.out.println(result[x]);
        }
    }  
}       

7.判断数据是否存在 public boolean contains(Object data)

　　在链表中存在很多数据，判断数据是否存在链表之中，可以利用contains()方法进行完成，

判断的过程

　　　　1.判断链表是否有数据，如果没有数据不需要进行后续迭代

 　　　　2.当我们链表之中存在有数据之后，进行的数据的依次递归判断，考虑到标准化问题，这个操作需要equals(）方法支持。

1.在Node类里面追加有一个containsNode()方法，用于数据查找递归

　　这个方法一定是由root这个对象首先调用 

    public boolean contains(Object search){
        //没有要查询的内容以及链表为空
        if(search==null||this.root==null){
            return false;
        }
        return this.root.containsNode(search);
    }

查找操作需要使用equals()方法 如果是一个自定义的类则一定要覆写equals()方法

取得指定索引数据：public Object get(int index)

链表属于动态数组，数组应该有索引取得内容的形式

1.在Node内里面追加一个新的方法，用于索引查找

    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 newData)

　　现在如果发现某些数据的保存有问题，则可以根据索引进行修改处理操作，

1.Node 类里面追加一个方法：setNode（）；

        public void setNode(int index,Object newData){
            if(Link.this.foot++==index){//索引相同
                this.data=newData;
                return ;//结束
            }else{
                if(this.next!=null){
                    this.next.setNode(index,newData);
                }
            }
        }

10.数据删除 public void remove(Object data)

如果要想进行数据的删除处理，则需要考虑两种情况，

情况一：要删除的是根节点

　　如果要删除的是根节点，则意味着Link中的根节点的保存需要发生变化；

情况二：删除的不是根节点

　　所有的处理的操作应该交给Node来进行处理。

 

class Link{    //负责链表的操作
    //将Node定义为内部类，表示Node类只为Link类
    private class Node{        //负责数据与节点关系的匹配
        private Object data;//保存节点的数据
        private Node next;//保存下一个节点
        public Node(Object data){
            this.data=data;
        }
        //第1次调用：this=Link.root
        //第2次调用：this=Link.root.next;
        //第3次调用：this=Link.root.next;
        public void addNode(Node newNode){//处理节点关系
            if(this.next==null){//当前节点下一个为空
                this.next=newNode;
            }else{//现在当前节点的下一个不为空
                this.next.addNode(newNode);
            }
        }
        //第一次调用:this=Link.root
        //第一次调用:this=Link.root.next
        public void toArrayNode(){
            Link.this.retData[Link.this.foot++]=this.data;
            if(this.next!=null){//现在还有下一个节点
                this.next.toArrayNode();
            }
        }
        //第一次调用:this=Link.root
        //第一次调用:this=Link.root.next
        public boolean containsNode(Object search){
            if(search.equals(this.data)){//找到了
                return true;
            }else{
                if(this.next!=null){//当前节点之后
                return this.next.containsNode(search);    
            }else{//没有节点
                return false;
                }
            }
        }
        //第一次调用:this=Link.root
        //第一次调用:this=Link.root.next
        public Object getNode(int index){
            if(Link.this.foot++==index){
                return this.data;
            }else{
                this.next.getNode(index);
            }
            return null;
        }
        public void setNode(int index,Object newData){
            if(Link.this.foot++==index){//索引相同
                this.data=newData;
                return ;//结束
            }else{
                if(this.next!=null){
                    this.next.setNode(index,newData);
                }
            }
        }
        //第一次调用：this=Link.root.next,previous=Link.root;
        //第二次调用：this=Link.root.next.next,previous=Link.root.next;
        public void removeNode(Node previous,Object data){
            if(this.data.equals(data)){//当前节点为要删除节点
                previous.next=this.next;//删除当前了
            }else{
                this.next.removeNode(this,data);
            }
        }
    }
    //----------------以下为link类------------//
    private Object[] retData;//返回类型
    private int foot=0;//操作脚标
    private int count=0;//当前的保存个数    
    private Node root;//属于根节点，没有根节点就无法进行数据的保存
    public void add(Object data){
        if(data==null){//人为的追加了规定，不允许存放空值
            return ;//方法结束调用
        }
        //如果要想进行数据的保存，那么就必须将数据封装在Node节点类里面
        //如果没有封装，则无法确认好节点的先后顺序
        Node newNode=new Node(data);
        if(this.root==null){  //当前并没有根节点
            this.root=newNode;//第一个节点设置为根节点
        }else{    //根节点已经存在了
            //应该把此时的节点顺序的处理交给Node类自己完成
            this.root.addNode(newNode);
        }
        count++;
    }
    public int size(){//取得元素个数
        return this.count;
    }
    public boolean isEmpty(){
        return this.root==null&&this.count==0;
    }
    public boolean contains(Object search){
        //没有要查询的内容以及链表为空
        if(search==null||this.root==null){
            return false;
        }
        return this.root.containsNode(search);
    }
    public Object[] toArray(){
        if(this.count==0){
            return null;
        }
        //现在链表中存在有数据，则开辟指定长度的数组
        //该数组一定要交给Node类进行处理
        this.retData=new Object[this.count];
        this.foot=0;//进行清零的处理，需要进行脚标操作
        this.root.toArrayNode();//将数据的取出处理交给Node类完成
        return this.retData;
    }
    public void set(int index,Object newData){
        if(index>=this.count){//超过了保存的个数
            return ;//结束方法调用
        }
        this.foot=0;
        this.root.setNode(index,newData);
    }
    public Object get(int index){
        if(index>=this.count){//超过了保存的个数
            return null;
        }
        this.foot=0;
        return this.root.getNode(index);
    }
    public void remove(Object data){
        if(this.contains(data)){//如果该数据存在则进行删除处理
            //首先需要判断要删除的是否为根节点数据
            if(this.root.data.equals(data)){//首先需要判断
                this.root=this.root.next;//根节点变为下一个节点
            }else{//不是根节点
                this.root.next.removeNode(this.root,data);
            }
            this.count--;
        }
    }
}

public class Newbegin{
    public static void main(String args[]) throws Exception{
        Link all=new Link();    
        all.add("hello")  ;
        all.add("world");
        all.add("gl");
        all.set(1,"你好");
        all.remove("hello");
        all.remove("gl");
        Object result[]=all.toArray();
        for(int x=0;x<result.length;x++){
            System.out.println(result[x]);
        }
//        System.out.println("===========");
//        System.out.println(all.contains("hello"));
//        System.out.println( all.contains("xxx"));
    //    System.out.println("===========");
    //    System.out.println(all.get(0));
    //    System.out.println(all.get(3));
    }  
}