单链表真题演练

最新推荐文章于 2022-05-18 22:19:50 发布
最新推荐文章于 2022-05-18 22:19:50 发布
阅读量169 收藏
点赞数
分类专栏： JavaSE基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38574563/article/details/107339396
版权

1.将两个有序单链表合并成一个有序单链表

  实现步骤：

（1）获得head1和head2中数据值较小的节点，并设置为合并后链表的首节点。

（2）通过循环循环依次获得链表1和链表2中数据较小 的节点，并添加到合并链表的末尾 。

（3）当步骤2执行完毕，如果某一链表中的首节点不为null,则将该链表首节点及其之后的节点添加到合并后链表的末尾。

public class MergeSingleLinkList {
    public static void main(String[] args) {
        //创建两个单链表
        //链表1
        Node node1_4 = new Node(289);
        Node node1_3 = new Node(186, node1_4);
        Node node1_2 = new Node(167, node1_3);
        Node node1_1 = new Node(103, node1_2);
        //链表2
        Node node2_4 = new Node(228);
        Node node2_3 = new Node(147, node2_4);
        Node node2_2 = new Node(134, node2_3);
        Node node2_1 = new Node(67, node2_2);

        //测试合并两个有序单链表
        Node headNode = mergeList(node1_1, node2_1);
        print(headNode);
    }
    /*
      实现单链表的遍历操作
     */
    public static void print(Node headNode){
        //定义一个临时节点，用于辅助单链表的遍历操作
        Node tempNode=headNode;
        //定义一个循环，用于实现单链表的遍历操作
        while(tempNode!=null){
            //输出tempNode中保存的数据值
            System.out.println(tempNode.data);
            //让tempNode指向它的下一个节点
            tempNode=tempNode.next;

        }
    }
    /*
    实现节点类
     */
    private static class Node{
        /*
        用于保存节点中的数据
         */
        private int data;
        /*
         用于保存下一个节点的地址值
         */
        private Node next;
        /*
        为data做初始化的工作
         */
        public Node(int data){
            this.data=data;
        }
        public Node(int data,Node next){
            this.data=data;
            this.next=next;
        }
    }
    public static Node mergeList(Node head1,Node head2){
        //1.head1和head2都为null
        if(head1 == null && head2 == null){
            return null;
        }
        //2.head和head2只有一个为null
        if(head1==null){
            return head2;
        }
        if(head2==null){
            return head1;
        }
        //3.定义headnode和lastnode,分别作为合并后链表的首节点或尾结点
        Node headNode=null,lastNode=null;
        //4.获取head1和head2中数据值较小的节点，并设置为合并后链表的首节点和尾结点。
        if(head1.data>head2.data){
            headNode=head2;
            lastNode=head2;
            //更新head2的值，让head2指向head2的下一个节点
            head2=head2.next;
        }else{
            headNode=head1;
            lastNode=head1;
            head1=head1.next;
        }
        //5.定义一个循环，用于依次的获取链表1和链表2中数据值较小的节点，并把该节点添加到合并后链表的末尾。
        while(head1!=null && head2 !=null){
            //处理head1的数据值大于head2的情况
            if(head1.data>head2.data){
               lastNode.next=head2;
               lastNode=head2;
               //更新head2的值
                head2=head2.next;
            }else{
                lastNode.next=head1;
                lastNode=head1;
                head1=head1.next;

            }
        }
        //6.循环执行完毕，如果某个链表的首节点不为null,那么我们将这个链表的首节点及其之后的节点添加到合并后的链表的末尾
        if(head1==null){
            lastNode.next=head2;
        }else{
            lastNode.next=head1;
        }
        //7.返回合并后链表的首节点
        return headNode;
    }

}

2.如何判断一个单链表有环

实现步骤：

（1）定义一个fast和slow指针，指针的初始值都设为单链表的头结点

（2）让fast指针每次向后走两步，slow指针每次向后走一步。

（3）循环执行步骤2，如果fast指向的节点为null或者fast指向节点的后一个节点为null,则证明单链表无环。如果fast指针和slow指针指向了同一个节点，则证明单链表有环。

public class JudgeHasCycle {
    public static void main(String[] args) {
        //1.创建一个单链表
        Node lastNode=new Node(55);
        Node node4=new Node(44,lastNode);
        Node node3=new Node(33,node4);
        Node node2=new Node(22,node3);
        Node headNode=new Node(11,node2);
        lastNode.setNext(node2);
        //2.判断是否有环
        boolean flag=hasCycle(headNode);
        System.out.println(flag);
    }
    public static boolean hasCycle(Node headNode){
        //1.如果headNode为null的情况
        if(headNode==null){
            return false;
        }
        //2.定义一个快指针，每次往后走两步
        Node fast=headNode;
        //3.定义一个慢指针，每次往后走一步
        Node slow=headNode;
        //4.定义一个循环，用于判断单链表是否有环
        while(fast!=null && fast.next!=null){
            fast=fast.next.next;
            slow=slow.next;
          //5.如果fast和slow指向同一个节点，则证明单链表有环
            if(fast==slow){
                return true;
            }
        }
        //7.否则，单链表无环
          return false;
    }
    private static class Node{
        private int data;
        private Node next;
        public Node(int data){
            this.data=data;
        }
        public Node(int data,Node next){
            this.data=data;
            this.next=next;
        }

        public void setNext(Node next) {
            this.next=next;
        }
    }

}

3.如果存在两个单链表相交的结果，请找出相交节点并返回。

实现步骤：

（1）获得以head1为首节点的单链表长度，记为length1；以head2为首节点的单链表长度，记为length2;

（2）定义longNode指针，用于指向长度较长的单链表的首节点；定义shortNode指针，用于指向长度较短的单链表的首节点。

（3）让longNode指针往后移动Math.abs(length1-length2)次。

（4）定义一个循环，每次让longNode指针和shorNode指针往后移动一次，当longNode指针和shortNode指向同一个节点时，那么就停止循环操作，LongNode指针和shortNode指针指向的节点就是两个单链表相交的第一个节点。 

public class SingleLinkIntersect {
    public static void main(String[] args) {
      //1.创建两个单链表
        Node lastNode=new Node(77);
        Node node6=new Node(66,lastNode);
        Node node3=new Node(33,node6);
        Node node2=new Node(22,node3);
        Node head1=new Node(11,node2);
        Node node5=new Node(55,node6);
        Node head2=new Node(44,node5);
        Node commonNode=getFirstCommonNode(head1,head2);
        System.out.println(commonNode.getData());
    }
    public static Node getFirstCommonNode(Node head1,Node head2){
        //1.处理head1和head2为Null的情况
        if(head1==null || head2==null){
            return null;
        }
        //2.获得以head1为首节点的单链表长度
         int length1=getLength(head1);
        //3.获得以head2位首节点的单链表长度
         int length2=getLength(head2);
         //4.定义LongNode指针，用于指向长度较长的单链表的首节点
         Node longNode=length1>length2 ? head1:head2;
         //5.定义shortNode指针，用于指向长度较短的单链表的首节点
        Node shortNode=length1>length2 ? head2:head1;
        //6.让LongNode指针往后移动Math.abs(length1-length2)次
        for(int i=0;i<Math.abs(length1-length2);i++){
            longNode=longNode.getNext();
        }
        //7.定义一个循环，每次让longNode和shortNode往后移动一次
        while(longNode!=shortNode){
            longNode=longNode.next;
            shortNode=shortNode.next;
        }
        //8.返回两个单链表的相交节点
        return longNode;
    }
    public static int getLength(Node headNode){
        //1.定义一个变量，用于保存单链表的长度
        int length=0;
        //2.定义一个循环，用于实现单链表的遍历操作
        Node tempNode=headNode;
        while(tempNode!=null){
            tempNode=tempNode.getNext();
            //3.更新length的值
            length++;
        }
        //4.返回单链表的长度
        return length;
    }
    public static class Node{
        private int data;
        private Node next;
        public Node(int data){
            this.data=data;
        }
        public Node(int data,Node next){
            this.data=data;
            this.next=next;
        }
        public void setNext(Node next){
            this.next=next;
        }

        public Node getNext() {
            return next;
        }

        public int getData() {
            return data;

        }
    }
}

4.输出单链表的倒数第k个节点

实现步骤：

（1）定义first指针和second指针，并且设置他们的初始值为单链表的首节点。

（2）通过循环，让first指针往后移动k-1次。

（3）通过循环，把fist指针和second指针往后移动一次。当first指针指向的节点是单链表的尾结点时，那么就停止移动。此时，second的指针指向的节点就是单链表倒数第k个节点。

public class Print_DKNode {
    public static void main(String[] args) {
        Node lastNode=new Node(55);
        Node node4=new Node(44,lastNode);
        Node node3=new Node(33,node4);
        Node node2=new Node(22,node3);
        Node head=new Node(11,node2);
        Node node=Print_dkNode(head,5);
        System.out.println(node.getData());
    }
    public static Node Print_dkNode(Node headNode,int k){
        //1.处理headNode为Null的情况
        if(headNode==null){
            throw new NullPointerException("headNode为null");
        }
        //此处k的合法取值范围：[1,单链表长度]

        //2.定义first指针和second指针，并且设置他们的初始值为单链表的首节点
        Node first=headNode;
        Node second=headNode;
        //3.通过循环，让first指针往后移动k-1次。
        for(int i=0;i<k-1;i++){
            first=first.getNext();
        }
        //4.通过循环，每次让first和second往后移动一次，当first指针指向单链表的尾结点时，那么就停止移动，此时，second指针指向的节点就是单链表的倒数第k个节点。
        while(first.getNext()!=null){
            first=first.getNext();
            second=second.getNext();
        }
        //5.返回倒数第k个节点
        return second;
    }
    public static class Node{
        private int data;
        private Node next;
        public Node(int data){
            this.data=data;
        }
        public Node(int data,Node next){
            this.data=data;
            this.next=next;
        }
        public void setNext(Node next){
            this.next=next;
        }
        public Node getNext(){
            return next;
        }
        public void setData(int data){
            this.data=data;
        }
        public int getData(){
            return data;
        }
    }
}

5.单链表的反转

实现步骤：

（1）定义一个节点，用于保存反转后链表的首节点。

（2）把原链表的首节点插入到反转后链表的最前面。

（3）更新原链表和反转后链表的首节点。

（4）循环中执行步骤（2）和步骤（3），直到原链表中的首节点为null时停止。

public class ReverseSingleLinkList {
    public static void main(String[] args){
        //1.创建一个单链表
        Node lastNode=new Node(44);
        Node node3=new Node(33,lastNode);
        Node node2=new Node(22,node3);
        Node headNode=new Node(11,node2);
        System.out.println("反转之前的链表");
        print(headNode);
        System.out.println();
        Node reverse=reverseLinkList(headNode);
        System.out.println("反转之后的链表");
        print(reverse);
    }
    /*
      实现单链表的反转
     */
    public static Node reverseLinkList(Node headNode){
       //1.判断headNode为Null和单链表只有一个节点的情况
        if(headNode==null || headNode.getNext()==null){
            return headNode;
        }
        //2.定义一个节点,用于保存反转后链表的首节点
        Node reverse=null;
        //3.定义一个循环，用于实现单链表的反转操作
        while(headNode!=null){
        //4.获得HeadNode的下一个节点
        Node nextNode=headNode.getNext();
        //5.把headNode插入到反转后链表的最前面
         headNode.setNext(reverse);
        //6.更新反转后链表的首节点
        reverse=headNode;
        //7.跟新需要反转链表的首节点
        headNode=nextNode;
        }
        //8.返回反转后链表的首节点
        return reverse;

    }

    /*实现单链表的遍历操作
     */
    public static void print(Node headNode){
     //1.定义一个临时节点，用于辅助单链表的便利操作
        Node tempNode=headNode;
     //2.定义一个循环，用于实现单链表的遍历操作
        while(tempNode!=null){
     //3.输出tempNode中保存的数据值
      System.out.println(tempNode.getData());
     //4.让它的tempNode指向他的下一个节点
         tempNode=tempNode.getNext();
        }

    }
public static class Node(){
  
  private int data;

  private Node next;

  public  Node(int data){

  this.data=data;

}

 public Node(int data,Node next){

  this.data=data;

 this.next=next;

}

public void setNext(Node next){

  this.next=next;

}

public  Node getNext(){

  return next;

}

public void setData(int data){

   this.data=data;
  
}

public int getData(){

   return data;
}
}
}

6.从未到头打印单链表

实现步骤：

（1）创建一个栈

（2）从头到尾遍历链表，然后将遍历出来的节点依次存入栈中

（3）遍历并打印输出栈中的所有节点

import java.util.Stack;

public class print_SingleLinkList {
    public static void main(String[] args) {
        //1.创建一个单链表
        Node lastNode=new Node(44);
        Node node1=new Node(33,lastNode);
        Node node2=new Node(22,node1);
        Node headNode=new Node(11,node2);
        reversePrint(headNode);
    }
   public static void reversePrint(Node headNode){
        //1.处理headNode为null的情况
        if(headNode==null){
            throw new NullPointerException("headNode为null");
        }
        //2.创建一个栈
       Stack<Node> stack=new Stack<>();
        //3.遍历单链表中的所有节点
       Node tempNode=headNode;
       while(tempNode!=null){
        //4.把遍历出来的节点添加进入栈中
           stack.push(tempNode);
           tempNode=tempNode.getNext();
       }
       //5.遍历栈中的所有节点
       while(!stack.isEmpty()){
           Node node=stack.pop();
           System.out.println(node.getData());
       }
   }
}

7.判断一个链表是否是回文结构

实现步骤：

（1）使用一个辅助栈，第一次遍历链表的时候，把所有元素存入栈中。

（2）第二次遍历链表，依次取出栈中元素，然后比较元素的值是否相等。

import java.util.Stack;

public class Justy_isPalindrome {
    public static void main(String[] args){
        //1.创建一个单链表
        Node lastNode=new Node(1);
        Node node3=new Node(2,lastNode);
        Node node2=new Node(2,node3);
        Node headNode=new Node(1,node2);
        boolean flag=isPalindRome(headNode);
        System.out.println(flag);
    }

    public static boolean isPalindRome(Node headNode){
        //1.判断单链表为null的情况
        if(headNode==null){
            throw new NullPointerException("headNode为null");
        }
        //2.第一次遍历单链表，把节点保存入栈中
        Stack<Node> stack=new Stack<>();
        Node tempNode=headNode;
        while(tempNode!=null){
            stack.push(tempNode);
            tempNode=tempNode.getNext();
        }
        //3.第二次遍历单链表，依次取出栈中元素，然后对比元素是否相等
        while(headNode!=null){
            if(headNode.data!=stack.pop().data){
              return false;
            }
            headNode=headNode.getNext();
        }
        return true;
    }
}

 

LikeSundayLikeRain*
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
反转链表
CJYKeepLearning的博客
03-13 89
public class reverseLinkList { //reverse LinkList 反转整个单链表 public static Node reverse(Node headNode){ if (headNode.getNext()==null) return headNode; Node last = reverse(headNode.getNext()); headNode.getNext().setN
使用单链表逆置字符串
抱愚守拙，持之以恒；不问结果，相信过程.
08-16 556
难度：二星 如何逆置一个单链表存储起来的 字符串？ 实现的方法有很多，这里我描述的是一个通过迭代和指针向后移动，翻转当前指针指向的方式来 实现的。看完这句话，我相信你也一定么有看懂，我一直觉得学数据结构和算法这门课，想通过文字来明白其中的原理是非常困难的。因为毕竟数据结构还是有很强的空间感的，尤其是指针指来指去的很可能就绕进去了，所以画图递进步骤是我觉得的一个好办法。这里其实我是先写出了代码并...
剑指offer24 反转链表 Java
weixin_43065507的博客
08-15 84
public class ReverseLinkList24 { static class Node { int val; Node next; public Node(int val){ this.val = val; } @Override public Strin...
链表逆序 递归 java_将链表逆序（递归方式）
weixin_29623691的博客
02-27 200
namespace ShopEx.CRS.Test{/// ///将链表逆序/// public class ReverseLinkList{//入口public static void Do(){//创建单链表int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };Node head = new Node() { Num = array[0] };Node tmp...
逆序单链表
qq_40739049的博客
06-12 1739
public class LinkReverseOrder { public static class Node{ public int value; public Node next; public Node(int data) { this.value = data; } pub...
单链表基础练习题
qq_51569907的博客
05-18 307
Java、数据结构、算法、链表、题库
单链表基本练习
qq_43129608的博客
03-11 513
//统计单链表有效节点的个数(头节点不是有效的节点，不能存储元素) public static int getLength(HeroNode head){ if(head.next==null){//空链表 return 0; } //定义一个辅助变量temp进行遍历 HeroNode temp=head.next; int length=0...
计算机真题演练，考试
09-02
超级好用的资源啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦
中级网络工程师真题下载
11-29
中级网络工程师真题下载
蓝桥杯历年真题.zip
最新发布
04-30
蓝桥杯历年真题.zip蓝桥杯历年真题.zip蓝桥杯历年真题.zip蓝桥杯历年真题.zip蓝桥杯历年真题.zip蓝桥杯历年真题.zip蓝桥杯历年真题.zip蓝桥杯历年真题.zip蓝桥杯历年真题.zip蓝桥杯历年真题.zip蓝桥杯历年真题.zip...
蓝桥杯真题历年真题汇总
03-03
蓝桥杯历年真题
概率论复习资料真题演练
06-18
概率论。期末复习。类型题真题典型例题，稳拿高分
单向链表的反转
qq_44859843的博客
08-17 79
package com.yang.list; /** 单向链表的反转， */ public class reverseLinkLIst { //内部类定义结点 public static class Node{ public Object item; //保存数据 public Node next; //保存下一个结点的位置 public Node(Object item, Node next) { this.item = it
单链表的反转（用循环和递归实现单链表反转）
猛龙过蒋的专栏
08-23 945
单链表的反转，首先要考虑，如果链表是空链表或者是一个链表，则不需要反转。其次要考虑反转时，需要三个指针，分别是前一个指针，当前指针，和下一个指针。最后要把头结点指针的指向赋值null，同时头结点指针重新指向前一个指针。分别用非递归和递归实现单链表反转。 循环实现单链表反转： package cn.edu.nwu.structs.linklist; /** * @author jcm *
逆置链表
yangxiaozhan_的博客
12-11 1056
逆置链表 1.创建新的链表，把要逆置的链表从最结尾把结点一个一个的取出来，尾插到新链表中，或者把要逆置的链表从头把结点一个一个的拿出来，头插到新链表中去。 2.用栈实现链表的逆置，链表的逆置就是要把在前面的链表放在后面，这跟栈先进先出的特点吻合 import java.util.Stack; public class reverseList { static class Node { ...
Java实现二叉树前序、中序、后续、层次遍历（递归与非递归）
biglxl的博客
01-27 159
package datastructure.binarytree; import java.util.HashMap; import java.util.LinkedList; import java.util.Stack; public class IteratorBinaryTree { public static void main(String[] args) { /** * 二叉树遍历 */ Node node1 .
单向链表常见面试题~真题为例
qq_45058113的博客
03-27 1132
求单链表中节点的个数 查找单链表中的倒数第k个节点（新浪面试） 单链表的反转（腾讯面试） 从尾到头打印单链表（百度 要求：反向遍历，Stack栈） 合并两个有序的单链表，合并之后的链表依然有序 ...
【算法导论学习-23】两个单链表（single linked）求交点
BrilliantEagle的专栏
08-27 1341
单链表的交点计算
Java跨平台特性
LikeSundayLikeRain*的博客
06-15 1782
1.Java跨平台特性 Java有一个其他语言都没有特点，那就是跨平台。平台就是指我们计算机的操作系统，例如：Windows、Linux、Mac等操作系统。跨平台的意思就是Java程序，在一次编译后，在这些平台上都可以运行。其他编程语言没有这个特性，例如c语言在Windows上编译的文件，放到Linux系统上运行，可能就有不兼容问题。 首先java的跨平台不是指java语言本身具有跨平台特性，而是不同平台上都有可以让java运行的环境，这个运行环境就是JRE。JRE由JVM和其...
2013计算机考研真题及参考答案完整版--考研必备.pdf
01-26
本资源是一份2013年的计算机考研真题及参考答案，主要涵盖计算机科学与技术学科联考的专业基础综合部分。以下是一些关键知识点的详细解析： 1. **链表合并**： 题目考察了在升序链表和降序链表合并时的时间复杂度...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值