0
点赞
收藏
分享

微信扫一扫

新星计划Day6【数据结构与算法】 链表Part2

墨春 2022-05-02 阅读 36
链表数据结构java

新星计划Day6【数据结构与算法】 链表Part2

在这里插入图片描述

🛒导航小助手🎪

文章目录

🏳‍🌈021 单链表新浪面试题

查找单链表中的倒数第k个节点（新浪面试题）

思路

1.编写一个方法，接收head节点，同时接收一个index

2.index表示是倒数第index个节点

3.先把链表从头到尾遍历一下，得到这个链表的总的长度getLength

4.得到size后，我们从链表的第一个开始遍历（size-index）个，就可以得到了

5.如果找到了，则返回该节点，否则返回null

public static HeroNode findLastIndexNode(HeroNode head,int index){
    //判断如果链表为空，返回null
    if(head.next==null){
        return null;//没有找到
    }
    //第一次遍历得到链表的长度（节点个数）
    int size=getLength(head);
    //第二次遍历size-index位置，就是我们倒数的第K个节点
    //先做一个index的校验
    if(index<=0||index>size){
        return null;
    }
    //定义一个辅助变量,for循环定位到倒数的index
    HeroNode cur=head.next;
    for(int i=0;i<size-index;i++){
        cur=cur.next;
    }
    return cur;
}

💺022 单链表腾讯面试题

将单链表进行反转

思路：1.先定义一个节点reverseHead=new HeroNode();

2.从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表的最前端

3.原来的链表的head.next=reverseHead.next

public static void reverseList(HeroNode head){
    //如果当前链表为空，或者只有一个节点，无需反转，直接返回
    if(head.next==null||head.next.next==null){
        return;
    }
    //定义一个辅助的指针（变量），帮助我们遍历原来的链表
    HeroNode cur=head.next;
    HeroNode next=null;//指向当前节点【cur】的下一个节点
    HeroNode reverseHead=new HeroNode(0,"","");
    //从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表的最前端
    //动脑筋
    while(cur!=null){
        next=cur.next;//先暂时保存当前节点的下一个节点，因为后面需要使用
        cur.next=reverseHead.next;//将cur的下一个节点指向新的链表的头节点
        reverseHead.next=cur;//将cur连接到新的链表
        cur=next;//让cur后移
    }
    //将head.next指向reverseHead.next，实现单链表的反转
    head.next=reverseHead.next;
}

🚌023 单链表百度面试题

从尾到头打印单链表

思路：

1.上面的题的要求就是逆序打印单链表

2.方式一：先将单链表进行一个反转操作，然后再遍历即可，这样做的问题是会破坏原来的单链表的结构，不建议这样做

3.方式二：可以利用栈这个数据结构，将各个节点压入到栈中，利用栈的先进后出的特点就实现了这个逆序打印的效果

举例演示栈的使用

import java.util.Stack;
public class TestStack{
    public static void main(String[] args){
        Stack<String> stack=new Stack();
        //入栈
        stack.add("jack");
        stack.add("tom");
        stack.add("smith");
        //出栈
        //smith,tom,jack
        while(stack.size()>0){
            System.out.println(stack.pop());//pop就是将栈顶的数据取出
        }
    }
}

方式二：可以利用栈这个数据结构，将各个节点压入到栈中，利用栈的先进后出的特点就实现了这个逆序打印的效果

public static void reversePrint(HeroNode head){
    if(head.next==null){
        return;//空链表，不能打印
    }
    //创建要给一个栈，将各个节点压入栈
    Stack<HeroNode> stack=new Stack<HeroNode>();
    HeroNode cur=head.next;
    //将链表的所有节点压入栈中
    while(cur!=null){
        stack.push(cur);
        cur=cur.next;//cur后移，这样就可以压入下一个节点
    }
    //将栈中的节点进行打印，pop出栈
    while(stack.size()>0){
        System.out.println(stack.pop());//stack的特点是先进后出
    }
}

🌍024 双向链表增删改查分析图解

单链表的缺点

1.单向链表的查询节点只能是一个方向

2.单向链表不能实现自我删除，只能通过找到前一个节点来删除

双向链表分析

image-20211130120123494

pre：指向前一个节点

分析双向链表的遍历，添加，修改，删除的操作思路—代码实现

1）遍历的方式和单链表一样，只是可以向前查找，也可以向后查找

2）添加（默认添加到双向链表的最后）

（1）先找到双向链表的最后这个节点

​ （2）temp.next=newHeroNode

​ (3)newHeroNode.pre=temp;

(4)修改思路和原来的单向链表一样

（5）删除

​ （1）因为是双向链表，因此，我们可以实现自我删除某个节点

​ （2）直接找到要删除的这个节点，比如temp

​ （3）temp.pre.next=temp.next

​ (4)temp.next.pre=temp.pre;

🦽025 双向链表增删改查代码实现

//创建一个双向链表的类
class DoubleLinkedList{
    //先初始化一个头节点，头节点不要动,不存放具体的数据
    private HreoNode2 head=new HeroNode2(0,"","");
    //返回头节点
    public HeroNode2 getHead(){
        return head;
    }
    //遍历双向链表的方法
    //显示链表【遍历】
    public void list(){
        //判断链表是否为空
        if(head.next==null){
            System.out.println("链表为空");
            return;
        }
        //因为头节点，不能动，因此我们需要一个辅助变量来遍历
        HeroNode temp=head.next;
        while(true){
            //判断是否到链表最后
            if(temp==null){
                break;
            }
            //输出节点的信息
            System.out.println(temp);
            //将temp后移，一定小心
            temp=temp.next;
        }
    }
    //添加一个节点到双向链表的最后
    public void add(HeroNode2 heroNode){
        //因为head节点不能动，因此我们需要一个辅助遍历temp
        HeroNode2 temp=head;
        //遍历链表，找到最后
        while(true){
            if(temp.next==null){
                break;
            }
            //如果没有找到最后，将temp后移
            temp=temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        //形成一个双向链表
        temp.next=heroNode;
        heroNode.pre=temp;
    }
    //修改一个节点的内容，可以看到双向链表的节点内容修改和单向链表一样
    //只是节点的类型改成了HeroNode2
    public void update(HeroNode2 newHeroNode){
        //判断是否为空
        if(head.next==null){
            System.out.println("链表为空");
            return;
        }
        //找到需要修改的节点，根据no编写
        //定义一个辅助变量
        HeroNode2 temp=head.next();
        boolean flag=false;//表示是否找到节点
        while(true){
            if(temp==null){//已经遍历完链表
                break;
            }
            if(temp.no==newHeroNode.no){
                //找到
                flag=true;
                break;
            }
            temp=temp.next;
        }
        //根据flag判断是否找到要修改的节点
        if(flag){
            temp.name=newHreoNode.name;
             temp.nickname=newHreoNode.nickname;
        }else{//没有找到
             System.out.printt("没有找到编号%d的节点，不能修改\n",newHeroNode.no);
        }
    }
    //从双向链表中删除一个节点
    //1.对于双向链表，我们可以直接找到要删除的这个节点
    //2.找到后，自我删除即可
    public void del(int no){
        //判断当前链表是否为空
        if(head.next==null){//空链表
            System.out.println("链表为空，无法删除");
            return;
        }
        HeroNode2 temp=head.next;//辅助变量（指针）
        boolean flag=false;//标志是否找到待删除节点的
        while(true){
            if(temp==null){//已经到链表的最后
                break;
            }
            if(temp.no==no){
                //找到了待删除节点的前一个节点temp
                flag=true;
                break;
            }
            temp=temp.next;//temp后移，遍历
        }
        //判断flag
        if(flag){//找到
            //可以删除
            temp.pre.next=temp.next;
            //这里我们的代码有问题  
            //如果是最后一个节点，就不需要执行下面这句话，否则会出现空指针异常
            if(temp.next!=null){
                temp.next.pre=temp.pre;
            }
            
        }else{
            System.out.printf("要删除的%d节点不存在\n",no);
        }
    }
}
//定义HeroNode2,每个HeroNode对象就是一个节点
class HeroNode2{
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;//执行下一个节点，默认为null
    public HeroNode pre;//指向前一个节点，默认为null
    //构造器
    public HeroNode(int hNo,String name,String nickname){
        this.no=no;
        this.name=name;
        this.nickname=nickname;
    }
    //为了显示方便，我们重写一下toString
    @Override
    public String toString(){
        return "HeroNode [no="+no+",name="+name+",nickname="+nickname+"]";
    }
    
}

🚡026 双向链表功能测试和小结

public class DoubleLinkedListDemo{
    public static void main(String[] args){
        //测试
        System.out.println("双向链表的测试");
        //先创建节点
        HeroNode2 her1 = new HeroNode2(1, "宋江", "及时雨");
        HeroNode2 her2 = new HeroNode2(2, "卢俊义", "玉麒麟");
        HeroNode2 her3 = new HeroNode2(3, "吴用", "智多星");
        HeroNode2 her4 = new HeroNode2(4, "林冲", "豹子头");
        //创建一个双向链表
        DoubleLinkedList doubleLinkedList=new DoubleLinkedList;
        doubleLinkedList.add(hero1);
        doubleLinkedList.add(hero2);
        doubleLinkedList.add(hero3);
        doubleLinkedList.add(hero4);
        
        doubleLinkedList.list();
        //修改
        HeroNode2 newHeroNode = new HeroNode2(4, "公孙胜", "入云龙");
        doubleLinkedList.update(newHeroNode);
        System.out.println("修改后的链表情况");
        doubleLinkedList.list();
        //删除
        doubleLinkedList.del(3);
        System.out.println("删除后的链表情况");
        doubleLinkedList.list();
    }
}

🚞027 环形链表介绍和约瑟夫问题

Josephu(约瑟夫、约瑟夫环) 问题 Josephu 问题为：设编号为 1，2，… n 的 n 个人围坐一圈，约定编号为 k（1<=k<=n）的人从 1 开始报数，数 到 m 的那个人出列，它的下一位又从 1 开始报数，数到 m 的那个人又出列，依次类推，直到所有人出列为止，由 此产生一个出队编号的序列。

提示：用一个不带头结点的循环链表来处理 Josephu 问题：先构成一个有 n 个结点的单循环链表，然后由 k 结 点起从 1 开始计数，计到 m 时，对应结点从链表中删除，然后再从被删除结点的下一个结点又从 1 开始计数，直 到最后一个结点从链表中删除算法结束

🚂028 约瑟夫问题分析图解和实现（1）

构建一个单向的环形链表思路

1.先创建第一个节点，让first指向该节点，并形成环形

2.后面当我们每创建一个新的节点，就把该节点，加入到已有的环形链表中即可

遍历环形链表

1.先让一个辅助指针（变量）指向first节点

2.然后通过一个while循环遍历该环形链表即可 cueBoy.next==first结束

public class Josepfu{
    public static void main(String[] args){
        //测试一把看看构建环形链表，和遍历是否ok
        CircleSingleLinkedList circleSingleLinkedList=new CircleSingleLinkedList;
        circleSingleLinkedList.addBoy(5);//加入五个小孩节点
        circleSingleLinkedList.showBoy();
    }
}
//创建一个环形的单向链表
class CircleSingleLinkedList{
    //创建一个first节点，当前没有编号
    private Boy first=new Boy(-1);
    //添加小孩的节点，构建成一个环形链表
    public void addBoy(int nums){
        //nums做一个数据校验
        if(nums<1){
            System.out.println("nums的值不正确");
            return;
        }
        Boy curBoy=null;//辅助指针，帮助构建环形链表
        //使用for循环来创建我们的环形链表
        for(int i=1;i<=nums;i++){
            //根据编号创建小孩节点
            Boy boy=new Boy(i);
            //如果是第一个小孩
            if(i==1){
                first=boy;
                first.setNext(first);//构成环
                curBoy=first;//让curBoy指向第一个小孩
            }else{
                curBoy.setNext(boy);//
                boy.setNext(first);//
                curBoy=boy;
            }
        }
    }
    //遍历当前环形链表
    public void showBoy(){
        //判断链表是否为空
        if(first==null){
            System.out.println("没有任何小孩");
            return;
        }
        //因为first不能动，因此我们仍然使用一个辅助指针完成遍历
        Boy curBoy=first;
        while(true){
            System.out.printf("小孩的编号%d \n",curBoy.getNo());
            if(curBoy.getNext()==first){//说明已经遍历完毕
                break;
            }
            curBoy=curBoy.getNext();//curBoy后移
        }
    }
}
//创建一个Boy类，表示一个节点
class Boy{
    private int no;//编号
    private Boy next;//指向下一个节点，默认null
    public Boy(int no){
        this.no=no;
    }
    public int getNo(){
        return no;
    }
    public void setNo(int  no){
        this.no=no;
    }
    public Boy getNext(){
        return next;
    }
    public void setNext(Boy next){
        this.next=next;
    }
}

💌029 约瑟夫问题分析图解和实现（2）

根据用户的输入，生成一个小孩出圈的顺序

n=5，即有5个人

k=1，从第一个人开始报数

m=2，数2下

1.需要创建一个辅助指针（变量）helper，事先应该指向环形链表的最后这个节点

补充：

小孩报数前，先让first和helper移动k-1次

2.当小孩报数时，让first和helper这个指针同时的移动m-1次

3.这时都可以将first指向的小孩节点出圈

first=first.next

helper.next=first;

原来first指向的节点就没有任何引用了，就会被回收

//startNo  表示从第几个小孩开始数数
//countNum  表示数几下
//nums 表示最初有多少小孩在圈中
public void countBoy(int startNo,int countNum,int nums){
    //先对数据进行校验
    if(first==null||starNo<1||startNo>nums){
        System.out.println("参数输入有误，请重新输入");
        return;
    }
    //创建要给辅助指针，帮助完成小孩出圈
    Boy helper=first;
    //需要创建一个辅助指针（变量）helper，事先应该指向环形链表的最后这个节点
    while(true){
        if(helper.getNext()==first){//说明helper指向最后小孩节点
            break;
        }
        helper=helper.getNext();
    }
    //小孩报数前，先让first和helper移动k-1次
    for(int j=0;j<startNo-1;j++){
        first=first.getNext();
        helper=helper.getNext();
    }
    //当小孩报数时，让first和helper这个指针同时的移动m-1次,然后出圈
    //这里是一个循环操作，直到圈中只有一个节点
    while(true){
        if(helper==first){  //说明圈中只有一个节点
            break;
        }
        //让first和helper指针同时移动countnum-1次
        for(int j=0;j<countNum-1;j++){
            first=first.getNext();
        helper=helper.getNext();
        }
        //这时first指向的节点，就是要出圈的小孩节点
        first=first.getNext();
        helper.setNext(first);
        
    }
    System.out.printf("最后留在圈中的小孩编号为%d\n",first.getNo());
}

下期预告：力扣每日一练之数组中篇Day2

觉得文章写的不错的亲亲们，点赞评论走一波，爱你们哦！🥗

举报

相关推荐

新星计划Day8【数据结构与算法】 栈Part2

数据结构算法java运算符入栈系统/运维

新星计划Day7【数据结构与算法】 栈Part1

java数据结构算法数据操作符Linux系统/运维

新星计划Day4【数据结构与算法】 稀疏数组与队列

数据结构算法

力扣数据结构14天学习计划day6

数据结构leetcode学习

数据结构与算法系列之＜3＞----动态数组(Part2)

数据结构算法链表

【leetcode】链表part2

算法

【数据结构与算法】2 - 链表

日记本数据结构与算法

数据结构与算法Day2

数据结构算法散列表

学习笔记 Day 18 (数据结构与算法 -- 链表)

数据结构链表算法python

数据结构与算法---链表

链表数据结构算法javaintellij-idea
0 条评论