数据结构玩转数据结构 4-5 从链表中删除元素 - 菜鸟乙

数据结构玩转数据结构 4-5 从链表中删除元素

0　　　　课程地址

https://coding.imooc.com/lesson/207.html#mid=13448

1　　　　重点关注

1.1　　　　代码草图解析

1.2　　　　链表操作的复杂度

增删改查均是O(n)

如果只对链表头进行操作，增删查，那么复杂度为O(1)

2　　　　课程内容

3　　　　Coding

3.1　　　　关键代码

重点看删除功能点

 /**
     * H        删除索引为index的元素
     * @author weidoudou
     * @date 2022/10/29 19:40
     * @param index 请添加参数描述
     * @return E
     **/
    public E remove(int index){
        if(index<0||index>size-1){
            throw new IllegalArgumentException("索引越界");
        }

        Node pre = dummyHead;
        for(int i = 0;i<index;i++){
            pre = pre.next;
        }

        Node ret = pre.next;
        pre.next = ret.next;
        ret.next = null;
        size--;

        return ret.e;
    }

3.2　　　　全量代码（遍历查询和修改）

全量代码

package com.company;

/***
 * 链表
 * @author weidoudou
 * @date 2022/10/28 7:56
 **/
public class LinkedList<E> {

    /**
     * 1  内部类node
     * @author weidoudou
     * @date 2022/10/28 7:59
     * @return null
     **/
    private class Node{
        //Node 只有两个属性，下一个节点和本节点存储的元素
        private E e;
        private Node next;

        /**
         * 通用调用node方法
         * @author weidoudou
         * @date 2022/10/28 8:17
         * @param e 请添加参数描述
         * @param  next 请添加参数描述
         * @return null
         **/
        public Node(E e,Node next){
            this.e = e;
            this.next = next;
        }

        /**
         * node 无参构造
         * @author weidoudou
         * @date 2022/10/28 8:15
         * @return null
         **/
        public Node(){
            this(null,null);
        }

        /**
         * node 有参构造
         * @author weidoudou
         * @date 2022/10/28 8:16
         * @param e 请添加参数描述
         * @return null
         **/
        public Node(E e){
            this(e,null);
        }


        @Override
        public String toString() {
            return e.toString();
        }
    }

    //2 LinkedList 属性 链表头元素（火车头），大小
    private int size;
    private Node dummyHead;

    /**
     * 3    LikedList 无参
     * @author weidoudou
     * @date 2022/10/28 8:27
     * @return null
     **/
    public LinkedList() {
        this.dummyHead = new Node(null,null);
        this.size = 0;
    }

    /**
     * 4  getSize
     * @author weidoudou
     * @date 2022/10/28 8:23
     * @return null
     **/
    public int getSize(){
        return size;
    }

    /**
     * 5  isEmpyt
     * @author weidoudou
     * @date 2022/10/28 8:24
     * @return boolean
     **/
    public boolean isEmpty(){
        return size == 0;
    }

    /**
     * 6  链表头部添加元素
     * @author weidoudou
     * @date 2022/10/28 8:37
     * @param e 请添加参数描述
     * @return void
     **/
    public void addFirst(E e){
        /*Node nodeNew = new Node(e);
        nodeNew.next = head;    //火车尾指向 上个尾巴
        this.head = nodeNew;    //火车尾 变成了当前的node*/

        //称之为优雅写法
        addElement(0,e);
    }

    /**
     * 7  链表尾部添加元素 认真分析下
     * @author weidoudou
     * @date 2022/10/28 18:11
     * @param e 请添加参数描述
     * @return void
     **/
    public void addLast(E e){
        addElement(size,e);
    }

    /**
     * 8  链表添加元素(链表通常不在中间添加元素，编写此段代码完全是为了后续便于理解和二叉树相关知识做铺垫)
     * @author weidoudou
     * @date 2022/10/28 8:45
     * @param index 请添加参数描述
     * @param  e 请添加参数描述
     * @return void
     **/
    public void addElement(int index,E e){
        if(index<0||index>size){
            throw new IllegalArgumentException("索引不正确");
        }


        Node pre = dummyHead;
        for(int i = 0;i<index;i++){
            pre = pre.next;
        }

        /*Node nodeNew = new Node(e);
        nodeNew.next = pre.next;
        pre.next = nodeNew;*/

        //优雅写法
        pre.next = new Node(e,pre.next);
        size++;
    }

    /**
     * 9    查询
     * @author weidoudou
     * @date 2022/10/29 11:18
     * @param index 请添加参数描述
     * @return E
     **/
    public E findByIndex(int index){
        if(index<0||index>size-1){
            throw new IllegalArgumentException("索引越界");
        }

        Node cur = dummyHead.next;
        for(int i = 0;i<index;i++){
            cur = cur.next;
        }
        return cur.e;
    }

    /**
     * A     查询首个元素
     * @author weidoudou
     * @date 2022/10/29 11:27
     * @return E
     **/
    public E findByFirst(){
        return findByIndex(0);
    }

    /**
     * B     查询最后一个元素
     * @author weidoudou
     * @date 2022/10/29 11:27
     * @return E
     **/
    public E findByLast(){
        return findByIndex(size-1);
    }

    /**
     * C     修改
     * @author weidoudou
     * @date 2022/10/29 11:29
     * @param index 请添加参数描述
     * @param  e 请添加参数描述
     * @return void
     **/
    public void update(int index,E e){
        if(index<0||index>size-1){
            throw new IllegalArgumentException("索引越界");
        }

        Node cur = dummyHead.next;
        for(int i = 0;i<index;i++){
            cur = cur.next;
        }
        cur.e = e;

    }

    /**
     * D     修改第一个元素
     * @author weidoudou
     * @date 2022/10/29 11:31
     * @param e 请添加参数描述
     * @return void
     **/
    public void updateFirst(E e){
        update(0,e);
    }

    /**
     * E    修改最后一个元素
     * @author weidoudou
     * @date 2022/10/29 11:31
     * @param e 请添加参数描述
     * @return void
     **/
    public void updateLast(E e){
        update(size-1,e);
    }

    /**
     * F     查询链表是否包含元素
     * @author weidoudou
     * @date 2022/10/29 13:04
     * @param e 请添加参数描述
     * @return boolean
     **/
    public boolean contains(E e){
        boolean flag;

        for(Node cur = dummyHead.next;cur!=null;cur=cur.next){
            if(e.equals(cur.e)){
                return true;
            }
        }
        return false;
    }

    /**
     * G      toString
     * @author weidoudou
     * @date 2022/10/29 13:06
     * @return java.lang.String
     **/
    @Override
    public String toString() {

        StringBuilder sb = new StringBuilder();
        for(Node cur = dummyHead.next;cur!=null;cur=cur.next){
            sb.append(cur+"->");
        }
        sb.append("Null");
        return sb.toString();
    }

    /**
     * H        删除索引为index的元素
     * @author weidoudou
     * @date 2022/10/29 19:40
     * @param index 请添加参数描述
     * @return E
     **/
    public E remove(int index){
        if(index<0||index>size-1){
            throw new IllegalArgumentException("索引越界");
        }

        Node pre = dummyHead;
        for(int i = 0;i<index;i++){
            pre = pre.next;
        }

        Node ret = pre.next;
        pre.next = ret.next;
        ret.next = null;
        size--;

        return ret.e;
    }

    /**
     * 删除第一个元素
     * @author weidoudou
     * @date 2022/10/30 14:56
     * @return E
     **/
    public E removFirst(){
        return remove(0);
    }

    /**
     * 删除最后一个元素
     * @author weidoudou
     * @date 2022/10/30 14:56
     * @return E
     **/
    public  E removLast(){
        return remove(size-1);
    }



}

测试类

package com.company;


public class Main {

    public static void main(String[] args) {

        LinkedList<Integer> linkedList = new LinkedList<>();
        for(int i = 0;i<5;i++){
            linkedList.addFirst(i);
            System.out.println(linkedList);
        }

        System.out.println("是否包含222="+linkedList.contains(222));

        linkedList.addElement(1,222);
        System.out.println(linkedList);

        System.out.println("是否包含222="+linkedList.contains(222));

        linkedList.delete(1);
        System.out.println(linkedList);


    }
}

测试结果

0->Null
1->0->Null
2->1->0->Null
3->2->1->0->Null
4->3->2->1->0->Null
是否包含222=false
4->222->3->2->1->0->Null
是否包含222=true
4->3->2->1->0->Null

Process finished with exit code 0

posted on 2022-10-29 20:06 菜鸟乙阅读(50) 评论(0) 编辑收藏举报

刷新页面返回顶部

0 课程地址

1 重点关注

1.1 代码草图解析

1.2 链表操作的复杂度

2 课程内容

3 Coding

3.1 关键代码

3.2 全量代码（遍历查询和修改）

0　　　　课程地址

1　　　　重点关注

1.1　　　　代码草图解析

1.2　　　　链表操作的复杂度

2　　　　课程内容

3　　　　Coding

3.1　　　　关键代码

3.2　　　　全量代码（遍历查询和修改）