Java-＞链表

KIDAKN

已于 2024-09-29 16:45:38 修改

阅读量719

点赞数 22

文章标签： java 链表开发语言数据结构

于 2024-09-27 08:30:00 首次发布

本文链接：https://blog.csdn.net/2401_85234841/article/details/142502191

版权

一、链表

1.概念

链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的

2.结构

二、自定义单链表

1.MySingerList类

package dome1;

public class MySingleList {
    //静态内部类
    static class ListNode {
        public int val;
        public ListNode next;

        public ListNode(int val) {
            this.val = val;
        }
    }

    public ListNode head;

    //创建链表
    public void createList() {
        ListNode list0 = new ListNode(1);
        ListNode list1 = new ListNode(2);
        ListNode list2 = new ListNode(3);
        ListNode list3 = new ListNode(4);
        ListNode list4 = new ListNode(5);
        list0.next = list1;
        list1.next = list2;
        list2.next = list3;
        list3.next = list4;
        head = list0;
    }

    //打印链表
    public void show() {
        ListNode cur = head;
        while (cur != null) {
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
    }

    //返回链表长度
    public int size() {
        int count = 0;
        ListNode cur = head;
        while (cur != null) {
            count++;
            cur = cur.next;
        }
        return count;
    }

    //是否包含key
    public boolean contains(int key) {
        ListNode cur = head;
        while (cur != null) {
            if (cur.val == key) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

    //头插法
    public void addFirst(int data) {
        ListNode list = new ListNode(data);
        list.next = head;
        head = list;
    }

    //尾插法
    public void addLast(int data) {
        ListNode list = new ListNode(data);
        if (head == null) {
            head = list;
            return;
        }
        ListNode cur = head;
        while (cur.next != null) {
            cur = cur.next;
        }
        cur.next = list;
    }
    //任意位置插入
    public void addIndex(int index, int data) {
        if(index<0||index>size()) {
            System.out.println("index不合法！");
            return;
        }
        if (index == 0) {
            addFirst(data);
            return;
        }
        ListNode cur = findIndex(index);
        ListNode list = new ListNode(data);
        list.next = cur.next;
        cur.next = list;
    }
    private ListNode findIndex(int index) {
        ListNode cur = head;
        int count = 0;
        while(count!=index-1) {
            cur = cur.next;
            count++;
        }
        return cur;
    }
    //删除第一次出现关键字为key的节点
    public void remove(int key) {
        if(head==null) {
            return;
        }
        if(head.val==key) {
            head = head.next;
            return;
        }
        ListNode cur = fingKey(key);
        if(cur==null) {
            return;
        }
        cur.next = cur.next.next;
    }
    private ListNode fingKey(int key) {
        ListNode cur = head;
        while(cur.next!=null) {
            if(cur.next.val==key) {
                return cur;
            }
            cur = cur.next;
        }
        return null;
    }
    //删除所有值为key的节点
    public void removeAllKey(int key){
        if(head==null) {
            return;
        }
        ListNode cur = head.next;
        ListNode prev = head;
        while(cur!=null) {
            if(cur.val==key) {
                prev.next = cur.next;
                cur = cur.next;
            }else {
                prev = cur;
                cur = cur.next;
            }
        }
        if(head.val==key) {
            head = head.next;
        }
    }
    //清空链表
    public void clear() {
        ListNode cur = head;
        while(cur!=null) {
            ListNode curN = cur.next;
            cur.next = null;
            cur = curN;
        }
        head = null;
    }
}

2.Text类

package dome1;

public class Text {
    public static void main(String[] args) {
        MySingleList mySingleList = new MySingleList();
        mySingleList.addLast(2);
        mySingleList.addLast(2);
        mySingleList.addLast(3);
        mySingleList.addLast(4);
        mySingleList.addLast(2);
        mySingleList.addLast(2);
        mySingleList.removeAllKey(2);
        mySingleList.clear();
        mySingleList.show();
    }
    public static void main5(String[] args) {
        MySingleList mySingleList = new MySingleList();
        mySingleList.addLast(1);
        mySingleList.addLast(2);
        mySingleList.addLast(3);
        mySingleList.addLast(4);
        mySingleList.remove(1);
        mySingleList.show();
    }
    public static void main4(String[] args) {
        MySingleList mySingleList = new MySingleList();
        mySingleList.addLast(1);
        mySingleList.addLast(2);
        mySingleList.addLast(3);
        mySingleList.addLast(4);
        mySingleList.addIndex(4,10);
        mySingleList.show();
    }
    public static void main3(String[] args) {
        MySingleList mySingleList = new MySingleList();
        mySingleList.addLast(1);
        mySingleList.addLast(2);
        mySingleList.addLast(3);
        mySingleList.addLast(4);
        mySingleList.show();
    }
    public static void main2(String[] args) {
        MySingleList mySingleList = new MySingleList();
        mySingleList.addFirst(1);
        mySingleList.addFirst(2);
        mySingleList.addFirst(3);
        mySingleList.addFirst(4);
        mySingleList.show();
    }
    public static void main1(String[] args) {
        MySingleList mySingleList = new MySingleList();
        mySingleList.createList();
        mySingleList.show();
        System.out.println();
        System.out.println(mySingleList.size());
        System.out.println(mySingleList.contains(2));
        System.out.println(mySingleList.contains(7));
    }
}

三、带环单链表

让一个指针从链表起始位置开始遍历链表，同时让一个指针从判环时相遇点的位置开始绕环运行，两个指针都是每次均走一步，最终肯定会在入口点的位置相遇。

证明：

四、双向链表

1..LinkedList的概念

LinkedList的底层是双向链表结构(链表后面介绍)，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高

注意：

LinkedList实现了List接口
LinkedList的底层使用了双向链表
LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问
LinkedList的任意位置插入和删除元素时效率比较高，时间复杂度为O(1)
LinkedList比较适合任意位置插入的场景

2.LinkedList的使用

2.1LinkedList的构造

方法	解释
LinkedList()	无参构造
public LinkedList(Collection<? extends E> c)	使用其他集合容器中元素构造List

2.2Linke的常见操作

方法	解释
boolean add(E e)	尾插 e
void add(int index, E element)	将 e 插入到 index 位置
boolean addAll(Collection<? extends E> c)	尾插 c 中的元素
E remove(int index)	删除 index 位置元素
boolean remove(Object o)	删除遇到的第一个 o
E get(int index)	获取下标 index 位置元素
E set(int index, E element)	将下标 index 位置元素设置为 element
void clear()	清空
boolean contains(Object o)	判断 o 是否在线性表中
int indexOf(Object o)	返回第一个 o 所在下标
int lastIndexOf(Object o)	返回最后一个 o 的下标
List<E> subList(int fromIndex, int toIndex)	截取部分 list

3.自定义双向链表

// 2、无头双向链表实现
public class LinkedList {
    static class ListNode {
        public int val;
        public ListNode prev;
        public ListNode next;

        public ListNode(int val) {
            this.val = val;
        }
    }
    public ListNode head;
    public ListNode last;
    //头插法
    public void addFirst(int data) {
        ListNode list = new ListNode(data);
        if(head == null) {
            head = last =  list;
        }else {
            list.next = head;
            head.prev = list;
            head = list;
        }
    }
    //尾插法
    public void addLast(int data) {
        ListNode list = new ListNode(data);
        if(head == null) {
            head = last = list;
        }else {
            last.next = list;
            list.prev = last;
            last = list;
        }
    }
    //任意位置插入,第一个数据节点为0号下标
//    public void addIndex(int index,int data){
//        if(index < 0 || index > size()) {
//            return;
//        }
//        if(index == 0) {
//            addFirst(data);
//            return;
//        }
//        if(index == size()) {
//            addLast(data);
//            return;
//        }
//        ListNode cur = searchIndex(index);
//        ListNode node = new ListNode(data);
//        node.next = cur;
//        cur.prev.next = node;
//        node.prev = cur.prev;
//        cur.prev = node;
//    }
//
//    private ListNode searchIndex(int index) {
//        ListNode cur = head;
//        int count = 0;
//        while (count != index) {
//            cur = cur.next;
//            count++;
//        }
//        return cur;
//    }
    public boolean addIndex(int index,int data) {
        if(index<0||index>size()) {
            return false;
        }
        if(index == 0) {
            addFirst(data);
            return true;
        }
        if(index == size()) {
            addLast(data);
            return true;
        }
        ListNode node = new ListNode(data);
        ListNode list = searchIndex(index);
        node.prev = list;
        node.next = list.next;
        list.next.prev = node;
        list.next = node;
        return true;
    }

    private ListNode searchIndex(int index) {
        ListNode cur = head;
        int count = 0;
        while(count!=index-1) {
            cur = cur.next;
            count++;
        }
        return cur;
    }
    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key) {
        ListNode cur = head;
        while(cur!=null) {
            if(cur.val==key) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }
    //删除第一次出现关键字为key的节点
    public void remove(int key) {
        ListNode cur = head;
        while(cur!=null) {
            if(cur.val == key) {
                if(cur == head) {
                    head = head.next;
                    if(head!=null) {
                        head.prev = null;
                    }else {
                        last = null;
                    }
                }else {
                    cur.prev.next = cur.next;
                    if(cur.next!=null) {
                        cur.next.prev = cur.prev;
                    }else {
                        last = cur.prev;
                    }
                }
                return;
            }else {
                cur = cur.next;
            }
        }
    }
    //删除所有值为key的节点
    public void removeAllKey(int key) {
        ListNode cur = head;
        while(cur!=null) {
            if(cur.val == key) {
                if(cur == head) {
                    head = head.next;
                    if(head!=null) {
                        head.prev = null;
                    }else {
                        last = null;
                    }
                }else {
                    cur.prev.next = cur.next;
                    if(cur.next!=null) {
                        cur.next.prev = cur.prev;
                    }else {
                        last = cur.prev;
                    }
                }
            }
            cur = cur.next;
        }
    }
    //得到单链表的长度
    public int size() {
        ListNode cur = head;
        int count = 0;
        while(cur!=null) {
            count++;
            cur = cur.next;
        }
        return count;
    }
    public void display() {
        ListNode cur = head;
        while(cur!=null) {
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }
    public void clear() {
        ListNode cur = head;
        while(cur!=null) {
            ListNode curN = cur.next;
            cur.prev = cur.next = null;
            cur = curN;
        }
        head = last = null;
    }
}

4.ArrayList与LinkedList的区别

不同点	ArrayList	LinkedList
存储空间上	物理上一定连续	逻辑上连续，但物理上不一定连续
随机访问	支持O(1)	不支持：O(N)
头插	需要搬移元素，效率低O(N)	只需修改引用的指向，时间复杂度为O(1)
插入	空间不够时需要扩容	没有容量的概念
应用场景	元素高效存储+频繁访问	任意位置插入和删除频繁