【面试HOT200】链表篇

news2024/11/22 19:01:18

系列综述：
💞目的：本系列是个人整理为了秋招面试coding部分的，整理期间苛求每个算法题目，平衡可读性与代码性能（leetcode运行复杂度均打败80%以上）。
🥰来源：材料主要源于【CodeTopHot200】进行的，每个知识点的修正和深入主要参考各平台大佬的文章，其中也可能含有少量的个人实验自证，所有代码均优先参考最佳性能。
🤭结语：如果有帮到你的地方，就点个赞和关注一下呗，谢谢🎈🎄🌷！！！
🌈【C++】秋招&实习面经汇总篇

文章目录

      • 基础知识
        • 链表定义
        • 链表基本操作
      • 常见题目
        • 206. 反转链表
        • 25. K 个一组翻转链表
        • 21. 合并两个有序链表
        • 交换相邻链表节点
        • 141. 环形链表
        • 求环形链表的入口
        • 92. 反转链表 II
        • 160. 相交链表
        • 23. 合并K个排序链表
        • 143. 重排链表
        • 142. 环形链表 II
        • 19. 删除链表的倒数第 N 个结点
        • 移除链表中的重复结点
        • 删除无序链表中值重复出现的节点
    • 参考博客

😊点此到文末惊喜↩︎

基础知识

链表定义
struct ListNode {
	int val;
	ListNode *next;
	ListNode(int v) : val(v), next(nullptr){}
};
// 简化定义：在 C++ 中定义struct，可以省略struct并直接使用结构体名称。
ListNode *vhead = new ListNode(-1);
链表基本操作
  1. 删除指定链表节点
    • 虚拟头节点的定义：为了统一节点的遍历操作，避免无头节点的释放错误
    • 虚拟头节点的释放：C++不支持GC内存自动清理，所以需要手动释放，避免内存泄漏
      在这里插入图片描述
ListNode* removeElements(ListNode* head, int val) {
      // 1. 定义头节点
      ListNode *vHead = new ListNode(0, head);
      // 2. 逻辑处理部分
      ListNode* cur = vHead;				// 定义工作指针cur
      while(cur->next != nullptr){
          if(cur->next->val == val){		// 为了获取操作节点的前一个节点进行删除
              ListNode* tmp = cur->next;	// key：结点删除后要释放
              cur->next = cur->next->next;
              delete tmp;
          }else{
              cur = cur->next;				// 工作指针++
          }
      }
      // 3. 释放头节点
      head = vHead->next;					// key：解决头节点是目标值的情况
      delete(vHead);						// 不要忘记啦
      return head;
}
  1. 反转链表
    • 链表的遍历
      • 遍历使用当前结点：while (cur != nullptr) { }
      • 遍历使用当前结点的前一个结点：while (cur->next != nulllptr) { }
        请添加图片描述
    // 反转链表：链表前一个元素需要重新修改next指针
ListNode* reverseList(ListNode* head) {
    // 初始化：注意prve指向空
    ListNode* pre = nullptr;
    ListNode* cur = head;
    while (cur != nullptr) {	// TODO: cur执行结束节点时停止
        // 先记录后使用：注意记录的是cur->next
        ListNode* tmp = cur->next;
        cur->next = pre;
        // 迭代：pre和cur节点都前进一位
        pre = cur;
        cur = tmp;
    }
    return pre;
}
  2. 链表求中心
    在这里插入图片描述
    在这里插入图片描述
    // 中心结点（偶数返回右结点）
ListNode* middleNode(ListNode* head) {
    ListNode *slow = head;
    ListNode *fast = head;
    while (fast != nullptr && fast->next!= nullptr) {
        slow = slow->next;
        fast = fast->next->next;
    }
    cout << slow->val;
    return slow;
}

// 中心结点（偶数返回左结点）
ListNode* middleNode(ListNode* head) {
    ListNode *slow = head;
    ListNode *fast = head;
    while (fast->next && fast->next->next) {
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;
}

常见题目

206. 反转链表
ListNode* reverseList(ListNode* head) {
    ListNode *vhead = new ListNode(-1, nullptr);
    while (head != nullptr) {
        ListNode *tmp = head;
        head = head->next;
        tmp->next = vhead->next;
        vhead->next = tmp;
    }
    ListNode *p = vhead->next;
    delete vhead;
    return p;
}
25. K 个一组翻转链表

未完待续。。。

21. 合并两个有序链表
ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
   // 健壮性检查
    // 虚拟头节点和尾指针
    ListNode *vhead = new ListNode(-1);
    ListNode *tail = vhead;
    // 算法部分
    while (list1 != nullptr && list2 != nullptr) {
        if (list1->val < list2->val) {
            tail->next = list1;
            list1 = list1->next;
        } else {
            tail->next = list2;
            list2 = list2->next;
        }
        tail = tail->next;  // key: 忘记了
    }
    // 收尾
    tail->next = list1 == nullptr ? list2 : list1;
    // 防止内存泄漏
    ListNode *p = vhead->next;
    vhead->next = nullptr;
    delete vhead;
    return p;
}
交换相邻链表节点
  1. letcode题目网址
    在这里插入图片描述
    ListNode* swapPairs(ListNode* head){
	// 健壮性检查
	if(head == nullptr)
	    return nullptr;
	
	// 指向操作节点组的第一个和第二个
	ListNode* prior_first;
	ListNode* prior_second;-
	// 增加虚拟头节点
	ListNode* vHead = new ListNode(0);
	vHead->next = head;
	ListNode *cur = vHead;
	while(cur->next != nullptr && cur->next->next != nullptr){
	    prior_first = cur->next;
	    prior_second = cur->next->next;
	    prior_first->next = prior_second->next;
	    prior_second->next = prior_first;
	    cur->next = prior_second; 
	    cur = prior_second->next;// cur指向被操作节点组的前一个
	}
	return vHead->next;
}
141. 环形链表
  1. 题目
    • 给你一个链表的头节点 head ，判断链表中是否有环。
  2. 思路
    • 哈希缓存：每遍历一个元素，先查询哈希表中是否存在该元素的指针，若不存在则将该元素加入到哈希表中
    • 双倍指针：快指针一次走两步，慢指针一次走一步，只要有环，最终一定会相遇
    // 不进行第一次操作的初始化
bool hasCycle(ListNode *head) {
	 ListNode* fast = head, *slow = head;
	 while (true) {
		// 迭代：先探测后迭代
	    if (fast == nullptr || fast->next == nullptr) 
	     return false;
	    fast = fast->next->next;
	    slow = slow->next;
        // TODO
	    // 判断结束条件
	    if (fast == slow) break;
	 }
	 return true;
}

// 进行第一次运行的初始化
bool hasCycle(ListNode *head) {
	// 初始化第一次运行结果
   if (head == nullptr || head->next == nullptr)
       return false;
   ListNode *slow = head;
   ListNode *fast = head->next->next;
   // 算法部分
   while (fast != slow) {
       if (fast != nullptr && fast->next != nullptr) {
           fast = fast->next->next;
       }else {
           return false;
       }
       slow = slow->next;
   }
   return true;
}
求环形链表的入口
  1. letcode题目链接
    • 一个节点的next是否能访问，需要判断该节点是否存在
    • 只写容易判断的逻辑，其他的交给else
ListNode *detectCycle(ListNode *head) {
    ListNode* slow=head;
    ListNode* fast=head;
    // 1. 快指针走两步，慢指针走一步
    while(fast!=NULL&&fast->next!=NULL){
        slow=slow->next;
        fast=fast->next->next;
        // 如果相等，让慢指针从头开始走，快慢指针一起移动，相等则为链表环形入口
        if(slow==fast){
            slow=head;
            while(slow!=fast){
                slow=slow->next;
                fast=fast->next;
            }
            return fast;
        }
    }
    return NULL;
 }
92. 反转链表 II
  1. 题目
    • 给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回反转后的链表 。
ListNode* reverseBetween(ListNode* head, int l, int r) {
   // 逆序两个指针间的部分
    auto reverse_list = [](ListNode *head, ListNode *tail){
        ListNode *p = nullptr;
        while (head != tail) {
            p = head;
            head = head->next;
            p->next = tail->next;
            tail->next = p;
        }
    };

    ListNode *vhead = new ListNode(-1, head);
    // 获取需要进行处理的区间的头尾指针
    ListNode *left = vhead;
    for (int i = 0; i < l; ++i) {
        left = left->next;    
    }
    ListNode *right = vhead;
    for (int i = 0; i < r; ++i) {
        right = right->next;    
    }
    // 获取逆序区间的前指针prev和后指针behind
    ListNode *prev = vhead;
    while (prev->next != left) prev = prev->next;
    ListNode *behind = right->next;
    // 逆序执行
    reverse_list(left, right);
    // 插入回去
    prev->next = right;
    left->next = behind;
    // 防止内存泄漏
    ListNode *tmp = vhead->next;
    vhead->next = nullptr;
    delete vhead;
    return tmp;
}
160. 相交链表
  1. letcode题目链接
    • 给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。
      - 题目数据 保证 整个链式结构中不存在环。
  2. 思路
    • 哈希缓存：先将一个链表结点全部缓存到哈希表中，然后另一个链表遍历每个结点判断是否在哈希表中
    • 栈：两个链表从公共结点开始后面都是一样的，若是我们顺着链表从后向前查找，很容易就能查找到链表的公共结点（第一个不相同的结点的下一个结点即所求）
    • 同步移动：计算两个链表的长度差值，然后进行同步移动
    • 交替移动
      • 若两链表没有公共结点，那么两个链表指针都会走过 s1+s2个结点，同时到达两链表末尾
      • 若有公共结点，由于最后会同时走到两链表终点，所以倒退回去，两个指针一定会在第一个公共结点处相遇
      • 当然，若两链表等长，那确实不会跳到另一链表，不过链表等长本身指针就是同步的，同样也能找到公共结点
// 哈希缓存
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
    unordered_set<ListNode*> uset;
    // 放入缓存中
    while (headA != nullptr) {
        uset.insert(headA);
        headA = headA->next;
    }
    // 查找缓存
    while (headB != nullptr) {
        if (uset.count(headB)) return headB;
        headB = headB->next;
    }
    return nullptr;
}
// 交替移动？
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
 	ListNode *pa = headA;
    ListNode *pb = headB;
    while (pa != pb) {
        (pa == nullptr) ? pa = headB : pa = pa->next;
        (pb == nullptr) ? pb = headA : pb = pb->next;
    }
    return pa;
}
23. 合并K个排序链表
  1. 归并法
//通过mid将数组一分为二，并不断缩小规模，当规模为1时返回并开始合并
//通过合并两个链表，不断增大其规模，整体看就是不断缩小-最后不断扩大的过程
ListNode helper(ListNode[] lists, int begin, int end) {
	if(begin==end) {
		return lists[begin];
	}
	int mid = begin+(end-begin)/2;
	ListNode left = helper(lists,begin,mid);
	ListNode right = helper(lists,mid+1,end);
	return merge(left,right);
}

//合并两个有序链表
ListNode merge(ListNode a, ListNode b) {
	if(a==null || b==null) {
		return (a==null) ? b : a;
	}
	if(a.val<=b.val) {
		a.next = merge(a.next,b);
		return a;
	} else {
		b.next = merge(a,b.next);
		return b;
	}
}
  1. 逐个合并
ListNode* mergeKLists(vector<ListNode*>& lists) {
    auto merge = [](ListNode *l1, ListNode *l2)->ListNode *{
        ListNode *vhead = new ListNode(-1, nullptr);
        ListNode *p = vhead;
        while (l1 && l2) {
            if (l1->val > l2->val) {
                p->next = l2;
                p = p->next;
                l2 = l2->next;
            } else {
                p->next = l1;
                p = p->next;
                l1 = l1->next;
            }
        }
        p->next = (l1 ? l1 : l2);
        return vhead->next;
    };
    // 逐个合并
    if (lists.size() == 0) return nullptr;
    ListNode *l1 = lists[0];
    for (int i = 1; i < lists.size(); ++i) {
        if (lists[i] != nullptr){
            l1 = merge(l1, lists[i]);
        } 
    }
    return l1;
}
143. 重排链表
  1. 题目
    在这里插入图片描述
void reorderList(ListNode* head) {
    // 寻找中间结点（前一个）模板
    ListNode *slow = head;
    ListNode *fast = head;
    while (fast->next && fast->next->next) {
        slow = slow->next;
        fast = fast->next->next;
    }
    // 拆分链表并将后半部分压入栈中
    ListNode *second_head = slow->next;
    slow->next = nullptr;
    stack<ListNode*> st;
    while (second_head != nullptr) {
        st.push(second_head);
        second_head = second_head->next;
    }
    // 合并链表
    ListNode *cur = head;
    while (!st.empty()) {
        ListNode *tmp = st.top();
        st.pop();
        tmp->next = cur->next;
        cur->next = tmp;
        cur = cur->next->next;
    }
}
142. 环形链表 II
  1. 题目
    • 给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
ListNode *detectCycle(ListNode *head) {
    // 快慢指针
    ListNode* fast = head;
    ListNode* slow = head;
    while (true) {
        if (fast == nullptr || fast->next == nullptr) return nullptr;
        fast = fast->next->next;
        slow = slow->next;
        if (fast == slow) break;
    }
    // 第一次相遇后，快指针赋值为头部，然后再同步走，直到相等
    fast = head;
    while (slow != fast) {
        slow = slow->next;
        fast = fast->next;
    }
    return fast;
}
19. 删除链表的倒数第 N 个结点
  1. 有可能删除头结点的情况，都需要增加虚拟头节点
ListNode* removeNthFromEnd(ListNode* head, int n) {
    if(n < 0 || head == nullptr)
        return nullptr;
    // 快慢指针拉开n个节点的距离
    ListNode *vHead = new ListNode(0);
    vHead->next = head;
    ListNode *slow = vHead;
    ListNode *fast = vHead;
    // 让slow指向被删除节点的前一个
    while(n--){
        fast = fast->next;
    }
    // 同步移动
    while(fast->next != nullptr){
        fast = fast->next;
        slow = slow->next;
    }
    // 删除节点
    slow->next = slow->next->next;
    return vHead->next;
}
移除链表中的重复结点
LinkList *DeleteSameNode(LinkList *head) {
	LinkList *vhead = new LinkList(0);
	vhead->next = head;
	
	// 删除cur->next中剩下的值为val的结点
	auto delete_node = [](int val, LinkList *cur){
	  while (cur->next != nullptr) {
	    if (cur->next->val == val) {
	      LinkList *tmp = cur->next;
	      cur = cur->next->next;
	      delete tmp;
	    }
	    cur = cur->next;
	  }
	};
	// 遍历链表，删除重复结点
	LinkList *cur = vhead;
	while (cur->next != nullptr) {
	  delete_node(cur->next->val, cur);
	  cur = cur->next;
	}
}
删除无序链表中值重复出现的节点

  1. 采用哈希表set性质进行单一化，然后进行新建。

    • 空间复杂度：O(n)
    • 时间复杂度：O(n)

  2. 使用unordered_set<int> s;记录曾经出现过的情况，通过s.find(val) != s.end()实现对过去历史的快速查找。

    #include <set>
void deleteDuplicates(ListNode* head) {
    if (head == nullptr) return ;
    std::unordered_set<int> s; // 用于存储出现过的节点值
    // key：处理头节点，从而不需要建立vhead，但是头节点必须不会被删除
    s.insert(head->val); // 先将头节点的值插入 set
    ListNode* cur = head;
    while (cur->next != nullptr) {
        if (s.find(cur->next->val) != s.end()) { // 如果下一个节点的值在 set 中出现过，删除下一个节点
            ListNode* tmp = cur->next;
            cur->next = cur->next->next;
            delete tmp;
        } else { // 否则将下一个节点的值插入 set 中，继续遍历
            s.insert(cur->next->val);
            cur = cur->next;
        }
    }
}

  3. 采用双重链表遍历，每次排除一个元素的其他重复结点

    • 空间复杂度：O(1)
    • 时间复杂度：O(n^2)
    void deleteDuplicates(ListNode* head) {
    if (head == nullptr) {
        return;
    }
    ListNode* cur = head;
    while (cur != nullptr) {		// key：使用了当前遍历法，cur
        ListNode* prev = cur;
        ListNode* next = cur->next;
        while (next != nullptr) {	// key：使用了前者遍历法，cur->next
            if (next->val == cur->val) { // 如果下一个节点的值与当前节点的值相同，删除下一个节点
                prev->next = next->next;
                delete next;
                next = prev->next;
            } else { // 否则继续向后遍历
                prev = next;
                next = next->next;
            }
        }
        cur = cur->next;
    }
}

少年，我观你骨骼清奇，颖悟绝伦，必成人中龙凤。
不如点赞·收藏·关注一波

🚩点此跳转到首行↩︎

参考博客

  1. labuladong的leetcode滑动窗口模板
  2. codetop
  3. 动画演示+多种解法 206. 反转链表

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1566472.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

25+web技术站点，事半功倍，总有一个值得got

25+web技术站点，事半功倍，总有一个值得got

前言 收集一些有用的网站&#xff0c;为自己用&#xff0c;也分享一下&#xff0c;仅此而已。 ECMA 国际组织 各种文案 Ecma-262 - ECMAScript 规范Ecma-402&#xff0c; -国际化 API 规范Ecma-404 - JSON 数据交换语法ECMA-419 - 嵌入式系统 API 规范ECMA-414 规定了和 ECM…
阅读更多...
数据挖掘|关联分析与Apriori算法详解

数据挖掘|关联分析与Apriori算法详解

数据挖掘|关联分析与Apriori算法 1. 关联分析2. 关联规则相关概念2.1 项目2.2 事务2.3 项目集2.4 频繁项目集2.5 支持度2.6 置信度2.7 提升度2.8 强关联规则2.9 关联规则的分类 3. Apriori算法3.1 Apriori算法的Python实现3.2 基于mlxtend库的Apriori算法的Python实现 1. 关联分…
阅读更多...
比较靠谱的测试进度报告

比较靠谱的测试进度报告

在测试的过程中&#xff0c;不要等领导过问&#xff0c;有一份比较靠谱的测试进度报告&#xff0c;让关心和支持项目的干系人心里有谱&#xff0c;有利于管理层对项目的监控和资源的支持&#xff0c;有利于项目团队成员之间沟通协调&#xff0c;及时发现问题利于项目风险控制等…
阅读更多...
Docker 笔记

Docker 笔记

1.Ubuntu安装Docker 安装Docker看这篇文章 http://t.csdnimg.cn/IsSsJ 2.在docker中运行python代码 2.1搭建python环境 docker部署python环境看这篇文章 http://t.csdnimg.cn/TYz0G 2.2在python shell中运行python代码 2.2.1查看镜像 2.2.1启动python&#xff0c;厦门这个…
阅读更多...
ABC318 F - Octopus

ABC318 F - Octopus

解题思路 对于每个宝藏维护个区间&#xff0c;答案一定在这些区间中对于每个区间的端点由小到大排序对于每个点进行判断&#xff0c;若当前位置合法&#xff0c;则该点一定为一个右端点则该点到前一个端点之间均为合法点若前一个点不合法&#xff0c;则一定是某一个区间限制的…
阅读更多...
【Linux】详解动静态库的制作和使用动静态库在系统中的配置步骤

【Linux】详解动静态库的制作和使用动静态库在系统中的配置步骤

一、库的作用 1、提高开发效率&#xff0c;让开发者所有的函数实现不用从零开始。 2、隐藏源代码。 库其实就是所有的.o文件用特定的方式进行打包形成一个文件&#xff0c;各个.o文件包含了源代码中的机器语言指令。 二、动态库和静态库的制作和使用 2.1、静态库的制作和使用…
阅读更多...
【学习笔记】java项目—苍穹外卖day03

【学习笔记】java项目—苍穹外卖day03

文章目录 苍穹外卖-day03课程内容1. 公共字段自动填充1.1 问题分析1.2 实现思路1.3 代码开发1.3.1 步骤一1.3.2 步骤二1.3.3 步骤三 1.4 功能测试1.5 代码提交 2. 新增菜品2.1 需求分析与设计2.1.1 产品原型2.1.2 接口设计2.1.3 表设计 2.2 代码开发2.2.1 文件上传实现2.2.2 新…
阅读更多...
【代码随想录】数组

【代码随想录】数组

704. 二分查找 class Solution {public int search(int[] nums, int target) {if(numsnull || nums.length0){return -1;}return searchTarget(nums, 0, nums.length-1, target);}private int searchTarget(int[] nums, int left, int right, int target){//left和right都指向同…
阅读更多...
RegionCLIP网络结构解析 Region-based Language-Image Pretraining

RegionCLIP网络结构解析 Region-based Language-Image Pretraining

1、简单介绍 主要是关注目标检测方面的工作&#xff0c;现在纯CV已经前景黯淡&#xff0c;即使前段时间的YOLOv9发布也是关注一般。 现在大模型已成热点&#xff0c;而大模型要求的数据量和算力和算法复杂度&#xff0c;显然让很多人却步。但是具有大模型特点的多模态算法也算…
阅读更多...
Vue3从入门到实战：路由的query和params参数

Vue3从入门到实战：路由的query和params参数

在Vue 3中&#xff0c;我们可以通过路由的查询参数来传递数据。这意味着我们可以在不同的页面之间传递一些信息&#xff0c;以便页面可以根据这些信息来显示不同的内容或执行不同的操作。 查询参数的使用方式类似于在URL中添加附加信息&#xff0c;以便页面之间可以根据这些信息…
阅读更多...
AI技术创业：把握机遇，提升能力，迎接未来挑战

AI技术创业：把握机遇，提升能力，迎接未来挑战

文章目录 人工智能三次浪潮人工智能时代机遇提升核心能力AI时代的长期赛道和早期优势实践应用&#xff1a;让AI工具为你所用学会变通&#xff1a;适应AI领域的快速变化提升核心能力&#xff1a;想象力、创造力和提问能力结语 人工智能三次浪潮 第一次黄金期&#xff1a;1956年…
阅读更多...
基于SSM的网络视频播放器

基于SSM的网络视频播放器

目录 背景 技术简介 系统简介 界面预览 背景 互联网的迅猛发展彻底转变了全球各类组织的管理策略。自20世纪90年代起&#xff0c;中国政府和企业便开始探索利用网络系统进行信息管理。然而&#xff0c;早期的网络覆盖不广泛、用户接受度不高、相关法律法规不完善以及技术开…
阅读更多...
WPF文本框TextEdit不以科学计数法显示

WPF文本框TextEdit不以科学计数法显示

WPF文本框TextEdit不以科学计数法显示 一个float或者double类型的数值&#xff0c;如果小数点后0的个数≥4&#xff0c;在界面上就会自动以科学计数法显示&#xff0c; 比如&#xff1a;0.00003会显示成这样 但是很多时候我并不希望它这样显示&#xff0c;因为这样不方便编辑…
阅读更多...
成都欣丰洪泰文化传媒有限公司引领电商新风向

成都欣丰洪泰文化传媒有限公司引领电商新风向

在当今数字化时代&#xff0c;电子商务行业日新月异&#xff0c;竞争激烈。然而&#xff0c;在这股浪潮中&#xff0c;成都欣丰洪泰文化传媒有限公司凭借其独特的战略眼光和创新精神&#xff0c;正引领着电商领域的新浪潮。本文将探讨成都欣丰洪泰文化传媒有限公司如何在激烈的…
阅读更多...
实战webSocket压测（二）jmeter配置webSocket连接

实战webSocket压测（二）jmeter配置webSocket连接

背景 我们可以通过Jmeter添加插件实现webSocket脚本编写。WebSocket的插件较多&#xff0c;我选择以WebSocket Samplers by Peter Doornbosch为例来进行配置。 步骤1、WebSocket Samplers插件安装 下载地址&#xff1a;JMeter WebSocket Samplers&#xff0c;建议下载最新版本…
阅读更多...
阿里巴巴25届实习生内推

阿里巴巴25届实习生内推

#阿里巴巴 #春招实习 阿里国际春季2025届实习生招聘4月1日已正式启动&#xff01;学生网申投递、师兄师姐内推通道均已开放 整体介绍&#xff08;含在招岗位&#xff09; 内推投递方式 方式一&#xff1a;内推码自行投递 方式二&#xff1a;通过简历投递 简历发邮箱&#xf…
阅读更多...
Lumos学习王佩丰Excel第一讲：认识Excel

Lumos学习王佩丰Excel第一讲：认识Excel

最近发现自己在操作excel的一些特殊功能时会有些不顺手&#xff0c;所以索性找了一个比较全的教程&#xff08;王佩丰excel24讲&#xff09;拿来学习&#xff0c;刚好形成文档笔记&#xff0c;分享给有需要但没有时间看视频的朋友们。整体笔记以王老师授课的知识点去记录&#…
阅读更多...
蓝桥杯备考

蓝桥杯备考

目录 P8823 [传智杯 #3 初赛] 期末考试成绩 题目描述 输入格式 输出格式 输入输出样例 说明/提示 代码 P8828 [传智杯 #3 练习赛] 直角三角形 题目描述 输入格式 输出格式 输入输出样例 代码 P8833 [传智杯 #3 决赛] 课程 题目背景 题目描述 输入格式 输出格式…
阅读更多...
【热门话题】文言一心与ChatGPT-4：一场跨时代智能对话系统的深度比较

【热门话题】文言一心与ChatGPT-4：一场跨时代智能对话系统的深度比较

&#x1f308;个人主页: 鑫宝Code &#x1f525;热门专栏: 闲话杂谈&#xff5c; 炫酷HTML | JavaScript基础 ​&#x1f4ab;个人格言: "如无必要&#xff0c;勿增实体" 文章目录 文言一心与ChatGPT-4&#xff1a;一场跨时代智能对话系统的深度比较一、技术背景…
阅读更多...
西电计科大三下SOC微体系结构设计作业合集

西电计科大三下SOC微体系结构设计作业合集

目录 一.VHDL设计作业 1.基于硬件描述语言的3-8译码器逻辑电路设计 2.8位双向移位寄存器设计 3.基于有限状态机的自助售票系统设计 4.按键消抖电路设计 5.同步环形FIFO设计 6.线上实验——时钟模块设计 7.线上实验——原码二位乘法器设计 8.线上实验——布斯乘法器设…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023