【数据结构】用JAVA实现一个简单的单向不带头结点链表的增删改查

我们首先创建一个链表

我们用Java里面的内部类属性来创建每一个节点

public class MyLinkedLIst {
    //创建一个链表
    class LinkedNode{
        private LinkedNode next;
        private int value;

        LinkedNode(int value){
            this.value = value;
        }
    }

value里面存的是每一个节点的值

next则存的是下一个节点的地址

然后我们创建一个链表

    //创建头节点
    LinkedNode head;
    
    //创建一个链表
    public void creatList(){
        //创建节点值
        LinkedNode linkedNode1 = new LinkedNode(12);
        LinkedNode linkedNode2 = new LinkedNode(23);
        LinkedNode linkedNode3 = new LinkedNode(34);
        LinkedNode linkedNode4 = new LinkedNode(45);
        //将各个节点连接起来
        linkedNode1.next =linkedNode2;
        linkedNode2.next =linkedNode3;
        linkedNode3.next =linkedNode4;
        //将头节点指向第一个节点
        this.head = linkedNode1;
    }

将链表创建好了以后我们增加一些功能

 比如说增加元素

有头插法/尾插法/中间节点插入法

    //找到下标的前一个元素
    public LinkedNode findSubIndex(int index){
        LinkedNode cur = head;
        while(index - 1 != 0){
            cur = cur.next;
            index--;
        }
        return cur;
    }

    public void addFirst(int val){
        //如果是空列表直接添加
        if (head == null){
            this.head.value = val;
        }
        //如果不是空列表那么直接在头部添加
        LinkedNode node = new LinkedNode(val);
        node.next = head;
        head = node;
    }
    //尾插法
    public void addLast(int val){
        //如果是空列表直接添加
        if (head == null){
            this.head.value = val;
        }
        //如果不是空列表那么直接在列表尾部添加元素
        //首先要找到最后一个元素
        LinkedNode cur = head;
        while(cur.next != null){
            cur =  cur.next;
        }
        //添加元素
        LinkedNode node = new LinkedNode(val);
        cur.next = node;
        node.next = null; //可写可不写
    }
    //中间插入一个元素
    public void addIndex(int index,int val){

        if (index < 0 || index > size()){
            throw new RuntimeException("下标返回错误！请重新输入！");
        }
        if (index == 0){
            addFirst(val);
        }
        if (index == size()){
            addLast(val);
        }

        LinkedNode node = new LinkedNode(val);
        node.next = findSubIndex(index).next;
        findSubIndex(index).next = node;


    }

以及删除元素

    /*要在中间中间插入一个元素首先要找到前一个元素*/
    public LinkedNode findSubOne(int val){
        LinkedNode cur = this.head;
        while (cur.next != null){
            /*这里用cur.next是因为前面的if判断中有了尾插法
            * 如果在前面不使用尾插法那么这里的判定条件可以将cur.next改为cur
            * 同时如果使用了cur那么也就意味着走完了整个链表
            * 也就是说最后一个节点也会被统计 但是我们要统计的是最后一个节点的前一个节点所以不能使用cur*/
            if (cur.next.value == val){
                //找到下一个值为要的值
                return cur;
            }
            cur = cur.next;
        }
        return null;
    }


public void delKey(int val){
        if (head == null){
            throw new RuntimeException("空表不能删除");

        }

        if (head.value == val){
            this.head = this.head.next;
            return;
        }

        LinkedNode cur = head;

        while (cur != null){
            if (cur.value == val){
                findSubOne(val).next = cur.next;
                return;
            }
            cur = cur.next;
        }


        //删除关键字为key的节点(删除值为value的节点) 写法2
/*           cur = findSubOne(val);
           if(cur == null){
               System.out.println("没有你要找的数字");
           }
           LinkedNode del = cur.next;
           cur.next = del.next;*/

    }


    //删除所有关键字为key的元素
    public void delAllkey(int val){
        if (head == null){
            return;
        }
        LinkedNode cur = head.next;
        LinkedNode pre = head;

        while (cur != null){
            if (cur.value == val){
                pre.next = cur.next;
                cur = cur.next;
            }else {
                pre = cur;
                cur = cur.next;
            }
        }
        if (head.value == val){
            head = head.next;
        }
    }
    //删除所有元素
    public void clearAll(){
        head = null;
    }
}

最后我们将链表进行测试

public class LinkedTest {
    public static void main(String[] args) {
        MyLinkedLIst linkedLIst1 = new MyLinkedLIst();
        linkedLIst1.creatList();;
        linkedLIst1.display();
        System.out.println();
        linkedLIst1.addFirst(1);
        linkedLIst1.addLast(1);
        linkedLIst1.addLast(1);
        linkedLIst1.addLast(1);
        linkedLIst1.display();
        System.out.println();
        linkedLIst1.addLast(56);
        linkedLIst1.display();
        System.out.println();
        linkedLIst1.addIndex(3,0);
        linkedLIst1.display();
   /*     linkedLIst1.addIndex(99,0);*/
        System.out.println();
        linkedLIst1.delKey(12);
        linkedLIst1.display();
        System.out.println();
        linkedLIst1.delAllkey(1);
        linkedLIst1.display();
    }
}

最后的结果如下