【数据结构】单链表---C语言版

【数据结构】单链表---C语言版

  • 一、顺序表的缺陷
  • 二、链表的概念和结构
    • 1.概念：
  • 三、链表的分类
  • 四、链表的实现
    • 1.头文件：SList.h
    • 2.链表函数：SList.c
    • 3.测试函数：test.c
  • 五、链表应用OJ题
    • 1.移除链表元素
      • （1）题目描述：
      • （2）思路表述：
      • （3）代码实现：
    • 2.翻转一个单链表
      • （1）题目描述：
      • （2）思路表述：
      • （3）代码实现：
    • 3.返回一个链表的中间节点
      • （1）题目描述：
      • （2）思路表述：
      • （3）代码实现：
    • 4.链表中倒数第k个结点
      • （1）题目描述：
      • （2）思路表述：
      • （3）代码实现：
    • 5.合并两个有序链表
      • （1）题目描述：
      • （2）思路表述：
      • （3）代码实现：
    • 6. 链表分割
      • （1）题目描述：
      • （2）思路表述：
      • （3）代码实现：
    • 7. 链表的回文结构
      • （1）题目描述：
      • （2）思路表述：
      • （3）代码实现：
    • 8.相交链表
      • （1）题目描述：
      • （2）思路表述：
      • （3）代码实现：
    • 9.判断链表中是否有环
      • （1）题目描述：
      • （2）思路表述：
      • （3）代码实现：
  • 六、链表和顺序表的优缺点对比

一、顺序表的缺陷

（1）挪动数据时间开销较大：如果是头插或者头删，后面的数据都需要挪动时间复杂度为O（N），这样的代价就比较大。
（2）增容有代价：每次扩容都需要向系统申请空间，然后拷贝数据，然后再释放原来的旧空间，这样对系统的消耗还是不小的。
（3）空间浪费：我们每次空间不够，都会扩大原来空间的二倍，如果我只需要两个字节的空间，但是我扩大了原来100的2倍，那98个字节的空间就浪费了。

但是谁能来解决这个问题呢？那么就是接下来要讲的：链表！
![在这里插入图片描述](https://img-blog.csdnimg.cn/4ce633c0acf64b7f8a1f000bd5a1c4df.pn

二、链表的概念和结构

1.概念：

链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表
中的指针链接次序实现的 。
在这里插入图片描述
现实中的链表就是这样的：
在这里插入图片描述

  1. 从上面的图片我们可以看出链式结构在逻辑上是连续的，但是在物理上它不一定是连续的。
  2. 现实中也就是物理上的节点都是从堆上申请出来的。
  3. 从堆上申请的空间是按照一定的策略来分配的，两次申请的空间：可能连续，也可能不连续。

三、链表的分类

实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

1. 单向或者双向：
在这里插入图片描述
2. 带头或者不带头：
在这里插入图片描述
3. 循环或者非循环：
在这里插入图片描述

4.虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：
无头单向非循环链表和带头双向循环链表。
在这里插入图片描述

四、链表的实现

1.头文件：SList.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>typedef int SLTDataType;typedef struct SListNode
{SLTDataType data;struct SListNode* next;
}SLTNode;//打印函数
void SLTPrint(SLTNode* phead);//申请新结点函数
SLTNode* BuySListNode(SLTDataType x);//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x);//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x);//头删
void SLTPopFront(SLTNode** pphead);//尾删
void SLTPopBack(SLTNode** pphead);//单链表查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);// 在pos之前插入x
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);//在pos位置之后插入一个数字x
void SLTInsertAfter(SLTNode* pos, SLTDataType x);//删除POS位置的值
void SLTErase(SLTNode** pphead, SLTNode* pos);//删除POS位置的下一个值
void SLTEraseAfter(SLTNode* pos);

2.链表函数：SList.c

#define _CRT_SECURE_NO_WARNINGS 1 
#include <stdio.h>
#include "SList.h"void SLTPrint(SLTNode* phead)
{SLTNode* cur = phead;while (cur){printf("%d-> ", cur->data);cur = cur->next;}printf("NULL\n");
}SLTNode* BuySListNode(SLTDataType x)
{SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));if (newnode == NULL){perror("malloc fail");exit(-1);}newnode->data = x;newnode->next = NULL;return newnode;
}//头插void SLTPushFront(SLTNode** pphead, SLTDataType x)
{SLTNode* newnode = BuySListNode(x);newnode->next = *pphead;*pphead = newnode;
}//尾插
//如果我要改变指针的指向，我不可能通过传值调用，我只能通过来改变指针的地址，
//也就是用二级指针才能改变结构体指针的指向。
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{SLTNode* newnode = BuySListNode(x);//创建新节点if (*pphead == NULL){// 改变的结构体的指针，所以要用二级指针*pphead = newnode;}else{SLTNode* tail = *pphead;while (tail->next)//tail->next!=NULL{tail = tail->next;}// 改变的结构体，用结构体的指针即可tail->next = newnode;//因为tail->next是结构体中的一个成员}
}//头删
void SLTPopFront(SLTNode** pphead)
{//空：//如果直接指向空指针,那就不用删了assert(*pphead);//非空：// 我们需要运用空瓶思想创建个临时变量来存放，要删那个节点的下一个节点的地址，//要不然删除那个节点之后，下一个节点的地址就连接不上了。SLTNode* newnode = (*pphead)->next;free(*pphead);*pphead = newnode;}//尾删
void SLTPopBack(SLTNode** pphead)
{//1.空assert(*pphead);//1个节点if ((*pphead)->next == NULL){free(*pphead);*pphead = NULL;}//1个以上结点else{//因为是尾删，所以需要一个前摇标志：tailPrevSLTNode* tailPrev = NULL;SLTNode* tail = *pphead;while (tail->next){tailPrev = tail;tail = tail->next;}free(tail);tailPrev->next = NULL;}//方法2//SLTNode* tail = *pphead;//while (tail->next->next)//{//	tail = tail->next;//}//free(tail->next);//tail->next = NULL;
}//查找函数
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{SLTNode* cur = phead;while (cur)//而不是cur->text!=NULL，查找因为我要遍历完！！！{if (cur->data == x){return cur;}cur = cur->next;}return NULL;//当全部都遍历完了，还没找到的话，就直接返回  空 （NULL）
}//在POS之前插入一个结点void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{assert(pphead);assert(pos);//SLTNode* prev = *pphead;if (pos == *pphead){SLTPushFront(pphead, x);}else{SLTNode* prev = *pphead;while (prev->next != pos){prev = prev->next;}SLTNode* newnode = BuySListNode(x);prev->next = newnode;newnode->next = pos;}
}//在pos位置后插入一个数字
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{assert(pos);SLTNode* newnode = BuySListNode(x);//while()为啥不用循环？？？？newnode->next = pos->next;pos->next = newnode;}void SLTErase(SLTNode** pphead, SLTNode* pos)
{assert(pos);if (pos == *pphead){SLTPopFront(pphead);}else{SLTNode* prev = *pphead;while (prev->next != pos){prev = prev->next;}prev->next = pos->next;free(pos);//pos = NULL;}
}//删除pos后位置的一个值
void SLTEraseAfter(SLTNode* pos)
{assert(pos);//检查尾节点是否为空assert(pos->next);//空瓶思想：需要先做一个标记,posnext就是空瓶存放,在pos的下一个位置SLTNode* posNext = pos->next;pos->next = posNext->next;free(posNext);posNext = NULL;}

3.测试函数：test.c

#define _CRT_SECURE_NO_WARNINGS 1 
#include <stdio.h>
#include "SList.h"void TestList1()
{int n=0;printf("请输入链表的长度：");scanf("%d", &n);printf("\n请依次输入每个节点的值：");SLTNode* plist = NULL;for (int i = 0; i < n; i++){int val = 0;scanf("%d", &val);SLTNode* newnode = BuySListNode(val);//头插newnode->next = plist;plist = newnode;}SLTPrint(plist);SLTPushBack(&plist, 10000);SLTPrint(plist);
}//void SLTPushBack(SLTNode** phead, SLTDataType x)
//{
//	//如果我要改变指针的指向，我不可能通过传值调用，我只能通过来改变指针的地址，也就是用二级指针才能改变结构体指针的指向。
//	SLTNode* newnode = BuySListNode(x);
//	SLTNode* tail = phead;
//	while (tail->next)//tail->next!=NULL
//	{
//		tail = tail->next;
//	}
//	tail->next = newnode;
//}//测试尾插
void TestList2()
{SLTNode* plist = NULL;SLTPushBack(&plist, 10);SLTPrint(plist);SLTPushBack(&plist, 20);SLTPrint(plist);SLTPushBack(&plist, 30);SLTPrint(plist);SLTPushBack(&plist, 40);SLTPrint(plist);SLTPushBack(&plist, 50);SLTPrint(plist);
}//测试头插
void TestList3()
{SLTNode* plist = NULL;SLTPushFront(&plist, 10);SLTPrint(plist);SLTPushFront(&plist, 20);SLTPrint(plist);SLTPushFront(&plist, 30);SLTPrint(plist);SLTPushFront(&plist, 40);SLTPrint(plist);SLTPushFront(&plist, 50);SLTPrint(plist);
}//测试尾删
void TestList4()
{SLTNode* plist = NULL;SLTPushFront(&plist, 10);SLTPushFront(&plist, 20);SLTPushFront(&plist, 30);SLTPushFront(&plist, 40);SLTPushFront(&plist, 50);SLTPrint(plist);SLTPopBack(&plist);SLTPrint(plist);SLTPopBack(&plist);SLTPrint(plist);SLTPopBack(&plist);SLTPrint(plist);SLTPopBack(&plist);SLTPrint(plist);SLTPopBack(&plist);SLTPrint(plist);
}//测试头删
void TestList5()
{SLTNode* plist = NULL;SLTPushFront(&plist, 10);SLTPushFront(&plist, 20);SLTPushFront(&plist, 30);SLTPushFront(&plist, 40);SLTPushFront(&plist, 50);SLTPrint(plist);SLTPopFront(&plist);SLTPrint(plist);SLTPopFront(&plist);SLTPrint(plist);SLTPopFront(&plist);SLTPrint(plist);SLTPopFront(&plist);SLTPrint(plist);SLTPopFront(&plist);SLTPrint(plist);
}//测试查找
void TestList6()
{SLTNode* plist = NULL;SLTPushFront(&plist, 10);SLTPushFront(&plist, 20);SLTPushFront(&plist, 30);SLTPushFront(&plist, 40);SLTPushFront(&plist, 50);SLTPrint(plist);SLTNode* pos = SLTFind(plist, 40);if (pos){pos->data *= 10;}SLTPrint(plist);int x = 0;printf("请输入要查找数字的位置：");scanf("%d", &x);pos = SLTFind(plist, x);if (pos){SLTInsert(&plist, pos, x * 10);}SLTPrint(plist);}void TestList7()
{SLTNode* plist = NULL;SLTPushFront(&plist, 10);SLTPushFront(&plist, 20);SLTPushFront(&plist, 30);SLTPushFront(&plist, 40);SLTPushFront(&plist, 50);SLTPrint(plist);int x;printf("请输入你想要查找的数字：");scanf("%d", &x);SLTNode* pos = SLTFind(plist, x);if (pos){SLTInsertAfter(pos, x * 10);}SLTPrint(plist);}void TestList8()
{SLTNode* plist = NULL;SLTPushFront(&plist, 10);SLTPushFront(&plist, 20);SLTPushFront(&plist, 30);SLTPushFront(&plist, 40);SLTPushFront(&plist, 50);SLTPrint(plist);int x = 0;printf("请输入你想要查找的数字：");scanf("%d", &x);SLTNode* pos = SLTFind(plist, x);if (pos){SLTErase(plist, pos);}SLTPrint(plist);
}void TestList9()
{SLTNode* plist = NULL;SLTPushFront(&plist, 10);SLTPushFront(&plist, 20);SLTPushFront(&plist, 30);SLTPushFront(&plist, 40);SLTPushFront(&plist, 50);SLTPrint(plist);int x = 0;printf("请输入你想要查找的数字：");scanf("%d", &x);SLTNode* pos = SLTFind(plist, x);if (pos){SLTEraseAfter(pos);}SLTPrint(plist);}int main()
{//TestList1();//TestList2();//TestList3();//TestList4();//TestList5();//TestList6();//TestList7();TestList8();//TestList9();return 0;
}

五、链表应用OJ题

1.移除链表元素

（1）题目描述：

点击链接
在这里插入图片描述

（2）思路表述：

创建的prev和tmp指针都是用来保存 cur当前节点指针的前一个和后一个：因为如果你直接销毁cur的话，他前一个和后一个连接不起来，所以说你要先创建暂时的节点来保存它。
分类讨论：

  1. 从头往后找，如果没找到要删的目标节点就一直往后走：
    prev->next=cur;
    cur=cur->next;

  2. 如果找到目标节点，这里面还要分为：如果目标节点是在“头”，我们要进行“头删”，如果在除了“头”的其他位置是另一种情况（注意：只要我找到了要删的目标节点，我一定要先保存，当前要删节点的下一个！）

（3）代码实现：

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
struct ListNode* removeElements(struct ListNode* head, int val) 
{struct ListNode* prev=NULL;struct ListNode* cur=head;while(cur){if(cur->val==val)//只要找到了，我就保存！{struct ListNode* tmp=cur->next;//接下来我就要判断了，//1.如果他这个链表里面第1个就是我们要删除的节点。prev==NULL就说明第1个就是目标if(prev==NULL){free(cur);head=tmp;cur=tmp;}else//2.除了头删的其他任意位置！{prev->next=tmp;free(cur);cur=tmp;}}else//没找到就都往下一个走{prev->next=cur;cur=cur->next;}}return head;
}

2.翻转一个单链表

（1）题目描述：

点击链接
在这里插入图片描述

（2）思路表述：

1.在这里插入图片描述
2.在这里插入图片描述
3.
在这里插入图片描述

（3）代码实现：

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
struct ListNode* reverseList(struct ListNode* head) 
{struct ListNode* cur=head;struct ListNode* newhead=NULL;while(cur){//1.保存cur的下一个结点struct ListNode* tmp=cur->next;//2.头插：头插之后一定要记得newhead要往前走一步cur->next=newhead;newhead=cur;//3.原链表中的cur继续往后走！cur=tmp;}return newhead;
}

3.返回一个链表的中间节点

（1）题目描述：

点击链接
在这里插入图片描述

（2）思路表述：

利用两个指针，一个是快指针（fast），一个慢指针（slow），快指针移动的速度是慢指针的二倍！

（3）代码实现：

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
struct ListNode* middleNode(struct ListNode* head) 
{struct ListNode* fast=head;struct ListNode* slow=head;while(fast&&fast->next)//1.fast存在：针对奇数个结点  2.fast—>next存在：针对偶数个结点{fast=fast->next->next;slow=slow->next;}return slow;
}

4.链表中倒数第k个结点

（1）题目描述：

点击链接
在这里插入图片描述

（2）思路表述：

如果要求倒数第k个节点并返回k节点：还是利用快慢指针法，先让fast指针走k步，slow在第一个节点不动，完了之后呢，然后他们再一起走，最后如果fast走到了NULL，那么就直接返回slow就OK了！
自己要尝试画画图

（3）代码实现：

/*** struct ListNode {*	int val;*	struct ListNode *next;* };*//*** * @param pListHead ListNode类 * @param k int整型 * @return ListNode类*/
struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) 
{struct ListNode* fast=pListHead;struct ListNode* slow=pListHead;//fast=(fast->next)*k;//先让fast指针走K步while(k--){if(fast==NULL){return NULL;}fast=fast->next;}while(fast){fast=fast->next;slow=slow->next;}return slow;
}

5.合并两个有序链表

（1）题目描述：

题目链接
在这里插入图片描述

（2）思路表述：

在这里插入图片描述
2.
在这里插入图片描述
3.
在这里插入图片描述
4.
在这里插入图片描述
5.
在这里插入图片描述

（3）代码实现：

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2) 
{struct ListNode* head=NULL;struct ListNode* tail=NULL;//前提：排除如果有一个链表就是空的咋办？if(l1==NULL){return l2;}if(l2==NULL){return l1;}//1.确定好：l1和l2谁为head,tailif(l1->val<l2->val){head=tail=l1;l1=l1->next;}else{head=tail=l2;l2=l2->next;}//2.逐个节点判断while(l1&&l2){if(l1->val<l2->val){tail->next=l1;l1=l1->next;tail=tail->next;}else{tail->next=l2;l2=l2->next;tail=tail->next;}}//3.如果跳出了循环，那么肯定有一个指向了NULLif(l1==NULL){tail->next=l2;}if(l2==NULL){tail->next=l1;}return head;
}

6. 链表分割

（1）题目描述：

点击链接
在这里插入图片描述

（2）思路表述：

分析：申请两个链表，一个放比x小的节点，一个放比x大的节点，最后将大链表链接在小链表末尾即可。

（3）代码实现：

/*
struct ListNode {int val;struct ListNode *next;ListNode(int x) : val(x), next(NULL) {}
};*/
#include <cstddef>
class Partition {public:ListNode* partition(ListNode* pHead, int x) {struct ListNode* cur = pHead;struct ListNode* lhead;struct ListNode* ltail;struct ListNode* ghead;struct ListNode* gtail;lhead= ltail= (struct ListNode*)malloc(sizeof(struct ListNode));ghead= gtail=(struct ListNode*)malloc(sizeof(struct ListNode));while (cur) {if (cur->val < x) {ltail->next = cur;ltail = ltail->next;}else {gtail->next = cur;gtail = gtail->next;}cur = cur->next;}ltail->next = ghead->next;//不置空，会导致死循环gtail->next = NULL;//释放哨兵位，但需先创建结构体保存：lhead的第一个struct ListNode* head = lhead->next;free(lhead);free(ghead);return head;}
};

7. 链表的回文结构

（1）题目描述：

点击链接
在这里插入图片描述

（2）思路表述：

分析：判断链表是否是回文结构，可以结合前面的题：

（1）利用快慢指针找到链表中间结点

（2）将后半部分逆置

（3）将（2）中的链表从第一个节点开始和中间结点开始同时进行访问，如果所有val相等，则链表为回文结构。

（3）代码实现：

/*
struct ListNode {int val;struct ListNode *next;ListNode(int x) : val(x), next(NULL) {}
};*/
class PalindromeList {public:bool chkPalindrome(ListNode* head) {struct ListNode* middleNode(struct ListNode * head);struct ListNode* reverseList(struct ListNode * head);//找到中间节点struct ListNode* middleNode(struct ListNode * head) {struct ListNode* fast = head;struct ListNode* slow = head;while (fast && fast->next) {slow = slow->next;fast = fast->next->next;}return slow;}//将中间节点后的都逆置struct ListNode* reverseList(struct ListNode * head) {struct ListNode* cur = head;struct ListNode* newhead = NULL;while (cur) {//这个next定义一定要在while循环内部，因为每次头插之前都要保存下一个节点的地址!!!struct ListNode* next = cur->next;//头插cur->next = newhead;newhead = cur;cur = next;}return newhead;}struct ListNode* mid = middleNode(head);struct ListNode* rmid = reverseList(mid);//head相当于原来链表的前一半的头指针//rmid相当于原来链表后一半的头指针while (head && rmid) {if (head->val != rmid->val) {return false;}head = head->next;rmid = rmid->next;}return true;}};

8.相交链表

（1）题目描述：

点击链接
在这里插入图片描述

（2）思路表述：

分别计算出L1链表和L2链表的总长度，然后用两个指针，一个是：fast，一个是：slow，让fast先走他们的差值步，让他们处在同一竖直平行线上，然后他们两个一起走，两个指针一起走后如果所指向的节点的值相同，那么就返回这个公共节点，也就是相交节点！

（3）代码实现：

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) 
{//1.极端条件的判断，要么L1为空，要么L2为空，我就返回空，所以说不可能有公共交点。if(headA == NULL || headB == NULL){return NULL;}struct ListNode *curA = headA, *curB = headB;int lenA = 0,lenB = 0;while(curA->next){curA = curA->next;lenA++;}while(curB->next){curB = curB->next;lenB++;}//2.此时此刻两个循环都结束了，current a指向的是最后一个节点，current b也指向最后一个节点，如果他们两个不相等的话，走到最后一个节点还没有公共交点，那么他们两个永远远远不可能会有公共节点，所以说我们直接返回空就ok了。if(curA != curB){return NULL;}//3.此时两个指针都指向数值水平线的平行线上处于同一位置,现在不知道lena大?还是lenb大?所以说我先假设lena大struct ListNode *longList = headA,*shortList = headB;if(lenA < lenB){longList = headB;shortList = headA;}int gap = abs(lenA - lenB);while(gap--){longList = longList->next;}while(longList != shortList){longList = longList->next;shortList = shortList->next;}return longList;
}

9.判断链表中是否有环

（1）题目描述：

点击链接

在这里插入图片描述

（2）思路表述：

分析：

如何判断链表是否有环：使用快慢指针，慢指针一次走1步，快指针一次走2步，如果链表带环，那么快慢同时从链表起始位置开始向后走，一定会在环内相遇，此时快慢指针都有可能在环内打圈，直到相遇；否则，如果链表不带环，那么快指针会先走到链表末尾，慢指针只能在链表末尾追上快指针。

在这里插入图片描述

如果快指针不是一次走2步，而是一次走3步，一次走4步一次走x步呢？能不能判断出链表是否带环呢？

如果快指针一次走两步，当slow从直线中间移动到直线末尾时，fast又走了slow的2倍，因此当slow进环时，fast可能在环的任意位置，具体要看直线有多长，环有多大。在环内，一定是fast追slow，因为fast比slow移动的快。

fast一次走3步：假设slow进环的时候，fast跟slow相差N步，环的长度为C，追击时，slow走1步，fast走3步，每走1次，差距就缩小

在这里插入图片描述

总结：如果slow进环时，slow和fast的差距N是奇数，且环的长度C为偶数(则C-1为奇数，上面举例可以看出差距最小为1或-1)，那么就永远追不上了。

（3）代码实现：

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
bool hasCycle(struct ListNode *head) 
{struct ListNode* slow=head;struct ListNode* fast=head;while(fast&&fast->next){slow=slow->next;fast=fast->next->next;if(fast==slow){return true;}}return false;
}

六、链表和顺序表的优缺点对比

在这里插入图片描述

没有谁好谁坏，不同情况具体对待，相辅相成罢了

好了，今天的分享就到这里了
如果对你有帮助，记得点赞👍+关注哦！
我的主页还有其他文章，欢迎学习指点。关注我，让我们一起学习，一起成长吧！

在这里插入图片描述

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

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

相关文章

多媒体信号处理复习笔记 --脑图版本

多媒体信号处理复习笔记 --脑图版本

多媒体信号处理复习笔记 --脑图版本 依据 [2020多媒体信号处理复习笔记] 考前复习时使用Xmind制作 例图: PDF下载 BaiduYunPan 提取码&#xff1a;jbyw CSDN 下载
阅读更多...
从零构建属于自己的GPT系列1：文本数据预处理、文本数据tokenizer、逐行代码解读

从零构建属于自己的GPT系列1：文本数据预处理、文本数据tokenizer、逐行代码解读

&#x1f6a9;&#x1f6a9;&#x1f6a9;Hugging Face 实战系列 总目录 有任何问题欢迎在下面留言 本篇文章的代码运行界面均在PyCharm中进行 本篇文章配套的代码资源已经上传 从零构建属于自己的GPT系列1&#xff1a;文本数据预处理 从零构建属于自己的GPT系列2&#xff1a;语…
阅读更多...
渲染到纹理：原理及WebGL实现

渲染到纹理：原理及WebGL实现

这篇文章是WebGL系列的延续。 第一个是从基础知识开始的&#xff0c;上一个是向纹理提供数据。 如果你还没有阅读过这些内容&#xff0c;请先查看它们。 NSDT在线工具推荐&#xff1a; Three.js AI纹理开发包 - YOLO合成数据生成器 - GLTF/GLB在线编辑 - 3D模型格式在线转换 - …
阅读更多...
ffmpeg 把mp4文件中某段视频转成gif文件

ffmpeg 把mp4文件中某段视频转成gif文件

一 缘起背景&#xff1a; 有视频文件转gif动图的需求&#xff1b;网上下载的转换工具需要注册会员、否则带水印&#xff0c;还限制时长。 二 工具环境&#xff1a; win10 下 dos 操作 ffmpeg 三 操作命令&#xff1a; ffmpeg -i test.mp4 -ss 00:01:01 -t 00:00:19 -vf &q…
阅读更多...
什么牌子的台灯对孩子的眼睛好？安利五款适合孩子备考的护眼台灯

什么牌子的台灯对孩子的眼睛好？安利五款适合孩子备考的护眼台灯

近年来&#xff0c;青少年的近视问题越来越严重&#xff0c;近视率持续升高&#xff0c;不少上小学一年级就已经戴上了厚厚的近视眼镜。导致这种现象发生的原因有两个&#xff0c;一个是孩子长时间使用电子产品导致。还有就是现在孩子的学习任务&#xff0c;不仅远比80、90后上…
阅读更多...
【开源】基于JAVA的高校学生管理系统

【开源】基于JAVA的高校学生管理系统

项目编号&#xff1a; S 029 &#xff0c;文末获取源码。 \color{red}{项目编号&#xff1a;S029&#xff0c;文末获取源码。} 项目编号&#xff1a;S029&#xff0c;文末获取源码。 目录 一、摘要1.1 项目介绍1.2 项目录屏 二、功能模块2.1 学生管理模块2.2 学院课程模块2.3 学…
阅读更多...
Python基础语法之学习表达式进行符串格式化

Python基础语法之学习表达式进行符串格式化

Python基础语法之学习表达式进行符串格式化 一、代码二、效果 一、代码 print("11等于%d" % (1 1)) print(f"2/1等于{2 / 1}") print("字符串类型是%s" % type("字符串"))二、效果 坚持追求自己的梦想&#xff0c;即使道路漫长曲折&…
阅读更多...
模板引擎详解

模板引擎详解

&#x1f4d1;打牌 &#xff1a; da pai ge的个人主页 &#x1f324;️个人专栏 &#xff1a; da pai ge的博客专栏 ☁️宝剑锋从磨砺出&#xff0c;梅花香自苦寒来 &#x1f324;️动态页面的渲染方式 …
阅读更多...
盘点68个Android系统源码安卓爱好者不容错过

盘点68个Android系统源码安卓爱好者不容错过

盘点68个Android系统源码安卓爱好者不容错过 学习知识费力气&#xff0c;收集整理更不易。 知识付费甚欢喜&#xff0c;为咱码农谋福利。 源码下载链接&#xff1a;https://pan.baidu.com/s/1FcBxCe7KpJsh0zFxNZ_7wg?pwd8888 提取码&#xff1a;8888 项目名称 Android …
阅读更多...
外贸B2B自建站怎么建？做海洋建站的方法？

外贸B2B自建站怎么建？做海洋建站的方法？

如何搭建外贸B2B自建站&#xff1f;外贸独立站建站方法有哪些&#xff1f; 对于许多初次涉足者来说&#xff0c;搭建一个成功的外贸B2B自建站并不是一件轻松的任务。海洋建站将为您详细介绍如何有效地建设外贸B2B自建站&#xff0c;让您的国际贸易之路更加畅通无阻。 外贸B2B…
阅读更多...
Android中使用Google Map

Android中使用Google Map

在app的使用过程中&#xff0c;我们经常会跟地图进行交互&#xff0c;如果是海外的应用&#xff0c;那选择使用Google Map 是最合适的选择。 在Android中如何使用Google Map&#xff0c;这里做一个简要的说明。 Google API_KEY的申请 Google Map 的使用并不是免费的&#xf…
阅读更多...
主播岗位面试

主播岗位面试

一、自我介绍 在面试的开始阶段&#xff0c;你需要准备一个简洁而有力的自我介绍。这个自我介绍应该包括你的姓名、教育背景、工作经验以及你为何对这个主播职位感兴趣。这个自我介绍应该控制在1-2分钟之内&#xff0c;避免冗长的表述。 二、主播经历和特点 在这个环节&…
阅读更多...
javaagent字节码增强浅尝

javaagent字节码增强浅尝

概述 javaagent 技术广泛应用于对代码的增强&#xff0c;比如统计方法执行时间、GC 信息打印、分布式链路跟踪等&#xff1b;实现方式包括 javassist 和 bytebuddy&#xff0c;bytebuddy 是对 javassist 的改进&#xff1b;类似于 spring 中的 AOP&#xff1b; Instrumentati…
阅读更多...
京东数据运营-京东数据平台-京东店铺数据分析-2023年10月京东烘干机品牌销售榜

京东数据运营-京东数据平台-京东店铺数据分析-2023年10月京东烘干机品牌销售榜

鲸参谋监测的京东平台10月份烘干机市场销售数据已出炉&#xff01; 10月份&#xff0c;烘干机市场整体销售上涨。鲸参谋数据显示&#xff0c;今年10月份&#xff0c;京东平台上烘干机的销量将近5万件&#xff0c;环比增长约77%&#xff0c;同比增长约22%&#xff1b;销售额将近…
阅读更多...
XUbuntu22.04之OBS强大录屏工具(一百九十五)

XUbuntu22.04之OBS强大录屏工具(一百九十五)

简介&#xff1a; CSDN博客专家&#xff0c;专注Android/Linux系统&#xff0c;分享多mic语音方案、音视频、编解码等技术&#xff0c;与大家一起成长&#xff01; 优质专栏&#xff1a;Audio工程师进阶系列【原创干货持续更新中……】&#x1f680; 优质专栏&#xff1a;多媒…
阅读更多...
NX/UG二次开发—踩坑（边上点与面上点）

NX/UG二次开发—踩坑（边上点与面上点）

获取视图内遮挡面时&#xff0c;特别是与视图平行的面认为是可视面&#xff0c;但NX选择认为是非可视面&#xff0c;设计方案时只检查边上的点&#xff0c;发现一些面显示干涉遮挡&#xff0c;通过打印数据发现&#xff0c;以边上点为参考&#xff0c;获取面上点&#xff0c;会…
阅读更多...
kubernetes(K8s)(Namespace、Pod、Deployment、Service资源的基本操作)-04

kubernetes(K8s)(Namespace、Pod、Deployment、Service资源的基本操作)-04

Namespace Namespace是kubernetes系统中的一种非常重要资源&#xff0c;它的主要作用是用来实现多套环境的资源隔离或者多租户的资源隔离。 默认情况下&#xff0c;kubernetes集群中的所有的Pod都是可以相互访问的。但是在实际中&#xff0c;可能不想让两个Pod之间进行互相的…
阅读更多...
leetcode 18. 四数之和（优质解法）

leetcode 18. 四数之和（优质解法）

代码&#xff1a; class Solution {public List<List<Integer>> fourSum(int[] nums, int target) {List<List<Integer>> listsnew ArrayList<>();int lengthnums.length;Arrays.sort(nums);for(int i0;i<length-4;){for(int ji1;j<lengt…
阅读更多...
第十五届蓝桥杯（Web 应用开发）模拟赛 2 期-大学组（详细分析解答）

第十五届蓝桥杯（Web 应用开发）模拟赛 2 期-大学组（详细分析解答）

目录 1.相不相等 1.1 题目要求 1.2 题目分析 1.3 源代码 2.三行情书 2.1 题目要求 2.2 题目分析 2.3 源代码 3.电影院在线订票 3.1 题目要求 3.2 题目分析 3.3 源代码 4.老虎坤&#xff08;不然违规发不出来&#xff09; 4.1 题目要求 4.2 题目分析 4.3 源代码 …
阅读更多...
宝塔环境备份到西部数码FSS

宝塔环境备份到西部数码FSS

1、登陆宝塔面板-软件商店-第三方应用&#xff0c; 搜索ftp&#xff1a;找到FTP存储空间&#xff0c;点击安装 2、在软件商城-已安装&#xff0c;找到ftp存储空间&#xff0c;点击进入选项设置. 3、按照下图填写fss相关参数.这些信息可以在fss详情中查看.目录路径如果没有请先在…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023