Java数据结构5-链表2

最新推荐文章于 2024-07-25 17:08:19 发布
最新推荐文章于 2024-07-25 17:08:19 发布
阅读量617 收藏 27
点赞数 19
分类专栏： 数据结构 文章标签： 数据结构 java 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhuiluoi/article/details/139974424
版权

1. 链表面试题

  1. 给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

链接

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

        while (cur != null) {
            ListNode curN = cur.next;
            cur.next = pCur;
            pCur = cur;
            cur = curN;
        }

        return pCur;

    }
    
}
  1. 给你单链表的头结点 head ，请你找出并返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。

链接

class Solution {
    public ListNode middleNode(ListNode head) {
        ListNode cur1 = head;
        ListNode cur2 = head;

        while (cur2 != null && cur2.next != null) {
            cur1 = cur1.next;
            cur2 = cur2.next.next;
        }

        return cur1;
    }
}
  1. 实现一种算法，找出单向链表中倒数第 k 个节点。返回该节点的值。

链接

public int kthToLast(ListNode head, int k) {
        ListNode cur1 = head;
        ListNode cur2 = head;

        for (int i = 0; i < k-1; i++) {
            cur1 = cur1.next;
        }

        while (cur1.next != null) {
            cur1 = cur1.next;
            cur2 = cur2.next;
        }
        
        return cur2.val;

    }
  1. 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

链接

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode cur1 = list1;
        ListNode cur2 = list2;
        ListNode newHead = new ListNode(0);
        ListNode cur3 = newHead;
        
        while (cur1 != null && cur2 != null) {
            if (cur1.val < cur2.val) {
                cur3.next = cur1;
                cur1 = cur1.next;
            } else {
                cur3.next = cur2;
                cur2 = cur2.next;
            }
            cur3 = cur3.next;
        }
        
        if (cur1 != null) {
            cur3.next = cur1;
        }
        if (cur2 != null) {
            cur3.next = cur2;
        }
        
        return newHead.next;
        
    }
}
  1. 现有一链表的头指针 ListNode* pHead，给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序，返回重新排列后的链表的头指针。

链接

public class Partition {
    public ListNode partition(ListNode pHead, int x) {
        // write code here
        if (pHead == null) {
            return null;
        }

        ListNode bs = null;
        ListNode be = null;
        ListNode as = null;
        ListNode ae = null;

        ListNode cur = pHead;
        
        while (cur != null) {
            
            if (cur.val < x) {
                if (bs == null) {
                    bs = be = cur;
                } else {
                    be.next = cur;
                    be = be.next;
                }
                cur = cur.next;
            } else {
                if (as == null) {
                    as = ae = cur;
                } else {
                    ae.next = cur;
                    ae = ae.next;
                }
                cur = cur.next;
            }

        }
        
        if (bs == null) {
            return as;
        }
        
        be.next = as;

        if (as != null) {
            ae.next = null;
        }
        return bs;
    }
}
  1. 对于一个链表，请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法，判断其是否为回文结构。给定一个链表的头指针A，请返回一个bool值，代表其是否为回文结构。保证链表长度小于等于900。

链接

public class PalindromeList {
    public boolean chkPalindrome(ListNode A) {
        // write code here
        if (A == null) {
            return true;
        }

        ListNode fast = A;
        ListNode slow = A;

        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        ListNode mid = slow;
        ListNode cur = slow.next;
        while (cur != null) {
            ListNode curN = cur.next;
            cur.next = slow;
            slow = cur;
            cur = curN;
        }

        while (A != mid) {
            if (A.val != slow.val) {
                return false;
            }
            
            A = A.next;
            slow = slow.next;
        }
        return true;

    }
}
  1. 给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。

链接

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode p1 = headA;
        ListNode p2 = headB;
        
        int lenA = 0;
        int lenB = 0;

        while (p1 != null) {
            lenA++;
            p1 = p1.next;
        }

        while (p2 != null) {
            lenB++;
            p2 = p2.next;
        }

        int len = lenA - lenB;

        p1 = headA;
        p2 = headB;

        if (len < 0) {
            p1 = headB;
            p2 = headA;
            len = lenB - lenA;
        }

        while (len != 0) {
            p1 = p1.next;
            len--;
        }

        while (p1 != p2) {
            p1 = p1.next;
            p2 = p2.next;
        }
        return p1;

    }
}
  1. 给你一个链表的头节点 head ，判断链表中是否有环。如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。如果链表中存在环 ，则返回 true 。 否则，返回 false 。

链接

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;
    }
}
  1. 给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。不允许修改 链表。

链接

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

2. LinkedList的模拟实现

public class IndexNotLegalException extends RuntimeException{
    public IndexNotLegalException() {
    }

    public IndexNotLegalException(String message) {
        super(message);
    }
}


// 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 node = new ListNode(data);
        if (head == null) {
            head = last = node;
            return;
        }
        node.next = head;
        head.prev = node;
        head = node;
    };
    //尾插法
    public void addLast(int data) {
        ListNode node = new ListNode(data);
        if (head == null) {
            head = last =node;
            return;
        }
        last.next = node;
        node.prev = last;
        last = node;


    };
    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index,int data) {
        try {
            checkIndex(index);
        }catch (IndexNotLegalException e) {
            e.printStackTrace();
        }
        if(index == 0) {
            addFirst(data);
            return;
        }
        if(index == size()) {
            addLast(data);
            return;
        }
        ListNode cur = findIndex(index);
        ListNode node = new ListNode(data);

        node.next = cur;
        node.prev = cur.prev;
        cur.prev.next = node;
        cur.prev = node;
    };

    private ListNode findIndex(int index) {
        ListNode cur = head;
        while (index != 0) {
            cur = cur.next;
            index--;
        }
        return cur;
    }
    private void checkIndex(int index) {
        if(index < 0 || index > size()) {
            throw new IndexNotLegalException("双向链表插入index位置不合法: "+index);
        }
    }

    //查找是否包含关键字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) {
                        last = null;
                    } else {
                        head.prev = null;
                    }
                } else {
                    cur.prev.next = cur.next;
                    if (cur.next == null) {
                        last = last.prev;
                    } else {
                        cur.next.prev = cur.prev;
                    }
                }
                return;
            }
            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) {
                        last = null;
                    } else {
                        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;
        }
    }

    //得到单链表的长度
    public int size() {
        int count = 0;
        ListNode cur = head;
        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.val = null;
            cur.prev = null;
            cur.next = null;
            cur = curN;
        }
        head = last = null;
    };
}


public class Test {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();

        list.addFirst(1);
        list.addFirst(2);
        list.addFirst(3);
        list.addLast(4);
        list.addLast(5);

        list.display();
        list.addIndex(0, 3);
        list.addIndex(2, 6);
        list.display();

        list.remove(4);
        list.display();
        list.removeAllKey(3);
        list.display();

    }
}

3. LinkedList的使用

3.1 什么是LinkedList

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

在这里插入图片描述

在集合框架中，LinkedList也实现了List接口，具体如下：

在这里插入图片描述

【说明】

  1. LinkedList实现了List接口

  2. LinkedList的底层使用了双向链表

  3. LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问

  4. LinkedList的任意位置插入和删除元素时效率比较高，删除的时侯时间复杂度为O(1)

  5. LinkedList比较适合任意位置插入的场景

3.2 LinkedList的使用

3.2.1 LinkedList的构造

方法解释
LinkedList()无参构造
public LinkedList(Collection<? extends E> c)使用其他集合容器中元素构造List
public static void main(String[] args) {
  // 构造一个空的LinkedList
  List<Integer> list1 = new LinkedList<>();
  List<String> list2 = new java.util.ArrayList<>();
  list2.add("JavaSE");
  list2.add("JavaWeb");
  list2.add("JavaEE");
  // 使用ArrayList构造LinkedList
  List<String> list3 = new LinkedList<>(list2);
}

3.2.2 LinkedList的其他常用方法介绍

方法解释
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
import java.util.LinkedList;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new MyLinkedList<>();
        list.add(1); // add(elem): 表示尾插
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(7);
        System.out.println(list.size());
        System.out.println(list);
        // 在起始位置插入0
        list.add(0, 0); // add(index, elem): 在index位置插入元素elem
        System.out.println(list);
        list.remove(); // remove(): 删除第一个元素，内部调用的是removeFirst()
        list.removeFirst(); // removeFirst(): 删除第一个元素
        list.removeLast(); // removeLast(): 删除最后元素
        list.remove(1); // remove(index): 删除index位置的元素
        System.out.println(list);
        // contains(elem): 检测elem元素是否存在，如果存在返回true，否则返回false
        if(!list.contains(1)){
            list.add(0, 1);
        }
        list.add(1);
        System.out.println(list);
        System.out.println(list.indexOf(1)); // indexOf(elem): 从前往后找到第一个elem的位置
        System.out.println(list.lastIndexOf(1)); // lastIndexOf(elem): 从后往前找第一个1的位置
        int elem = list.get(0); // get(index): 获取指定位置元素
        list.set(0, 100); // set(index, elem): 将index位置的元素设置为elem
        System.out.println(list);
        // subList(from, to): 用list中[from, to)之间的元素构造一个新的LinkedList返回
        List<Integer> copy = list.subList(0, 3);
        System.out.println(list);
        System.out.println(copy);
        list.clear(); // 将list中元素清空
        System.out.println(list.size());
    }
}

3.2.3 LinkedList的遍历

import java.util.LinkedList;
import java.util.ListIterator;

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1); // add(elem): 表示尾插
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(7);
        System.out.println(list.size());
// foreach遍历
        for (int e:list) {
            System.out.print(e + " ");
        }
        System.out.println();
// 使用迭代器遍历---正向遍历
        ListIterator<Integer> it = list.listIterator();
        while(it.hasNext()){
            System.out.print(it.next()+ " ");
        }
        System.out.println();
// 使用反向迭代器---反向遍历
        ListIterator<Integer> rit = list.listIterator(list.size());
        while (rit.hasPrevious()){
            System.out.print(rit.previous() +" ");
        }
        System.out.println();
    }
}

4. ArrayList和LinkedList的区别

不同点ArrayListLinkedList
存储空间上物理上一定连续逻辑上连续，但物理上不一定连续
随机访问支持O(1)不支持：O(N)
头插需要搬移元素，效率低O(N)只需修改引用的指向，时间复杂度为O(1)
插入空间不够时需要扩容没有容量的概念
应用场景元素高效存储+频繁访问任意位置插入和删除频繁
zhuiluoi
关注
  • 19
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java数据结构篇-链表与数组实现栈.pptx.pptx
12-19
Java数据结构是编程中至关重要的组成部分，它们定义了如何有效地存储和操作数据。在这个话题中，我们将重点关注两种常见的数据结构——链表和数组，并探讨它们如何被用来实现栈这一特定的抽象数据类型。 栈是一种...
数据结构-链表(LingkedList)介绍和Java示例代码
07-01
链表是一种重要的线性数据结构，它与数组相比具有独特的特性和优势。链表由一系列节点构成，每个节点包含两部分：数据元素和指向下一个节点的引用。这种结构允许链表在内存中不连续分布，提供了动态扩展和收缩的能力...
Java数据结构--链表
weixin_56846554的博客
03-13 1030
单链表是一种链式存取的数据结构，链表中的数据是以结点来表示的，每个结点由元素和指针构成。 元素表示数据元素的映象，就是存储数据的存储单元；指针指示出后继元素存储位置，就是连接每个结点的地址数据。 以结点的序列表示的线性表称作线性链表，也就是单链表，单链表是链式存取的结构。
java数据结构-链表详解
m0_63526467的博客
05-04 4069
文章目录1.数据结构-链表详解1.1单链表1.1.1单链表节点的尾部添加1.1.2单链表节点的自动排序添加1.1.3单链表节点的修改1.1.4单链表节点的删除1.2单链表面试题1.2.1单链表的有效节点个数1.2.2单链表倒数第k个结点1.2.3单链表反转1.2.4单链表逆序打印1.3双向链表1.3.1双向链表介绍1.3.2双向链表增删改查1.4单向环形链表1.4.1约瑟夫（Josephu）环问题 1.数据结构-链表详解 链表可分为三类： 单链表 双向链表 循环列表 下面具体分析三个链表的应用。 1.1
Java数据结构--双向链表
m0_74808313的博客
04-23 1648
在上一篇中我们学习了单向链表的实现，链表中我们除了单向链表还有双向链表，在这一篇我们将更进一步地了解链表，实现双向链表。
Java数据结构-认识链表
weixin_55752048的博客
01-28 3261
一.链表的概念及结构 1.链表的概念 链表是一种物理存储结构上非连续的存储结构。数据元素中的逻辑顺序是通过链表中的引用链接次序实现的 2.链表的分类
JAVA-数据结构-链表-附leetcode
jinghang2000的博客
03-13 1248
个人笔记
数据结构-链表 JAVA语言实现
08-24
数据结构-链表 JAVA语言实现,包含单向链表、双向链表、循环链表的遍历、删除和插入 详细介绍：http://blog.csdn.net/z740852294/article/details/77369439
Java员工管理系统-链表
04-10
基于此需求，我们开发了一款基于Java的员工管理系统，该系统利用链表和二叉排序树这两种数据结构来存储和管理公司的员工信息。 #### 二、主要功能模块 ##### 1. 部门枚举 - **定义**：首先定义了一个`Dept`枚举...
c语言（7.23）
fhgfyrsg的博客
07-23 542
【代码】c语言（7.23）
【算法与数据结构】并查集
2301_79728896的博客
07-23 326
合并和查询集合的数据结构，KruskalLCA查询的时间复杂度：小于O(log2​n)近乎O(1)
Linux嵌入式学习——数据结构——线性表的链式结构
m0_71703182的博客
07-24 740
在链表的尾部插入一个新节点，该节点包含指定的数据data。函数返回成功或失败的状态码。
手撕数据结构02--二分搜索（附源码）
weixin_64593595的博客
07-24 333
对于二分搜索的理论与实现的知识点学习。
数据结构：逻辑结构与物理结构
Weiki的博客
07-24 944
数据结构：逻辑结构与物理结构
数据结构之深入理解简单选择排序：原理、实现与示例（C，C++）
qq_35320456的博客
07-24 754
简单选择排序虽然在大数据量下效率不高，但它易于理解和实现，是理解排序算法基本思想的良好起点。在实际应用中，如果数据量较小或者对排序稳定性要求不高，选择排序可以作为一种简单有效的选择。
数据结构：数据类型与抽象数据类型
最新发布
Weiki的博客
07-25 1187
数据结构：数据类型与抽象数据类型
【初阶数据结构】复杂度算法题篇
2301_79849925的博客
07-24 304
我们可以先将所有元素翻转，这样尾部的 kmodn 个元素就被移至数组头部，然后我们再翻转 [0,kmodn−1] 区间的元素和 [kmodn,n−1] 区间的元素即能得到最后的答案。该方法基于如下的事实：当我们将数组的元素向右移动 k 次后，尾部 kmodn 个元素会移动至数组头部，其余元素向后移动 kmodn 个位置。时间复杂度：O(n)空间复杂度：O(1)
数据结构之判断完全二叉树详解与示例（C，C++）
qq_35320456的博客
07-23 419
通过上述C和C++的实现示例，我们可以看到判断一个二叉树是否为完全二叉树的基本方法是使用层序遍历。在遍历过程中，我们通过设置一个标记来区分节点是否应该为叶子节点，从而判断二叉树是否满足完全二叉树的条件。这种方法的时间复杂度为O(n)，其中n是二叉树中节点的数量，因为每个节点最多只会被访问一次。在实际应用中，完全二叉树由于其特殊的结构，常用于堆的实现，因为它可以在数组中有效地表示，同时保持堆的操作效率。理解并掌握判断完全二叉树的方法，对于深入理解二叉树结构和相关算法有重要意义。
java数据结构-循环链表的设计与实现
03-16
循环链表是一种特殊的链表，它的最后一个节点指向第一个节点，形成...总之，循环链表是一种非常有用的数据结构，可以在很多场景中使用。在Java中，我们可以通过定义Node类和头节点、尾节点来实现循环链表的设计与实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值