LinkedList与链表

最新推荐文章于 2024-07-24 12:42:40 发布

month177

最新推荐文章于 2024-07-24 12:42:40 发布

阅读量861

点赞数 17

文章标签：链表数据结构

本文链接：https://blog.csdn.net/2302_80113478/article/details/138277922

版权

4.2. LinkedList的其他常用方法介

5. ArrayList和LinkedList的区别

1. ArrayList的缺陷

由于其底层是一段连续空间，当在ArrayList任意位置插入或者删除元素时，就需要将后序元素整体往前或者往后搬移，时间复杂度为O(n)，效率比较低，因此ArrayList不适合做任意位置插入和删除比较多的场景。因此：java 集合中又引入了LinkedList，即链表结构。

2. 链表

2.1 链表的概念及结构

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

链表有

单向双向

带头不带头

循环非循环

比较重要的是单向不带头非循环

双向不带头非循环（LinkedList底层就是这个）

实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

1. 单向或者双向

2. 带头或者不带头

3. 循环或者非循环

虽然有这么多的链表的结构，但是我们重点掌握两种:

无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。

无头双向链表：在Java的集合框架库中LinkedList底层实现就是无头双向循环链表。

1，怎么从第一个节点，走到第二个节点

head=head.next

2.什么时候算把节点都遍历完成了

head=null

接口

public interface IList {

        public void addFirst(int data);
        public void addLast(int data);
        public void addIndex(int index,int data);
        public boolean contains(int key);
        public void remove(int key);
        public void removeAllKey(int key);
        public int size();
        public void clear() ;
        public void display();
}

类

import java.util.List;

public class MySingleList implements IList{
    static class ListNode{

        public int val;
        public ListNode next;
        public ListNode (int val){
            this.val=val;
        }
    }
    public ListNode head;
    public void createList(){
        ListNode node1=new ListNode(12);
        ListNode node2=new ListNode(23);
        ListNode node3=new ListNode(34);
        ListNode node4=new ListNode(45);
        node1.next=node2;
        node2.next=node3;
        node3.next=node4;
        this.head=node1;

    }
    @Override
    public void addFirst(int data) {
        ListNode node =new ListNode(data);
        node.next=this.head;
        this.head=node;
    }

    @Override
    public void addLast(int data) {
        ListNode node =new ListNode(data);
            if(head==null){
                head=node;
            }else{
                ListNode cur=head;
                while(head.next!=null){

                    cur=cur.next;
                    head.next=node;

                }

            }

    }

    @Override
    public void addIndex(int index, int data) throws IndexException{
if(index<0||index>size()){
    throw new IndexException("index不合法"+index);
}
ListNode node =new ListNode(data);
if(head==null){
    head=node;
    return;
}
if(index==0){
    addFirst(data);
    return;

}
if(index==size()){
    addLast(data);
    return;
}
//中间插入
ListNode cur=searchPrevIndex(index);
node.next=cur.next;
cur.next=node;
    }
    public ListNode searchPrevIndex(int index){
        ListNode cur=head;
        int count=0;
      while(count!=index-1) {
          cur = cur.next;
          count++;
      }
      return cur;
    }
//找key
    @Override
    public boolean contains(int key) {
        ListNode cur=head;
        while(cur!=null){
            if(cur.val ==key ){
            return true;
            }
            cur=cur.next;
        }

        return false;
    }

    @Override
public void remove(int key) {
if(head==null){
    return;
}
if(head.val==key){
    head=head.next;
    return;
}
ListNode cur=findPrevKey(key);
if(cur==null){
    return;
}ListNode del=cur.next;
cur.next=del.next;
    }
    private ListNode findPrevKey(int key){
        ListNode cur=head;
        while(cur.next!=null){
            if(cur.next.val==key){
                return cur;
            }else{
                cur=cur.next;

            }
            return cur;
        }
        return null;
    }

    @Override
    public void removeAllKey(int key) {
        if(head==null){
            return;
        }
ListNode prev=head;
ListNode cur=head.next;
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;

        }
    }
    //多少个节点
    @Override
    public int size() {
        ListNode cur=head;
        int a=0;
        while(cur!=null){
            a++;
            cur=cur.next;
        }
        return a;
    }
//清空
    @Override
    public void clear() {
        head=null;
    }

    @Override
    public void display() {
        ListNode cur=head;
            while(cur!=null){
                System.out.print(cur.val+" ");
                cur=cur.next;
            }
    }
}

3.LinkedList的模拟实现

// 2、无头双向链表实现
public class MyLinkedList {
 //头插法
public void addFirst(int data){ }
 //尾插法
public void addLast(int data){}
 //任意位置插入,第一个数据节点为0号下标
public void addIndex(int index,int data){}
 //查找是否包含关键字key是否在单链表当中
public boolean contains(int key){}
 //删除第一次出现关键字为key的节点
public void remove(int key){}
 //删除所有值为key的节点
public void removeAllKey(int key){}
 //得到单链表的长度
public int size(){}
 public void display(){}
 public void clear(){}
 }

4.LinkedList的使用

4.1 什么是LinkedList

LinkedList (Java Platform SE 8 ) (oracle.com)(LinkedList的官方文档)

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

4.2. LinkedList的其他常用方法介

方法	解释
boolean add(E e)	尾插 e
void add(int index, E element)	将 e 插入到 index 位置
boolean addAll(Collection 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 subList(int fromIndex, int toIndex)	截取部分 list

5. ArrayList和LinkedList的区别

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

month177

关注

17
点赞
踩
28

收藏

觉得还不错? 一键收藏
2
评论
LinkedList与链表

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

扫一扫