数据结构——单链表的Java实现

以前我只是单纯用数组，数组它有固定的长度，是有缺点的，不能随意改变它的长度，而链表可以插入和删除大量元素。

接下来我来介绍下单链表

什么是单链表呢

 链表的每个结点中只包含一个指针域，叫做单链表（即构成链表的每个结点只有一个指向直接后继结点的指针，且尾节点的指针为null）。

结点结构如下：

接下来呢，我举一个简单的存储整数的单链表的列子
一.存储整数的单链表分为三部分
1.结点
2.接口
3.链表
1.结点类，在接口中主要定义结点数据，指针属性，还有Node类的构造方法，方便在链表中去穿如何添加数据，
下面是结点接口Node类的代码

//结点类Node
public class Node {
//数据
int data;
//指针，或者可以说是下一个结点
Node next;
//创建一个无参的构造，便于初始化时使用
public Node(){
}
//创建一个有参数的构造方法，便于给结点传入数据
public Node(int data){
    this.data=data;
}
}

2.接口类，我们在接口中定义一些删除整数，添加整数，获取整数，修改，插入，以及获取整数个数的方法。
在链表中就能接口来调用者些方法；下面我来给出它的代码

    //接口myList类，用来定义存储链表数据的方法
    public interface myList {
        //存储
        public void add(int e);
        //插入
        public void insert(int e,int index);
        //删除
        public void delete(int index);
        //获取元素
        public int get(int index);
        //修改
        public void modify(int e,int index);
        //获取元素个数
        public int getSize();
    }

3.在链表类中通过继承接口myList，我们就可以通过创建对象调用接口中定义的方法，比如删除、获取整数等等；
在链表中有3个重要的属性，分别是头结点，尾节点，元素个数；
1.头结点：头结点的指针next是指向第一结点
2.尾节点：最后一个结点
3.元素个数
下面是编写链表类的代码

下面我来添加几个图片来展示下删除，插入的情况其实删除整数和插入整数的情况差不多。

下面的图片是删除整数方法的情况，删除整数就是把index下标所处的node结点的data数据赋值为0，node的指针next置为空，然后在把index-1的指针指向index+1的结点就可以了

下面是链表类中删除整数的代码

     @Override
        //删除整数
        public void delete(int index) {
            // TODO Auto-generated method stub
            checkindex(index);
            Node node=head.next;
            //找到下标index
            for(int i=0;i<index;i++){
                node=node.next;
            }
            //找到下标index-1
            Node node1=head.next;
            for(int i=0;i<index-1;i++){
                node1=node1.next;
            }
            if(index!=0){//假设index不等于0；不是第一个节点
                if(index==size-1){//假设是最后一个
                    node1.next=null;    
                }
                else {//假设不是最后一个
                    node1.next=null;
                    node1.next=node.next;
                }
                //设置node的指针为空，node的值为空
                node.next=null;
                node.data=0;
            }
            else{//假设index等于0
                head.next=null;
                head.next=node.next;
                node.next=null;
                node.data =0;
            }
            size--;
        }

下面的图片是插入整数方法的情况，插入整数就是先把index-1所处的结点node1的指针置空，然后再把要index-1结点的指针指向要插入的结点，然后再把要插入的结点node2的指针指向结点node就行了。

     //插入整数
        public void insert(int e, int index) {//形参index表示结点所处位置的下标
            // TODO Auto-generated method stub
            checkindex(index);
            Node node=head.next;
            //找到下标index
            for(int i=0;i<index;i++){
                node=node.next;
            }
            //找到下标index-1
            Node node1=head.next;
            for(int i=0;i<index-1;i++){
                node1=node1.next;
            }
            //创建一个新节点，为要插入的节点
            Node node2=new Node(e);
            if(index==0){//如果插入的位置是第一个节点
                head.next=null;
                head.next=node2;
            }else{
                node1.next=null;
                node1.next=node2;
            }
                node2.next=node;
            size++;
     
        }

接下来是单链表Link类的全部代码，其他的获取元素个数，修改整数，存储整数，获取整数都在里面

    public class Link implements myList{
        //头结点，尾节点
        Node head,tail;
        //元素个数
        int size;
        public Link(){
            head = new Node();
            tail = head;
            size = 0;
        }
     
        @Override
        //存储整数
        public void add(int e) {//形参e表示要添加的整数
            // TODO Auto-generated method stub
            //创建一个新的结点
            Node node = new Node(e);
            //设置尾结点的下一个节点为新结点
            tail.next=node;
            //设置尾结点为新结点
            tail=node;
            //元素个数加一
            size++;
        }
     
        @Override
        //插入整数
        public void insert(int e, int index) {//形参index表示结点所处位置的下标
            // TODO Auto-generated method stub
            checkindex(index);
            Node node=head.next;
            //找到下标index
            for(int i=0;i<index;i++){
                node=node.next;
            }
            //找到下标index-1
            Node node1=head.next;
            for(int i=0;i<index-1;i++){
                node1=node1.next;
            }
            //创建一个新节点，为要插入的节点
            Node node2=new Node(e);
            if(index==0){//如果插入的位置是第一个节点
                head.next=null;
                head.next=node2;
            }else{
                node1.next=null;
                node1.next=node2;
            }
                node2.next=node;
            size++;
     
        }
     
        @Override
        //删除整数
        public void delete(int index) {
            // TODO Auto-generated method stub
            checkindex(index);
            Node node=head.next;
            //找到下标index
            for(int i=0;i<index;i++){
                node=node.next;
            }
            //找到下标index-1
            Node node1=head.next;
            for(int i=0;i<index-1;i++){
                node1=node1.next;
            }
            if(index!=0){//假设index不等于0；不是第一个节点
                if(index==size-1){//假设是最后一个
                    node1.next=null;    
                }
                else {//假设不是最后一个
                    node1.next=null;
                    node1.next=node.next;
                }
                //设置node的指针为空，node的值为空
                node.next=null;
                node.data=0;
            }
            else{//假设index等于0
                head.next=null;
                head.next=node.next;
                node.next=null;
                node.data =0;
            }
            size--;
        }
     
        @Override
        //获取整数
        public int get(int index) {
            // TODO Auto-generated method stub
            //找到下表index
            Node node=head.next;
            //从头节点开始，依次向后查找
            for(int i=0;i<index;i++){
                node = node.next;
            }
     
            return node.data;
        }
     
        @Override
        //修改整数
        public void modify(int e, int index) {
            // TODO Auto-generated method stub
            //找到下表index
            Node node=head.next;
            //从头节点开始，依次向后查找
            for(int i=0;i<index;i++){
                node = node.next;
            }
            Node node1=new Node(e);
            node.data=e;
        }
     
        @Override
        //获取元素个数
        public int getSize() {
            // TODO Auto-generated method stub
            return size;
        }
        //检查index值是否合格
        public void checkindex(int index){
            if(index<0||index>size){
                throw new IndexOutOfBoundsException("参数不符合要求");
            }
        }
        public static void main(String [] args){
            Link link = new Link();
            //添加数据
            link.add(12);
            link.add(34);
            link.add(56);
            link.add(78);
            link.add(90);
            //遍历列表
                    for(int i=0;i<link.getSize();i++){
                        //取出元素
                        int e=link.get(i);
                        //输出元素
                        System.out.println("第"+i+"个元素是："+e);
     
                    }
        }
     
    }

转自：https://blog.csdn.net/coder150806/article/details/82425219