【Java算法题】剑指offer_数据结构之01链表

已于 2023-05-29 22:27:30 修改
阅读量330 收藏 1
点赞数 1
分类专栏： Java 文章标签： 数据结构 算法 链表
于 2023-05-17 23:38:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43800119/article/details/130736286
版权

前言

刷题链接：
https://www.nowcoder.com/exam/oj/ta?page=2&tpId=13&type=265

1. 链表

JZ24 反转链表

[图片]

思路：基本操作，如下所示。
[图片]
[图片]

[图片]

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode ReverseList(ListNode head) {
        if(head == null){
            return null;
        }
        ListNode pre = null;
        ListNode cur = head;
        ListNode temp = null;

        while(cur != null){
            temp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
}

JZ6 从尾到头打印链表

[图片]

思路：

  1. 反转链表
  2. 添加元素至数组
/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        
        ArrayList<Integer> arr = new ArrayList<Integer>();

        // 1. 链表不为空，则反转链表
        if(listNode!=null){
            listNode = ReverseList(listNode);
            // 2. 添加元素到ArrayList
            ListNode cur = listNode;
            while(cur!=null){
                arr.add(cur.val);
                cur = cur.next;
            }
            return arr;
        }
        return arr; // 空链表返回空ArrayList
    }
    public ListNode ReverseList(ListNode head){ //反转链表
        ListNode pre = null;
        ListNode cur = head;
        ListNode temp = cur.next;

        while(cur != null){
            temp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
}

JZ25 合并两个排序的链表

[图片]

[图片]

思路：看代码很清楚，利用新的lsit存排序后的链表，小的先存。

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode Merge(ListNode list1,ListNode list2) {
        ListNode list = new ListNode(0);
        ListNode l = list;
        if(list1 == null || list2 == null){
            return list1 != null?list1:list2;
        }
        while(list1!=null && list2!=null){
            if(list1.val<=list2.val){
                l.next = list1;
                list1=list1.next;
            }else{
                l.next = list2;
                list2=list2.next;
            }
            l=l.next;
        }
        if(list1!=null){
            l.next = list1; 
        }
        if(list2!=null){
            l.next = list2;
        }
        return list.next;
    }
}

JZ52 两个链表的第一个公共节点

[图片]

[图片]

思路：Y字形链表，以相同的速度遍历两条链表最终总会相遇。（注意：当遍历链表1结束，将指针指向链表2的头。）

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        ListNode p1=pHead1, p2=pHead2;
        while(p1!=p2){
            p1 = (p1==null)?pHead2:p1.next;
            p2 = (p2==null)?pHead1:p2.next;
        }
        return p1;
    }
}

JZ23 链表中环的入口结点

[图片]

[图片]

思路：
快慢指针，快指针走两步，慢指针走一步。
[图片]

  1. 判断是否有环；
  2. 有环则将slow指针指向头，fast从相遇点出发，二者将在入环点相遇。
/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {

    public ListNode EntryNodeOfLoop(ListNode pHead) {
        ListNode fast = pHead;
        ListNode slow = pHead;
        while(fast.next!=null && fast.next.next!=null){
            fast = fast.next.next;
            slow = slow.next;
            if(fast==slow){ //判断有没有环
                break;
            }
        }
        if(fast.next==null || fast.next.next==null){ //无环返回null
            return null;
        }
        slow = pHead;
        while (slow != fast) { //找到环入口
            fast = fast.next;
            slow = slow.next;
        }
        return fast;
    }
}

JZ22 链表中倒数最后k个结点

[图片]

[图片]

思路：快慢指针，先让一个指针走k步，后面同步一个个走，快指针走到末尾的时慢指针刚好指向末尾第k个节点。

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pHead ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
    public ListNode FindKthToTail (ListNode pHead, int k) {
        // write code here
        if(pHead == null){
            return null;
        }
        ListNode slow = pHead;
        ListNode fast = pHead;

        while(k-->0){
            if(fast == null)
                return null;
            fast = fast.next; //先走k步
        }
        while(fast != null){
            fast = fast.next;
            slow = slow.next;
        }
        
        return slow;
    }
}

JZ35 复杂链表的复制

[图片]

[图片]

思路：参考这篇博客 https://blog.csdn.net/qq_43676757/article/details/106253305

使用常规方法一，将步骤分成三个：

  1. 复制节点
    [图片]

  2. 复制random节点给已拷贝节点
    [图片]

  3. 拆分链表
    [图片]

/*
public class RandomListNode {
    int label;
    RandomListNode next = null;
    RandomListNode random = null;

    RandomListNode(int label) {
        this.label = label;
    }
}
*/
public class Solution {
    public RandomListNode Clone(RandomListNode pHead) {
        if(pHead==null)
            return null;
        
        RandomListNode cur = pHead;
        //遍历原始链表，复制
        while(cur!=null){
            //拷贝节点
            RandomListNode temp = new RandomListNode(cur.label);
            //添加新节点到原始链表当前节点后面
            temp.next=cur.next;
            cur.next=temp;
            cur=temp.next;
        }

        //连接新链表的random节点
        cur = pHead;//回到头节点
        RandomListNode temp = pHead.next;
        while(cur!=null){
            if(cur.random==null){
                temp.random=null;
            }else{
                temp.random = cur.random.next; //新链表的random为cur的random下一个
            }
            cur = cur.next.next;
            if(temp.next!=null){
                temp=temp.next.next;
            }
        }

        //拆分链表
        cur = pHead;
        RandomListNode res = pHead.next;
        temp = res;
        while(cur!=null){
            cur.next=cur.next.next;
            cur=cur.next;
            if(temp.next!=null){
                temp.next = temp.next.next;
            }
            temp = temp.next;
        }
        return res;
    }
}

JZ76 删除链表中重复的结点

[图片]

[图片]

思路：需要前一个节点、当前节点和下一节点的信息。在表头添加一个节点作为pre，当前节点和下一节点相同的时候，当前指针往下移动；当数值不同的时才退出循环，将pre.next指向下一个节点。

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public ListNode deleteDuplication(ListNode pHead) {
        // 链表为空或者只有一个节点
        if(pHead == null || pHead.next==null){
            return pHead;
        }

        ListNode res = new ListNode(-1); //表头加一个节点
        res.next = pHead;
        ListNode pre = res;
        ListNode cur = pHead;
        
        while(cur!=null && cur.next!=null){
            if(cur.val == cur.next.val){ //相邻的节点值相同
                int tmp = cur.val;
                while(cur.next!=null && cur.next.val==tmp){
                    cur = cur.next; //跳过相同的节点    
                }
                //退出循环时，cur指向最后一个重复值
                cur = cur.next;
                pre.next = cur;
            }else{
                pre=cur;
                cur=cur.next;
            }
        }
        return res.next;
    }
}

JZ18 删除链表的节点

[图片]

思路：直观的想法就是记录下前一个节点，当搜索到匹配的数值，将前一个节点的next直接指向当前节点的下一个节点，达到删除当前节点的目的。特殊情况是表头节点满足条件！

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param head ListNode类 
     * @param val int整型 
     * @return ListNode类
     */
    public ListNode deleteNode (ListNode head, int val) {
        // write code here
        //1. 空则返回null
        if(head == null){ 
            return null;
        }
        ListNode pre = head; //pre记录当前节点前一个节点
        ListNode cur = head.next;
        //2.第一个元素就满足val，删除第一个元素
        if(pre!=null&&pre.val==val){
            pre=pre.next;
            return pre;
        }
        //3.第二个元素开始匹配
        while(cur!=null){
            if(cur.val==val){
                pre.next = cur.next;
                cur.next = null;
                break;
            }
            cur = cur.next;
            pre = pre.next;
        }
        return head;
    }
}

更简洁的代码（来源牛客网题解）：在单链表前再加一个节点( ListNode res = new ListNode(0); res.next = head; )，返回的时候记得去掉。

import java.util.*;
public class Solution {
    public ListNode deleteNode (ListNode head, int val) {
        //加入一个头节点
        ListNode res = new ListNode(0);
        res.next = head;
        //前序节点
        ListNode pre = res;
        //当前节点
        ListNode cur = head;
        //遍历链表
        while(cur != null){
            //找到目标节点
            if(cur.val == val){
                //断开连接
                pre.next = cur.next;
                break;
            }
            pre = cur;
            cur = cur.next;
        }
        //返回去掉头节点
        return res.next;
    }
}

2. 树

请看下篇分解：https://blog.csdn.net/qq_43800119/article/details/130937714

有一个想不明白的地方需要各位帮忙看看

题号：JZ33 二叉搜索树的后序遍历序列
问题：
运行{4,6,7,5}时错误，应该如何修正呢？出错的点在于处理右子树{6,7}时，order(seq,1,2)=>mid=0 没有该子树没有右子树，但是因为mid=0，还是会运行下面的右子树合法判断。
我将mid初始化为-1，额外添加了if(mid==-1) return true; 还有别的方法改进吗？

    
public class Solution {
    public boolean VerifySquenceOfBST(int [] sequence) {
        if(sequence.length==0){
            return false;
        }
        return order(sequence,0,sequence.length-1);
    }
    public boolean order(int[] sequence,int left, int right){
        if(left >= right) return true;
        int root = sequence[right]; //根节点为最后一个元素
        
        // 找到左右子树的分界点，第一个大于根节点的元素位置
        int mid = 0;
        for(int i=left;i<right;i++){
            if(sequence[i]>root){
                mid = i;
                break;
            }
        }

        // 判断右子树合不合法
        for(int i=mid;i<right;i++){
            if(sequence[i]<root){ //右子树存在小于root的元素则为false
                return false;
            }
        }

        return order(sequence,left,mid-1) && order(sequence,mid,right-1);
    }
}
zoetu
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
牛客网剑指offer_数据结构之链表(1)
cyl2637965156的博客
03-02 720
目录 一、 从头到尾打印链表 1.解题思路 此系列记录自己为了找工作而刷算法题的历程，最主要的目的是为了整理自己的思路，防止自己刷完就忘，二来如果能对后来者有所帮助，也不失为一件美事。 全程使用Java语言。 一、 从头到尾打印链表 题目描述： 输入一个链表的头节点，按链表从尾到头的顺序返回每个节点的值（用数组返回）。 1.解题思路 输入的为链表，输出的是列表的反序打印结果，难点在于如何考虑使用尽量优化的空间复杂度。 首先了解Java中ListCode的定义，在牛客网中的定义是：
数据结构与算法，剑指Offer 50题
yonggeit的博客
07-24 1539
模拟每个节点最多含有两个子树的树称为二叉树。下图就是一个二叉树。在计算机科学中，二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。一棵深度为k，且有2^k-1个节点的二叉树，称为满二叉树。这种树的特点是每一层上的节点数都是最大节点数。而在一棵二叉树中，除最后一层外，若其余层都是满的，并且最后一层或者是满的，或者是在右边缺少连续若干节点，则此二叉树为完全二叉树。
数据结构与算法_剑指Offer05_从尾到头打印链表_JAVA实现
loveloose的博客
04-25 111
2020.04.16 题目：输入个链表的头结点，从尾到头反过来打印出每个结点的值。
剑指Offer-数据结构与算法题目(Java实现)
聚沙成塔
05-24 841
1、栈与队列 【实现一个栈】 【实现一个队列】 【构造一个栈，取最大最小、pop()、push()都是o(1)】 【两个栈实现一个队列】 【两个队列实现一个栈】 【栈的入栈、出栈序列】 2、链表的基本操作 【链表反转】 【按k步反转链表】 【取链表的倒数k个数&中间节点】 【两个有序链表合成一个有序链表】 【删除重复节点】 【取两个链表的第一个交叉节点】 【取链表中环的第一个节点】 【约瑟...
【剑指offer之链表】链表类型所有题总结
Miiiiiiiiiii的博客
11-17 213
文章目录概述剑指 Offer 06 从尾到头打印链表反转数组AC代码剑指 Offer 22 链表中倒数第k个节点双指针算法AC代码剑指 Offer 24 反转链表反转链表AC代码剑指 Offer 18 删除链表的节点删除节点AC代码剑指 Offer 35 复制链表的复制找规律AC代码剑指 Offer 52 两个链表的第一个公共节点距离归纳法AC代码 概述 本篇文章记录剑指offer标签为链表的题。 下面的题都是在力扣上面做的，可以按照题名搜索即可 剑指 Offer 06 从尾到头打印链表 反转数组 将
剑指offer_24_反转链表_水题
HDUCheater的博客
02-02 456
class Solution { public ListNode reverseList(ListNode head) { ListNode ans = head; if (ans == null) { return null; } ListNode temp = head.next; ans.next = null; while(temp != null) {
剑指offer数据结构与算法第四章链表（021-029）
m0_49101782的博客
04-06 1122
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} * ListNode(int x) : val(x), next(nullptr) {} * ListNode(int x, ListNode *next) : val(x), next(next)
《剑指offer》66道算法题合集（java实现）
热门推荐
weixin_43774841的博客
01-20 2万+
1
java 版剑指offer算法集锦
徐公，微信公众号同名
07-23 727
微信公众号:徐公码字（stormjun94）来源:https://github.com/gdutxiaoxu/Android_interview 前言 现如今，如果你想进入大厂，腾讯，阿里，头条，拼多多等，不管是社招还是校招，肯定都会面试到算法的。 相信很多人有这样的想法，面试的时候早火箭，工作的时候拧螺丝。确实，这种情况非常常见，我也认同。但没办法，谁叫我们想进入大厂呢，主动权掌握在人家手里。 不过，这种情况也可以理解。怎么在几轮面试中确定面试者的水平呢？ 肯定是考察算法，基础这些，原理这些。 虽然这.
剑指offer_链表_删除链表的结点
freedomUSTB的博客
02-21 250
剑指offer_链表_删除链表的结点 思路：链表基本操作。 # class ListNode: # def __init__(self, x): # self.val = x # self.next = None # # 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可 # # # @param head ListNode类 # @param val int整型 # @return ListNode类 # class Solution:
剑指offer-Java代码_java_剑指offer_
09-30
《剑指Offer》是一本备受推崇的编程面试指南，尤其对于Java开发者来说，它提供了大量精心设计的面试题目，旨在帮助求职者提升编程技能和解决问题的能力。这本书的Java代码实现和文字说明是深入理解问题解决方案的...
sword-pointing-to-offer_java.zip_剑指offer_剑指offer java
09-20
这本书的原始版本是用C++语言编写的，而"剑指offer_java.zip_剑指offer_剑指offer java"则提供了这些问题的Java实现版本。Java是一种广泛使用的面向对象的编程语言，以其平台无关性、丰富的类库和安全性著称。将这些...
中级笔试算法题 剑指offer 数组 排序 数据结构 字符串.zip
06-16
"中级笔试算法题 剑指offer 数组 排序 数据结构 字符串.zip"这个压缩包文件，显然是一份针对数据结构及其应用的学习资源，特别适合准备面试或提升编程能力的大学生。其中可能包含了对数组、排序算法、数据结构以及...
剑指offer（java版）.rar_剑指offer_剑指offer java_剑指offer（java版）
09-24
《剑指Offer》是针对Java开发者的一本面试指南，它集结了47道常见的Java面试编程题目，旨在帮助求职者更好地准备技术面试，提升解决问题的能力。这本书覆盖了多个核心的编程概念和技术，包括设计模式、数据结构、...
《剑指Offer：数据结构与算法名企面试题精讲》.zip
06-16
《剑指Offer：数据结构与算法名企面试题精讲》是针对计算机科学与技术领域，尤其是准备进入IT行业的大学生和求职者的一份宝贵资源。这份压缩包包含了C/C++/JAVA/Python四种编程语言相关的数据结构学习笔记和资料，...
【Redis】Redis 底层的数据结构（结合源码）
秋玄的博客
08-22 897
Redis 底层数据结构详解
数据结构：用栈实现队列（232）LeetCode
最新发布
2303_81073778的博客
08-26 200
你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。你能否实现每个操作均摊时间复杂度为 O(1) 的队列？换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）
【数据结构】—— 树和二叉树
mist的博客
08-26 689
树和二叉树、堆（顺序结构）、二叉树链式结构
算法的学习笔记—二叉搜索树的后序遍历序列(牛客JZ33)
业精于勤，荒于嬉
08-22 834
通过递归地判断数组的子序列是否满足二叉搜索树的性质，我们可以有效地判断一个数组是否是某二叉搜索树的后序遍历序列。这个方法在逻辑上比较直观，并且能够处理复杂的情况，尽管其时间复杂度为O(n^2)，但在实际应用中仍然是一个实用的算法。希望通过这篇文章，大家能够更加深入地理解二叉搜索树及其后序遍历的相关概念，并掌握如何通过编程来解决这类问题。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVC。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zoetu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值