剑指offer中 与链表有关的编程练习题 Java编码

最新推荐文章于 2022-12-11 23:47:04 发布
最新推荐文章于 2022-12-11 23:47:04 发布
阅读量273 收藏
点赞数
分类专栏： android 数据结构基础 文章标签： java string 链表 编程 存储
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27478765/article/details/77884449
版权

（1）从尾到头打印链表

题目描述

输入一个链表，从尾到头打印链表每个节点的值。
思想：用栈来存储节点，顺序出栈就为从尾到头打印节点值


     public static void main(String[] arg) {
         ListNode a=new ListNode(0);
         a.next=new ListNode(1);
         a.next.next=new ListNode(2);
         a.next.next.next=new ListNode(3);
         a.next.next.next.next=new ListNode(4);
         a.next.next.next.next.next=new ListNode(5);
         System.out.println("从后向前打印链表的节点");
         printListFromTailToHead(a);
     }

    private static void printListFromTailToHead(ListNode a) {
        if(a==null) {
            return ;
        }
        Stack<ListNode> stack=new Stack<ListNode>();
        while(a!=null) {
            stack.push(a);
            a=a.next;
        }
        while(!stack.isEmpty()) {
            System.out.print(stack.pop().val+" ");
        }

    }

这里写图片描述

（2）链表中倒数第k个结点

题目描述

输入一个链表，输出该链表中倒数第k个结点。
思路：先计数链表的节点，倒数第k个节点，即为正数n-k个节点

     public static void main(String[] arg) {
         ListNode a=new ListNode(0);
         a.next=new ListNode(1);
         a.next.next=new ListNode(2);
         a.next.next.next=new ListNode(3);
         a.next.next.next.next=new ListNode(4);
         a.next.next.next.next.next=new ListNode(5);
         System.out.println("链表中倒数第k个结点");
         FindKthToTail(a,5);
     }

    private static void FindKthToTail(ListNode a, int k) {
        if(a==null) {
            return ;
        }
        int count=0;
        ListNode ln=a;
        while(ln!=null) {
            count++;
            ln=ln.next;
        }
        ListNode lo=a;
        for(int i=0;i<count;i++) {
            if(i==k-1) {
                System.out.println(lo.val+"此时，k的值为"+k);
            }
            lo=lo.next;
        }
    }

这里写图片描述

（3）反转链表

题目描述

输入一个链表，反转链表后，输出链表的所有元素。
思路：链表操作

     public static void main(String[] arg) {
         ListNode a=new ListNode(0);
         a.next=new ListNode(1);
         a.next.next=new ListNode(2);
         a.next.next.next=new ListNode(3);
         a.next.next.next.next=new ListNode(4);
         a.next.next.next.next.next=new ListNode(5);
         System.out.println("反转链表：");
         ReverseList(a);
     }

    private static void ReverseList(ListNode pHead) {
        if(pHead==null) {
            return ;
        }
        ListNode pre=null;
        ListNode next=null;
        while(pHead!=null) {
            next=pHead.next;//用next来保存pHead的下一个节点
            pHead.next=pre;//pHead.next指向pre实现反转
            pre=pHead;//依次移动到下一节点
            pHead=next;
        }
        while(pre!=null) {
            System.out.print(pre.val+" ");
            pre=pre.next;
        }
    }

这里写图片描述

（3）合并两个排序的链表

题目描述

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。


     public static void main(String[] arg) {
         ListNode a=new ListNode(1);
         a.next=new ListNode(3);
         a.next.next=new ListNode(5);
         a.next.next.next=new ListNode(7);
         a.next.next.next.next=new ListNode(9);
         a.next.next.next.next.next=new ListNode(11);

         ListNode b=new ListNode(0);
         b.next=new ListNode(2);
         b.next.next=new ListNode(4);
         b.next.next.next=new ListNode(6);
         b.next.next.next.next=new ListNode(8);
         b.next.next.next.next.next=new ListNode(10);
         System.out.println("合并链表");
         Merge(a,b);
     }

    private static void Merge(ListNode a, ListNode b) {
        if(a==null&&b==null) {
            return ;
        }
        if(a!=null&&b==null) {
            return ;//这里自己写，我暂时返回空
        }
        if(a==null&&b!=null) {
            return ;//这里自己写，我暂时返回空
        }
        if(a!=null&&b!=null) {
            ListNode p=new ListNode(-1);
            ListNode ln=p;
            while(a!=null&&b!=null) {
                if(a.val<b.val) {
                    ln.next=a;
                    a=a.next;
                }else {
                    ln.next=b;
                    b=b.next;
                }
                ln=ln.next;
            }
            if(a!=null) {
                ln.next=a;
            }
            if(b!=null) {
                ln.next=b;
            }
            while(p.next!=null) {
                System.out.print(p.next.val+" ");
                p.next=p.next.next;
            }
        }
    }

这里写图片描述

（4）复杂链表的复制

题目描述

输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）

public RandomListNode Clone(RandomListNode pHead)
    {
        if(pHead==null){
            return null;
        }
       RandomListNode p=pHead;
        RandomListNode t=pHead; 
        while(p!=null){//复制节点
           RandomListNode q=new RandomListNode(p.label);
            q.next=p.next;
            p.next=q;
            p=q.next;
        }
        while(t!=null){
            RandomListNode q=t.next;
            if(t.random!=null){
                q.random=t.random.next;
            }
            t=q.next;
        }
        RandomListNode s=new RandomListNode(0);
        RandomListNode s1=s;
        while(pHead!=null){
            RandomListNode q=pHead.next;
            s.next=q;
             pHead.next=q.next;//原来的指向断开，目的使得pHead可以顺利指向源列表的下一节点
            s=s.next;
            pHead=pHead.next;
        }
        return s1.next; 
    }

这里写图片描述

（5）两个链表的第一个公共结点

题目描述

输入两个链表，找出它们的第一个公共结点。


     public static void main(String[] arg) {
         ListNode a=new ListNode(1);
         a.next=new ListNode(3);
         a.next.next=new ListNode(5);
         a.next.next.next=new ListNode(7);
         a.next.next.next.next=new ListNode(9);
         a.next.next.next.next.next=new ListNode(11);

         ListNode b=new ListNode(5);
         b.next=new ListNode(2);
         b.next.next=new ListNode(4);
         b.next.next.next=new ListNode(6);
         b.next.next.next.next=new ListNode(8);
         b.next.next.next.next.next=new ListNode(10);
         System.out.println("两个链表的第一个公共结点:");
         FindFirstCommonNode(a,b);
     }

    private static void FindFirstCommonNode(ListNode a, ListNode b) {
        if(a==null||b==null) {
            return ;
        }
        ArrayList<Integer> list=new ArrayList<Integer>();
        while(a!=null) {
            list.add(a.val);
            a=a.next;
        }   
        while(b!=null) {
            if(list.contains(b.val)) {
                System.out.print(b.val);
                return ;
            }
            b=b.next;
        }
    }

这里写图片描述

（6）链表中环的入口结点

题目描述

一个链表中包含环，请找出该链表的环的入口结点。
思路：定义两个节点，同时遍历一个比一个快一倍，当它们相遇的时候差距为一环的数量，然后将一个置为起点，两个同时走，相遇的地点即为环的入口。


    public static void main(String[] arg) {
     ListNode a=new ListNode(0);
     a.next=new ListNode(1);
     a.next.next=new ListNode(2);
     a.next.next.next=new ListNode(3);
     a.next.next.next.next=new ListNode(4);
     a.next.next.next.next.next=a.next.next;
     System.out.println("链表中环的入口结点为：");
    EntryNodeOfLoop(a);
    }

    private static void EntryNodeOfLoop(ListNode a) {
        if(a==null) {
            return ;
        }
        ListNode p=a;
        ListNode q=a;
        while(q!=null&&q.next!=null) {
            p=p.next;
            q=q.next.next;
            if(p.val==q.val) {
                q=a;
                while(p.val!=q.val) {
                    p=p.next;
                    q=q.next;
                }
                System.out.print(p.val);
                return ;
            }
        }
    }

这里写图片描述

（7）删除链表中重复的结点

题目描述

在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5

    public static void main(String[] arg) {
         ListNode a=new ListNode(0);
         a.next=new ListNode(1);
         a.next.next=new ListNode(2);
         a.next.next.next=new ListNode(3);
         a.next.next.next.next=new ListNode(4);
         a.next.next.next.next.next=new ListNode(4);
         System.out.println("链表中环的入口结点为：");
         deleteDuplication(a);
        }

    private static void deleteDuplication(ListNode a) {
        if(a==null) {
            return ;
        }
        ListNode first=new ListNode(0);
        first.next=a;
        ListNode pre=a;
        ListNode last=first;
        while(pre!=null) {
            if(pre.val==pre.next.val) {
                int ps=pre.val;
                while(pre!=null&&ps==pre.val) {
                    pre=pre.next;
                }
                last.next=pre;
            }else {
                last=pre;
                pre=pre.next;
            }

        }
        while(first.next!=null) {
            System.out.print(first.next.val+" ");
            first.next=first.next.next;
        }   
    }

这里写图片描述

gracefullum
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode-jian-zhi-offer:剑指Offer50题视频讲解
06-29
注意：讲解视频中的题目可能和剑指 Offer 书上的题目有些许不同，不保证 100% 一致。 另外，在我看来，有些题目练习的意义不大，已经使用删除线移除。 二维数组中的查找 - - leetcode 240 | lintcode 38 替换空格 从...
lrucacheleetcode-AlgorithmicPractice:关于LeetCode算法的练习(主要包括剑指Offer题解,算法概念
06-29
本篇是关于LeetCode算法练习的总结(题目主要来源于剑指offer)，内容划分为以下章节： 注: main.cpp展示测试效果; 一.基础数据结构 1.1 字符串 序号 题目(解答链接) LeetCode(原题链接) 1 2 3 4 5 6 7 8 9 10 1.2 ...
金典链表算法题（Java实现，简单详细）+题目链接
m0_62468521的博客
12-11 698
金典链表算法题 Java实现，简单详细，轻松拿捏链表！
链表经典练习题合集（Java版）
qq_58284486的博客
03-15 2418
最近开始了数据结构的学习，数据结构是比较抽象的，需要不断的进行画图总结，不断地刷相关的题来加强自己对于数据结构的理解，我会不断地更新博客以及上传自己的做题记录以及题解，希望可以给大家带来帮助，也希望大家可以指出我存在的问题，共同进步☺ 这是我的gitee链接，所有的代码都已上传至gitee中：gitee代码仓库 目录 移除链表元素 反转链表 链表的中间结点 链表中倒数第k个结点 合并两个有序链表 移除链表元素 原题链接：203.移除链表元素 题目描述： 给你...
Java链表试题详解（超全常见题型）
Zincy星辰
03-19 1303
目录 1. 移除链表元素⭐ 2. 翻转/逆置链表⭐ 2.1 头插法 2.2 三指针法 3. 链表的中间结点⭐ 4.链表中倒数第k个结点⭐ 5. 合并两个有序链表⭐ 6. 链表分割⭐ 7.删除链表中重复的结点⭐⭐⭐ 8. 链表的回文结构⭐⭐⭐ 9. 相交链表⭐ 10. 环形链表⭐⭐ 11. 环形链表Ⅱ⭐⭐⭐ 1. 移除链表元素⭐ 203. 移除链表元素 - 力扣（LeetCode） (leetcode-cn.com) 思路：定义前驱prev和cur，循环完再判断头结点...
new ListNode常用方法
来杯奶茶
11-05 8739
1、初始化一个空结点，没有复制，指针指向list ListNode list=new ListNode(); 2、初始化一个空结点，初始值为0，指针指向为list ListNode list=new ListNode(0); 3、初始化一个空结点，初始赋值为0，并且list的下一个next指针指向head，指针指向为list ListNode list=new ListNode(0,head); 4、定义一个空链表 ListNod...
C++ 链表ListNode list=new ListNode() ，ListNode list=new ListNode(0) 与 ListNode list=null 的区别
11-13 5463
ListNode list=new ListNode() 上面代码初始化一个空节点，没有值，接下来需要给他进行赋值。 ListNode list=new ListNode(0) 上面代码初始化一个节点值为0的空节点，比较方便简洁。 ListNode list=null 上面代码定义一个空链表。 ...
买股票最佳时期leetcode-Data_Structure_Exercises:LeetCode刷题记录、《剑指Offer》书中相关面试题及
07-07
其中《剑指Offer》书中相关试题的Python实现主要参考《剑指offer（第二版）》和。 哈希表： 面试题50：第一个只出现一次的字符 链表： 面试题06：从尾到头打印链表 （单向链表的增删改查，栈，递归） 面试题18：删除...
算法：“面试算法练习级攻略”-“ LeetCode题解”-“剑指优惠题解”
01-31
算法练级计划以面试算法过渡为线索，总结归纳面试涉及的算法知识点，整理LeetCode以及“剑指要约”出现的面试转换，在大量的LeetCode过渡中梳理一个刷题脉络，让大家能够在有限的频率，通过面试算法回归的练习，提高...
leetcodeoj调试-LeetCode-Exercise:LeetCode刷题&剑指offer第二版题解(67题已完成)&部分数据结构的实
07-01
leetcode oj 调试 LeetCode练习 ...CaptureOffer：剑指offer第二版68题题解和部分面试模拟题题解，OJ平台为牛客网 Interview，AlibabaInterview：面试题题解 java/utils:几种算法的实现 java/inteview:
ListNode list=new ListNode() 、 ListNode list=new ListNode(0) 与 ListNode list=null 的区别
看风起云落的博客
08-17 2万+
ListNode list=new ListNode()初始化一个空节点，无值,不提倡此种写法。 ListNode list=new ListNode(0) 初始化一个节点值为0的空节点，最常用最正规写法 ListNode list=null 为空，什么都没有，一般不这么写； ...
链表面试题总结(java实现)
kkkkkkkk的博客
01-07 2241
关于链表的基本实现在上另一篇博客里面有写http://blog.csdn.net/a447332241/article/details/78947827 这里简单总结一下一些常见的链表面试题 1.链表反转 2.为尾到头打印链表 3.合并有序链表 4.判断链表是否有环 5.求链表的倒数第k个结点 1.链表反转 我们定义三个指针,分别记录当前遍历到的结点,它的前一个结点以及后一
链表编程题
裸奔的小强的博客
05-17 222
package java_core.Node; import java.util.*; /* 环形链表 141 输入一个链表的头结点, 判断该链表是否是环形链表 https://leetcode-cn.com/problems/linked-list-cycle/solution/huan-xing-lian-biao-by-leetcode/ */ public class NodeTest { public static void main(String[] args) {
经典笔试编程题--Java实现
热门推荐
胡倩萌的博客
08-08 5万+
1.输入一个正数n，输出所有和为n的连续正数序列。 分析：设定两个指针，min指向和为n的连续正数序列的最小值，max指向和为n的连续正数序列最大值。sum表示真正的和。 初始情况下,min、max和sum 都指向1. 当sum小于n时，max++； 当sum大于n时，min++; 当sum等于n时，输出整个序列。public class a { public static void ge
java链表编程题总结
basycai的博客
07-09 673
转自：http://www.jb51.net/article/71885.htm 这份笔记整理了整整一个星期，每一行代码都是自己默写完成，并测试运行成功，同时也回顾了一下《剑指offer》这本书中和链表有关的讲解，希望对笔试和面试有所帮助。本文包含链表的以下内容：　　1、单链表的创建和遍历　　2、求单链表中节点的个数　　3、查找单链表中的倒数第k个结点（剑指offer，题15）　　4、查找单链表
剑指offer编程题（JAVA实现)——第25题：复杂链表的复制
JZ
10-13 6428
github https://github.com/JasonZhangCauc/JZOffer import java.util.HashMap; /** * * 剑指offer编程题（JAVA实现)——第25题：复杂链表的复制 * * 题目描述 * 输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点， * 另一个特殊指针指向任意一个节点）...
java链表面试编程题
贾红平
04-12 452
通过编码实现日常关于链表可能会遇到到编程题1 两个链表是各自自增的,要求合拼之后的链表满足单调不递减/** * 两个递增的单链表合并保持单调递增 * * 递归求解 * @param firstNode * @param secondNode * @return */ public Node mergeNode(Node firstNode,Node secondNode){ ...
Java · 链表相关练习题 · 高频面试题 · 有难度啊
sfg0861的博客
09-25 309
链表相关练习题 · 高频面试题编写代码，以给定值 x 为基准将链表分割成两部分，所有小于 x 的结点排在大于或等于 x 的结点之前。在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。给定一个带有头结点 head 的非空单链表，返回链表的中间结点。新链表是通过拼接给定的两个链表的所有节点组成的。代码返回的是整个新链表，而不是内存图的新结点。将两个有序链表合并为一个新的有序链表并返回。
JAVA实现链表面试题
bin的主栏
07-08 5962
这篇文章主要介绍了JAVA相关实现链表的面试题，代码实现非常详细，每一个方法讲解也很到位，特别适合参加Java面试的朋友阅读。 这份笔记整理了整整一个星期，每一行代码都是自己默写完成，并测试运行成功，同时也回顾了一下《剑指offer》这本书中和链表有关的讲解，希望对笔试和面试有所帮助。 本文包含链表的以下内容： 　　1、单链表的创建和遍历 　　2、求单链表中
K - 双向链表练习题
最新发布
03-25
A：好的，下面是K - 双向链表练习题的解答。 题目描述： 设计一个数据结构，要求实现双向链表的基本操作：插入、删除、反转等，并实现一个方法向链表中添加一个元素。同时，该数据结构需要支持以下操作： 1. get...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值