【大厂算法系列】链表实战篇，基于链表编码实现课程信息管理系统

最新推荐文章于 2024-08-19 06:30:00 发布
最新推荐文章于 2024-08-19 06:30:00 发布
阅读量255 收藏 3
点赞数 3
分类专栏： 程序员 文章标签： 算法 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84689394/article/details/138314778
版权 
        }
        //辅助指针往下移动
        cur=cur.next;
    }
    cur.next=node;
    node.pre=cur;
    length++;

}


##### 双向链表实战删除与修改课程


* 双向链表删除节点思路分析


![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qgVWeZZZ-1679329108757)(picture/image-20221027161343270.png)]](https://img-blog.csdnimg.cn/e0148e9d399c4f7bb8edb7167dac84a7.png)


* 双向链表修改课程信息（同单链表类似）

//删除课程 根据课程的id
public void delCourse(int id){
//定义辅助变量
CourseNode2 cur=head.next;
if(curnull){
return;
}
//记录是否找到课程
boolean flag=false;
while (cur!=null){
if(cur.idid){
flag=true;
break;
}
//一直遍历
cur=cur.next;
}
if(flag){
//删除节点
// data1 next->data3
cur.pre.next=cur.next;
//data3 pre->data1
if(cur.next!=null){
cur.next.pre=cur.pre;
}
length–;
}else {
System.out.printf(“要删除的节点%d没有找到”,id);
}
}


* **对单链表与双链表的相关操作进行时间复杂度分析**
* 删除节点时


	+ 单链表删除节点的时候，需要找到前驱节点，也就是通过遍历的方式得到。单链表的增删操作复杂度是O(n).
	+ 双向链表删除节点的时候，因为是双向的，直接通过pre就可以得到前驱节点，不用进行遍历，时间复杂度是O(1)
	+ 如果只知道要删除的双链表节点的序号，那一样要遍历，时间复杂度是O(n)
* 插入节点时


	+ 单链表与双链表的插入都要找到前驱节点，需要遍历找到的话时间复杂度就是O(n),给了前驱节点复杂度就是O(1)
* 查找节点时


	+ 查找时，时间复杂度均为O(n)
* 总体代码
* 单链表：

public class SingleLinkeDemo {
public static void main(String[] args) {
CourseLinke courseLinke = new CourseLinke();
CourseNode node1 = new CourseNode(1, “数据结构与算法”);
CourseNode node2 = new CourseNode(2, “数据结构与算法”);
CourseNode node3 = new CourseNode(3, “数据结构与算法”);
CourseNode node4 = new CourseNode(4, “数据结构与算法”);
CourseNode node5 = new CourseNode(5, “数据结构与算法”);
courseLinke.addCourse(node1);
courseLinke.addCourse(node2);
courseLinke.addCourse(node3);
courseLinke.addCourse(node4);
courseLinke.showCourse();
// System.out.println(" ==== “);
// courseLinke.delCourse(1);
// System.out.println(“删除课程id=1的课程后”);
// courseLinke.showCourse();
// System.out.println(“修改信息后”);
// courseLinke.update(node4);
// courseLinke.showCourse();
courseLinke.addNodeIndex(3,node5);
System.out.println(” ==== “);
System.out.println(“倒数第1门课程的信息是：”+courseLinke.getLastCourse(1));
courseLinke.showCourse();
}
}
//链表类 管理课程
class CourseLinke{
//头节点 初始化
public CourseNode head=new CourseNode(0,”");
//链表有效元素个数
private int length=0;
//添加课程
public void addCourse(CourseNode node){
//辅助的指针
CourseNode cur=head;
//不断的遍历链表 找到最后一个节点
while (true){
//找到了
if(cur.next==null){
break;
}
//辅助指针往下移动
cur=cur.next;
}
cur.next=node;
length++;

}
//指定位置插入 index=2,即在第二个元素之前插入
public void addNodeIndex(int index,CourseNode node){
    //辅助指针
    CourseNode cur=head;
    //判断参数是否合法
    if(index>length || index<0) return;
    for(int i=1;i<index;i++){
        cur=cur.next;
    }
    System.out.println("当前cur"+cur);
    CourseNode temp=cur.next;
    cur.next=node;
    node.next=temp;
}
//修改课程信息
public void update(CourseNode node){
    CourseNode cur=head;
    boolean flag=false;
    while (cur.next!=null){
        if(cur.next.id==node.id){
            flag=true;
            break;
        }
        cur=cur.next;
    }
    if(flag){
        cur.next.id=node.id;
        cur.next.courseName=node.courseName;
    }else {
        System.out.println("没有找到要修改的课程");
    }
}
//删除课程 根据课程的id
public void delCourse(int id){
    //定义辅助变量
    CourseNode cur=head;
    if(cur.next==null){
        return;
    }
    //记录是否找到课程
    boolean flag=false;
    while (cur.next!=null){
        if(cur.next.id==id){
            flag=true;
            break;
        }
        //一直遍历
        cur=cur.next;
    }
    if(flag){
        //删除节点
        cur.next=cur.next.next;
        length--;
    }else {
        System.out.printf("要删除的节点%d没有找到",id);
    }
}
//遍历输出课程
public void showCourse(){
    //定义辅助的指针
    CourseNode cur=head;
    if(cur.next==null){
        System.out.println("链表空 不可以输出");
        return;
    }
    while (true){
        if(cur.next==null){
            System.out.println("课程输出完成");
            return;
        }
        System.out.println(cur.next);
        cur=cur.next;
    }
}
//获取倒数第K个节点 1.获取到链表长度 2.遍历链表直到（链表长度-K+1） return node
public CourseNode getLastCourse(int k){
    CourseNode cur=head;
    if(cur.next==null){
        System.out.println("链表空 不可以返回");
        return null;
    }
    int length=getLength();
    if(k==0 || k>length){
        throw new IllegalArgumentException("参数错误");
    }
    System.out.println("链表长度:"+length);
    for(int i=0;i<length-k+1;i++){
        cur=cur.next;
    }
    return cur;
}
//获取链表长度
public int getLength(){
    return length;
}

}
class CourseNode{
public int id;
public String courseName;
public CourseNode next;
public CourseNode(int id,String courseName){
this.id=id;
this.courseName=courseName;
}

@Override
public String toString() {
    return "CourseNode{" +
            "id=" + id +
            ", courseName='" + courseName + '\'' +
            ", next=" + next +
            '}';
}

}


**双链表**

public class DoubleLinkeDemo {
public static void main(String[] args) {
DoubleLinke doubleLinke = new DoubleLinke();
CourseNode2 node1 = new CourseNode2(1, “数据结构与算法课程1”);
CourseNode2 node2 = new CourseNode2(2, “数据结构与算法课程1”);
CourseNode2 node3 = new CourseNode2(3, “数据结构与算法课程1”);
CourseNode2 node4 = new CourseNode2(3, “数据结构与算法课程5”);
doubleLinke.addCourse(node1);
doubleLinke.addCourse(node2);
doubleLinke.addCourse(node3);
doubleLinke.delCourse(1);
doubleLinke.update(node4);
doubleLinke.showCourse();
}
}

//链表类 管理课程
class DoubleLinke{
//头节点 初始化
public CourseNode2 head=new CourseNode2(0,“”);
//链表有效元素个数
private int length=0;
//添加课程
public void addCourse(CourseNode2 node){
//辅助的指针
CourseNode2 cur=head;
//不断的遍历链表 找到最后一个节点
while (true){
//找到了
if(cur.next==null){
break;
}
//辅助指针往下移动
cur=cur.next;
}
cur.next=node;
node.pre=cur;
length++;

}
//修改课程信息
public void update(CourseNode2 node){
    CourseNode2 cur=head;
    boolean flag=false;
    while (cur.next!=null){
        if(cur.next.id==node.id){
            flag=true;
            break;
        }
        cur=cur.next;
    }
    if(flag){
        cur.next.id=node.id;
        cur.next.courseName=node.courseName;
    }else {
        System.out.println("没有找到要修改的课程");
    }
}
//删除课程 根据课程的id
public void delCourse(int id){
    //定义辅助变量
    CourseNode2 cur=head.next;
    if(cur==null){
        return;
    }
    //记录是否找到课程
    boolean flag=false;
    while (cur!=null){
        if(cur.id==id){
            flag=true;
            break;
        }
        //一直遍历
        cur=cur.next;
    }
    if(flag){
        //删除节点
        // data1 next->data3
        cur.pre.next=cur.next;
        //data3 pre->data1
        if(cur.next!=null){
            cur.next.pre=cur.pre;
        }
        length--;
    }else {
        System.out.printf("要删除的节点%d没有找到",id);
    }
}
//遍历输出课程
public void showCourse(){
    //定义辅助的指针
    CourseNode2 cur=head;
    if(cur.next==null){
        System.out.println("链表空 不可以输出");
        return;
    }
    while (true){
        if(cur.next==null){
            System.out.println("课程输出完成");
            return;
        }
        System.out.println(cur.next);
        cur=cur.next;
    }
}
//获取倒数第K个节点 1.获取到链表长度 2.遍历链表直到（链表长度-K） return node
public CourseNode2 getLastCourse(int k){
    CourseNode2 cur=head;
    if(cur.next==null){
        System.out.println("链表空 不可以返回");
        return null;
    }
    int length=getLength();
    for(int i=0;i<length-k;i++){
        cur=cur.next;
    }
    return cur;
}
//获取链表长度
public int getLength(){
    return length;
}

}

class CourseNode2{
public int id;
public String courseName;
public CourseNode2 next;
//前驱节点
public CourseNode2 pre;
public CourseNode2(int id,String courseName){
this.id=id;
this.courseName=courseName;
}
// 这两个方法都会尝试在它们的邻居上调用toString()，包括你开始时使用的Node。这是一个无限递归。
// 要避免这种情况，请不要在节点的toString()方法中包含相邻节点的字符串表示。
@Override
public String toString() {

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里无偿获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

2401_84689394
关注
专栏目录
本科课程【数据结构与算法】实验2——单链表与双向循环链表的插入、删除操作(C++实现）
1+1=王的博客
03-01 1909
大家好，我是【1+1=王】， 热爱java的计算机（人工智能）渣硕研究生在读。 如果你也对java、人工智能等技术感兴趣，欢迎关注，抱团交流进大厂！！！ Good better best, never let it rest, until good is better, and better best. 近期会把自己本科阶段的一些课程设计、实验报告等分享出来，供大家参考，希望对大家有帮助。 持续更新。。。。。。。 一、 实验目的 掌握线性表的链表表示； 实现单链表的插入操作 实现单链表的删除操作 实现.
【檀越剑指大厂--算法】链表总结
檀越的博客
08-14 1万+
为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点。给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。输入：head = [1,2,2,1]..
python实现扫雷小游戏
12-20
前面我们用python实现了贪吃蛇、坦克大战、飞船大战、五子棋等游戏 今天我们用python来实现一下扫雷游戏 本游戏代码量和源文件较多 可以从我的GitHub地址中获取 构建地雷区 import random from enum import Enum BLOCK_WIDTH = 30 BLOCK_HEIGHT = 16 SIZE = 20 # 块大小 MINE_COUNT = 99 # 地雷数 class BlockStatus(Enum): normal = 1 # 未点击 opened = 2 # 已点击 mine = 3 # 地雷 flag = 4 # 标记为地雷
c++ STL迭代器实例_c++ 迭代器 样例代码
2401_84617969的博客
04-26 479
【代码】c++ STL迭代器实例_c++ 迭代器 样例代码。
详解Python中的相对导入和绝对导入
u013571243的专栏
08-31 1万+
点击打开链接 好长时间没用python了，有些东西有些生疏，今天涉及到相对导入问题（顶层相对模块执行问题，找了一篇文章总结的挺好的） 前言 Python 相对导入与绝对导入，这两个概念是相对于包内导入而言的。包内导入即是包内的模块导入包内部的模块。 Python import 的搜索路径 在当前目录下搜索该模块在环境变量 PYTHONPATH 中指定的路径列表中依
python安装方法_Python入门基础教程（非常详细）
weixin_39813200的博客
11-16 1735
Python 是一门开源免费、通用型的脚本编程语言，它上手简单，功能强大，坚持「极简主义」。Python 类库(模块)极其丰富，这使得 Python 几乎无所不能，不管是传统的 Web 开发、PC 软件开发、Linux 运维，还是当下火热的机器学习、大数据分析、网络爬虫，Python 都能胜任。这套 Python 基础教程不是教科书，不会玩弄概念，而是力求口语化和通俗化，让读者尽快入门。如果有小朋...
Python入门基础教程（非常详细）
m0_59235508的博客
03-12 2122
Python 是一门开源免费、通用型的脚本编程语言，它上手简单，功能强大，坚持「极简主义」。Python 类库（模块）极其丰富，这使得 Python 几乎无所不能，不管是传统的 Web 开发、PC 软件开发、Linux 运维，还是当下火热的机器学习、大数据分析、网络爬虫，Python 都能胜任。这套 Python 基础教程不是教科书，不会玩弄概念，而是力求口语化和通俗化，让读者尽快入门。如果有小朋友出于兴趣学习 Python，请引导他阅读本教程的前半部分，这是基础，可以降低学习成本；
【大厂算法系列】链表实战篇，基于链表编码实现课程信息管理系统(1)
2401_84689725的博客
05-03 427
【代码】【大厂算法系列】链表实战篇，基于链表编码实现课程信息管理系统(1)
进击极限算法训练营 60G最新大厂算法实战 互联网大厂大牛讲师带你提炼 内功心法
08-29
根据给定文件的信息，我们可以总结出以下相关的IT知识点： ### 进击极限算法训练营概述 #### 开学典礼视频 1. **笙南：《为什么我会参加两次算法训练营？》** - 讲师介绍自己多次参与算法训练营的经历，并分享...
大厂面试算法系列-如何从无序链表中移除重复项(二)-递归法
初学者
04-22 3041
导语   这种方法主要的思路是对节点cur来说首先递归的删除以cur.next为首的子链表中的重复节点。这个就是递归的主要思想。   对于节点cur，首先递归地删除以cur.next为首的子链表中重复的结点，接着从以cur.next为首的子链表中找出与cur有着相同数据域的节点并删除，代码实现如下。 private static LNode removeDupRecursion(LNode head){ // 如果没有后续节点了那么就退出递归 if(head.next==null){ retur.
❄️全网最详细的Python入门基础教程，Python最全教程（非常详细，整理而来）
热门推荐
努力前行，总会成为自己心中的那道光
05-25 18万+
最近想要学习Python，所以就在网上整理了好多整理而来 超级详细的Python入门教程
python import导入的路径问题
tzl2093的博客
04-30 5万+
转载：http://www.jb51.net/article/102252.htm前言Python 相对导入与绝对导入，这两个概念是相对于包内导入而言的。包内导入即是包内的模块导入包内部的模块。Python import 的搜索路径在当前目录下搜索该模块在环境变量 PYTHONPATH 中指定的路径列表中依次搜索在 Python 安装路径的 lib 库中搜索Python import 的步骤pyt...
年度最受欢迎的Python的书籍，还不来看看！
weixin_44099558的博客
01-04 6444
Python是一种通用的解释型编程，主要用于Web开发、机器学习和复杂数据分析。Python对初学者来说是一种完美的语言，因为它易于学习和理解，随着这种语言的普及，Python程序员的机会也越来越大。 如果你想学习Python编程，市场上就有很多的书籍。近日，hackr社区推荐了10本最佳的Python书籍。是2018年最受编程社区成员推荐的Python书，该列表还包括一些为初学者准备的免费Py...
python入门教程(非常详细)-python入门(非常详细的教程)
q6q6q的专栏
10-28 1万+
对于初学者而言，您要做的只是专注于Python语言，阐明学习重点，掌握学习节奏，并逐步学习。根据我多年的学习和工作经验，编程语言的学习分为以下三个步骤，无论您是否具有编程基础，都可以通过比较来完成。1）多练习多积累代码任何编程语言都具有广泛的知识，从基本变量赋值，条件循环到文件操作，并发编程等。但是，不要等到学习了所有知识点后再开始练习，因为到那时会发现您已经忘记了难以记住的知识。学习编程非常实用...
python入门教程（非常详细！3w+ 文字）
最新发布
小程xy的博客
08-19 1789
可以通过key参数自定义排序规则。key参数接收一个函数，这个函数对每个列表元素进行处理，并返回一个用于比较的值。可以结合lambda函数使用。# 按照最后一个字母排序print(sorted_words) # 输出: ['banana', 'grape', 'apple', 'cherry']Python 使用def"""docstring (optional): 函数的文档字符串，用于描述函数功能"""# 函数体return value # 可选的返回值。
数据结构教程 | 链表及代码实现
Tinky2013的博客
02-14 296
Code Implementation of Link list 1 Construction of link list 1.1 Construct a link list typedef struct Link{ char elem; // Represents the data field struct Link * next; // Represents the p...
链表知识体系——实战篇（结合代码讲解、超详细）
weixin_45713603的博客
05-13 535
链表基础知识体系链表的建立无头结点链表有头结点的链表建立FIFO型链表建立FIFO型链表其他零碎知识点结点代表对象时的输入建立问题链表的操作判断型查找型删除型移动型插入型逆置型其他零碎知识点链表的输出顺序输出逆序输出输出特定条件的结点其他零碎知识点 链表的建立 无头结点链表 有头结点的链表 建立FIFO型链表 建立FIFO型链表 其他零碎知识点 结点代表对象时的输入建立问题 链表的操作 判断型 查找型 删除型 移动型 插入型 逆置型 其他零碎知识点 链表的输出 顺序输出 逆序输出 输出特定条件的结点 其他零
一线互联网大厂算法面试问题Java实现
12-21
"一线互联网大厂算法面试问题Java实现"这个压缩包文件集合了多个知名公司的算法面试题目的Java实现，包括谷歌、亚马逊、领英、雅虎、微软、Facebook以及Airbnb等。这些题目覆盖了数据结构、排序、搜索、图论等多个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值