LinkedList与链表

最新推荐文章于 2024-11-09 20:38:27 发布
最新推荐文章于 2024-11-09 20:38:27 发布
阅读量1.2k 收藏 5
点赞数 18
文章标签： 链表 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80785428/article/details/141861888
版权

1.链表的引入

由于在ArrayList任意位置插入或者删除元素时就需要将元素整体往前或者往后搬移，时间复杂度为O（n），效率比较低，因此ArrayList不适合在任意位置插入或者删除元素，因此引入了LinkedList，即链表结构。

2.链表的分类

2.1 单向或者双向

无头指每一个节点都可以存放数字

 2.2 带头或者不带头

2.3 循环或者非循环

无头单向非循环结构简单，作为其他数据结构的子结构，在笔试面试中出现的比较多

 同时，无头双向循环链表，为LinkedList底层实现的链表。

3.链表的实现（无头单项非循环）

import java.util.LinkedList;

public class MyLinkedList implements IList{
    static class ListNode {
        public int val;
        public ListNode preV;
        public ListNode next;

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

    }
    public ListNode head;//这里的head并不是指头而是方便取的名字
    public ListNode last;
    @Override
    public void addFirst(int data) {
       ListNode cur = head;
       ListNode node = new ListNode(data);
       if(head.next == null){
           head = last = node;
       }else{
           node.next = cur;
           cur.preV = node;
           head = node;
       }
    }

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

        }

    @Override
    //在指定位置增删元素
    public void addIndex(int index, int data) {
        int len = size();
        if(index < 0 || index > len ){
            System.out.println("不符合条件");
            return;
        }if(index == 0){
            addFirst(index);
            return;
        }if(index == len){
            addLast(data);
            return;
        }else{
            ListNode cur = findOfKey(index);
            ListNode node = new ListNode(data);
            node.next = cur;
           node.preV = cur.preV;
            cur.preV.next = node;
           cur.preV = node;
        }

    }
    private ListNode findOfKey(int index){
        ListNode cur = head;
        while(index != 0){
           cur = cur.next;
           index--;
        }
        return cur;
    }


    @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) {
       ListNode cur = head;
       while(cur != null) {
           if (cur.val == key) {
               if (cur == head) {
                   head = head.next;
                   if (head != null) {
                       head.preV = null;
                   }
               } else {
                   cur.preV.next = cur.next;
                   if ( cur.next == null) {
                       last = last.preV;
                   }else {
                       cur.next.preV = cur.preV;
                   }
               }
           }
           cur =cur.next;
       }
    }

    @Override
    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 {
                    cur.preV.next = cur.next;
                    if (cur.next == null) {
                        last = last.preV;
                    }
                    cur.next.preV = cur.preV;
                }
            }
            cur = cur.next;
        }

    }



    @Override
    public int size() {
        ListNode cur = head;
        int len = 0;
        while(cur != null){
            len++;
            cur = cur.next;
        }
        return len;
    }

    @Override
    public void clear() {
        ListNode cur = head;
        if(cur != null){
            ListNode curN = cur.next;
            cur.preV = null;
            cur.next = null;
            cur = curN;
        }
        head = null;
        last = null;
    }

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

接口： 

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();


}

4.链表面试题

4.1 移除链表元素

 public class Solution {
  
        public ListNode removeElements(ListNode head, int val) {
            if(head == null){
                return head;
            }
            ListNode pre = head;
            ListNode cur = head.next;
            while(cur != null){
                if(cur.val == val){
                    pre.next = cur.next;
                    cur = cur.next;
                }else{
                    pre = cur;
                    cur = cur.next;
                }
            }
            if(head.val == val){
                head = head.next;
            }
            return head;
        }
    }

 4.2 反转链表

class Solution {
    public ListNode reverseList(ListNode head) {
        if(head == null){
            return head;
        }
        ListNode cur = head.next;
        head.next = null;
        while(cur != null){
            ListNode curN = cur.next;
            cur.next = head;
            head = cur;
            cur = curN;
        }
       return head;
    }
}

4.3 链表的中间结点

class Solution {
    public ListNode middleNode(ListNode head) {
        if(head == null){
            return head;
        }
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
        }
    return slow;

    }
}

4.4 返回倒数第k个节点

 

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int kthToLast(ListNode head, int k) {
        if(head == null){
            return head.val;
        }
        ListNode fast = head;
        ListNode slow = head;
        int count = k - 1;
        while(count != 0){
            fast = fast.next;
            count--;
        }
        while(fast.next != null){
            fast = fast.next;
            slow = slow.next;
        }
        return slow.val;
    }
}

 4.5 合并两个有序链表

 /**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
         ListNode newHead = new ListNode(-1);
        ListNode tmp = newHead;
       while(list1 != null && list2 != null){
          if(list1.val <= list2.val){
              tmp.next = list1;
              list1 = list1.next;
              tmp = tmp.next;
          }else{
              tmp.next = list2;
              tmp = tmp.next;
              list2 = list2.next;
          }
      }
       if(list1 != null){
           tmp.next = list1;
       }
       if(list2 != null){
           tmp.next = list2;
       }
       return newHead.next;
    }
}

 4.6 链表分割

public class Partition {
    public ListNode partition(ListNode pHead, int x) {
         ListNode as = null;
        ListNode ae = null;
        ListNode bs = null;
        ListNode be = null;
        ListNode cur = pHead;
        while(cur != null){
            if(cur.val < x){
                if(as == null){
                    as = ae = cur;
                }else{
                      ae.next = cur;
                      ae = ae.next;
                }
            }else{
                if(bs == null){
                     bs = be =cur;
                }else{
                     be.next = cur;
                     be = be.next;
                }
            }
            cur = cur.next;
        }
        if(as == null){
            return bs;
        }
         ae.next = bs;
        if(bs != null){
            be.next = null;
        }
            return as;
    }
    }

 4.7 链表回文

 

public class PalindromeList {
    public boolean chkPalindrome(ListNode A) {
        if(A == null){
            return false;
        }
        // write code here
      ListNode fast = A;
      ListNode slow = A;
      while(fast != null && fast.next != null){
        fast = fast.next.next;
        slow = slow.next;
      }
       ListNode cur = slow.next;
     while(cur !=  null){
         ListNode curN = cur.next;
        cur.next = slow;
        slow = cur;
        cur = curN;
     }
    while(A != slow){
        if(A.val != slow.val){
            return false;
        }
        if(A.next == slow){
            return true;
        }
        A= A.next;
        slow = slow.next;
    }
    return true;
    }
}

4.8 相交链表

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
       ListNode pl = headA;
       ListNode ps = headB;
        int lenA = 0;
        int lenB = 0;
        //计算长度
        while(pl != null){
            lenA++;
            pl = pl.next;
        }
        while(ps != null){
            lenB++;
            ps = ps.next;
        }
        pl = headA;
        ps = headB;
        //计算两个链表的差值
        int len = lenA - lenB;
        if(len < 0){
            pl = headB;
            ps = headA;
            len = lenB - lenA;
        }
        while(len != 0){
            pl = pl.next;
            len--;
        }
        while(pl != ps){
            pl = pl.next;
            ps = ps.next;
        }
        if(pl == null){
            return null;
        }
        return pl;
    }
}

 4.9 环形链表

public class Solution {
    public boolean hasCycle(ListNode head) {
        
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
            if(fast  ==  slow ){
                return true;
            }
        }
        return false;
    
    }
}

 5.双向链表的基本实现（LinkedList）

public class MyLinkedList implements IList{
    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;
    @Override
    public void addFirst(int data) {
       ListNode cur = head;
       ListNode node = new ListNode(data);
       if(head.next == null){
           head = last = node;
       }else{
           node.next = cur;
           cur.preV = node;
           head = node;
       }
    }
 
    @Override
    public void addLast(int data) {
        ListNode cur = head;
        ListNode node = new ListNode(data);
        if(head == null) {
            head = last = node;
        }else{
            last.next = node;
            node.preV = last;
            last = node;
        }
 
        }
 
    @Override
    //在指点位置增删元素
    public void addIndex(int index, int data) {
        int len = size();
        if(index < 0 || index > len ){
            System.out.println("不符合条件");
            return;
        }if(index == 0){
            addFirst(index);
            return;
        }if(index == len){
            addLast(data);
            return;
        }else{
            ListNode cur = findOfKey(index);
            ListNode node = new ListNode(data);
            node.next = cur;
           node.preV = cur.preV;
            cur.preV.next = node;
           cur.preV = node;
        }
 
    }
    private ListNode findOfKey(int index){
        ListNode cur = head;
        while(index != 0){
           cur = cur.next;
           index--;
        }
        return cur;
    }
 
 
    @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) {
       ListNode cur = head;
       while(cur != null) {
           if (cur.val == key) {
               if (cur == head) {
                   head = head.next;
                   if (head != null) {
                       head.preV = null;
                   }
               } else {
                   cur.preV.next = cur.next;
                   if ( cur.next == null) {
                       last = last.preV;
                   }else {
                       cur.next.preV = cur.preV;
                   }
               }
           }
           cur =cur.next;
       }
    }
 
    @Override
    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 {
                    cur.preV.next = cur.next;
                    if (cur.next == null) {
                        last = last.preV;
                    }
                    cur.next.preV = cur.preV;
                }
            }
            cur = cur.next;
        }
 
    }
 
 
 
    @Override
    public int size() {
        ListNode cur = head;
        int len = 0;
        while(cur != null){
            len++;
            cur = cur.next;
        }
        return len;
    }
 
    @Override
    public void clear() {
        ListNode cur = head;
        if(cur != null){
            ListNode curN = cur.next;
            cur.preV = null;
            cur.next = null;
            cur = curN;
        }
        head = null;
        last = null;
    }
 
    @Override
    public void display() {
        ListNode cur = head;
        while(cur != null){
            System.out.print(cur.val+" ");
            cur = cur.next;
        }
        System.out.println();
    }
    //在指定位置进行打印
    public void display2(ListNode newHead) {
        ListNode cur = head;
        while (cur != null) {
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }
 
        public ListNode reverseList() {
            if(head == null){
                return head;
            }
            ListNode cur = head.next;
            head.next = null;
            while(cur != null){
                ListNode curN = cur.next;
                cur.next = head;
                head = cur;
                cur = curN;
            }
            return head;
        }
 
    
    }

5.1LinkedList的一些性质

 5.2 LinkedList的使用

 2 其他方法的使用

 

3 LinkedList的遍历

6.ArrayList 与 LinkedList的区别

小晓媛
关注
java中LinkedList与链表
m0_62055442的博客
10-01 554
java中LinkedList与链表
【数据结构与算法】LinkedList与链表
bit me的博客
11-29 2588
LinkedList与链表的使用和模拟实现，以及和ArrayList的区别
【数据结构】LinkedList与链表
m0_73107796的博客
08-05 2025
熟悉链表、掌握使用并模拟实现
数据结构之LinkedList与链表
sniper_fandc的博客
03-22 2875
目录 1.LinkedList的特点和存在意义 2.LinkedList的简单使用 2.1.LinkedList的构造 2.2.常见方法 2.3.遍历 3.链表结构 4.简单实现 4.1单向无头不循环链表 4.2.双向无头不循环链表 5.ArrayList与LinkedList的不同 1.LinkedList的特点和存在意义 LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节 点中，然后通过引用将节点连接起来了...
LinkedList和链表
2301_78804510的博客
04-21 1236
方法解释尾插将e插入到index位置尾插c中的元素删除index位置元素删除遇到的第一个o获取下标index位置元素将下标index位置元素设置为element清空判断o是否在线性表中返回第一个o所在下标返回最后一个o的下标截取部分list4.3LinkedList的遍历// add(elem): 表示尾插// foreach遍历// 使用迭代器遍历---正向遍历// 使用反向迭代器---反向遍历。
Java SE编程：LinkedList与链表数据结构解析
与ArrayList相比，LinkedList在进行添加和删除操作时效率更高，因为这些操作在链表中只需要改变相邻元素之间的链接，而不需要像ArrayList那样进行大量的数组移动。LinkedList类继承了AbstractSequentialList类，并...
LinkedList双向链表源码分析（附详细图解！！）
A_diligent_man的博客
07-18 1234
本文章分析LinkedList源码。
使用java模拟实现LinkedList单向链表
weixin_42022728的博客
03-13 450
1. 基础知识 线性表常见的分为顺序表(vector和ArrayList)和链表(LinkedList) 单向链表只能由前驱找到后继,每个节点有数据和指向下一个节点的指针 优缺点:增删快,查找满 增加节点:新节点指针指向后一个节点,新节点的前一个节点指针指向新节点. 删除节点:被删除的节点的前一个节点指向被删除节点指向的后一个节点. 为了使操作一致,使用增加使用头结点(哑元节点)的方法. 2....
LinkedList:链表
03-13
链表与数组不同，它不依赖于物理存储位置的连续性，而是通过节点之间的引用（或称为指针）来组织数据。在Python中，我们可以使用内置的`collections.deque`或者自定义类来实现链表。 标题提到的"LinkedList"包含了...
Java LinkedList 双向链表实现原理
01-20
相信大家都明白 LinkedList 是基于双向链表而实现的，本篇文章主要讲解一下双向链表的实现，并且我们参考 LinkedList 自己实现一个单链表尝试一下。 什么是链表？ 简单的来讲一下什么是链表：首先链表是一种线性的...
STL set
最新发布
hls0611的博客
11-09 200
练习题：P1059 [NOIP2006 普及组] 明明的随机数。
100种算法【Python版】第51篇——希尔排序
AnFany
11-06 280
100种算法【Python版】第51篇——希尔排序
【LeetCode】【算法】160.相交链表
passer__jw767的博客
11-05 355
Leetcode 160. 相交链表
【算法】（Python）贪心算法
yannan20190313的博客
11-04 2055
【算法】（Python）贪心算法（最大单元数，买卖股票最佳时机，最低加油次数）
洛谷 P2239 [NOIP2014 普及组] 螺旋矩阵
jzwalliser的博客
11-09 777
本文由Jzwalliser原创，发布在CSDN平台上，遵循CC 4.0 BY-SA协议。因此，若需转载/引用本文，请注明作者并附原文链接，且禁止删除/修改本段文字。
二叉树(一)
m0_74340589的博客
11-05 461
/ 写递归算法的关键是要明确函数的「定义」是什么，然后相信这个定义，利用这个定义推导最终结果，绝不要试图跳入递归。// 再说说归并排序的逻辑，若要对nums[lo…// 再看看回溯算法，前文回溯算法详解干脆直接说了，回溯算法就是个 N 叉树的前后序遍历问题，没有例外。// 其实很多动态规划问题就是在遍历一棵树，你如果对树的遍历操作烂熟于心，起码知道怎么把思路转化成代。//快速排序的逻辑是，若要对nums[lo….所有回溯、动归、分治算法，其实都是树的问题，而树的问题就永远逃不开树的递归遍历。
GJ Round (2024.10) Round 8~21
lunjiahao的博客
11-06 849
前言： 点此 返回 GJ Round 目录 Round 8 (10.5) A 给定 nnn 个区间，每个区间 [li,ri][l_i,r_i][li​,ri​]，最大化选取区间对数，使得每对区间 [li,ri],[lj,rj][l_i,r_i],[l_j,r_j][li​,ri​],[lj​,rj​] 满足 [li,ri]∩[lj,rj]=∅[l_i,r_i] \cap [l_j,r_j] =\varnothing[li​,ri​]∩[lj​,rj​]=∅ 先按 lil_ili​ 从小到大排序，再按
【刷题】优选算法
林宇恒的博客
11-06 473
如图，我们先算出最左边(1)和最右边(7)围起来的容量，然后，7不动，1继续和7的左边3，8，4...遍历算出容量，你会发现底是不断缩短的，同时高一直都是1，因为高只有两种情况，比它小或和它相等，所以1和7左边的值算出来的容量都是比1和7的容量小的，因为底在不断变小同时高可能不变也可能变小。根据两个实例和鸽巢原理可以发现不断的平方和最终都会形成环，所以我们可以联想到用快慢指针，慢指针走一步，快指针走两步，最终会在环相遇，判断相遇时是否为1。第一个实例是快乐数，因为会变为1且不断是1的循环。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值