数据结构：线性表————单链表专题

news2024/11/24 1:07:06

 🌈个人主页：小新_-

🎈个人座右铭：“成功者不是从不失败的人，而是从不放弃的人！”🎈

🎁欢迎各位→点赞👍 + 收藏⭐️ + 留言📝

🏆所属专栏： 数据结构与算法欢迎订阅，持续更新中~~~

                      

         ✨让小新带着你快乐的学习吧~✨

目录

1. 链表的概念及结构

2、单链表的实现

准备工作

1、单链表的插入

1）头插

2）尾插

3）指定位置前插

4）指定位置后插

2、单链表的删除

1）头删

2）尾删

3）删除指定位置节点

4）删除指定位置之后节点

3、单链表的查找

4、单链表的销毁

3、链表的分类

4、 链表经典算法OJ题⽬

3.1 单链表相关经典算法OJ题1：移除链表元素(点击进入题目)

3.2 单链表相关经典算法OJ题2：反转链表（点击进入题目）

3.3 单链表相关经典算法OJ题3：合并两个有序链表（点击进入题目）

3.4 单链表相关经典算法OJ题4：链表的中间结点（点击进入题目）

3.5 循环链表经典应⽤-环形链表的约瑟夫问题（点击进入题目）

3.6 单链表相关经典算法OJ题5：分割链表（点击进入题目）

1. 链表的概念及结构

概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表
中的指针链接次序实现的 。
链表的结构跟⽕⻋⻋厢相似，淡季时⻋次的⻋厢会相应减少，旺季时⻋次的⻋厢会额外增加⼏节。只 需要将⽕⻋⾥的某节⻋厢去掉/加上，不会影响其他⻋厢，每节⻋厢都是独⽴存在的。
⻋厢是独⽴存在的，且每节⻋厢都有⻋⻔。想象⼀下这样的场景，假设每节⻋厢的⻋⻔都是锁上的状 态，需要不同的钥匙才能解锁，每次只能携带⼀把钥匙的情况下如何从⻋头⾛到⻋尾？
最简单的做法：每节⻋厢⾥都放⼀把下⼀节⻋厢的钥匙。
在链表⾥，每节“⻋厢”是什么样的呢？
与顺序表不同的是，链表⾥的每节"⻋厢"都是独⽴申请下来的空间，我们称之为“结点/节点”
节点的组成主要有两个部分：当前节点要保存的数据和保存下⼀个节点的地址（指针变量）。
图中指针变量 plist保存的是第⼀个节点的地址，我们称plist此时“指向”第⼀个节点，如果我们希
望plist“指向”第⼆个节点时，只需要修改plist保存的内容为0x0012FFA0。
为什么还需要指针变量来保存下⼀个节点的位置？
链表中每个节点都是独⽴申请的（即需要插⼊数据时才去申请⼀块节点的空间），我们需要通过指针 变量来保存下⼀个节点位置才能从当前节点找到下⼀个节点。
结合前⾯学到的结构体知识，我们可以给出每个节点对应的结构体代码： 
struct SListNode
{
 int data; //节点数据
 struct SListNode* next; //指针变量⽤保存下⼀个节点的地址
};
当我们想要保存⼀个整型数据时，实际是向操作系统申请了⼀块内存，这个内存不仅要保存整型数
据，也需要保存下⼀个节点的地址（当下⼀个节点为空时保存的地址为空）。
当我们想要从第⼀个节点⾛到最后⼀个节点时，只需要在前⼀个节点拿上下⼀个节点的地址（下⼀个 节点的钥匙）就可以了。
补充说明：
1、链式机构在逻辑上是连续的，在物理结构上不⼀定连续
2、节点⼀般是从堆上申请的
3、从堆上申请来的空间，是按照⼀定策略分配出来的，每次申请的空间可能连续，可能不连续

2、单链表的实现

准备工作

单链表实现前，有几个小段代码和问题

1、首先，我们来搞懂一个一个概念上的问题，就是节点的实参形参问题，其实就是考验对指针的理解与掌握

2、申请新的节点

代码比较简单，用malloc函数申请新节点的空间，让新节点的的data域置为x,next域为空

SLTNode* SLNewNode(SLDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	newnode->Data = x;
	newnode->next = NULL;
	return newnode;
}

3、打印当前链表

上代码

void SLPrint(SLTNode* phead)
{
	SLTNode* pcur = phead;
	while (pcur)
	{
		printf("%d->", pcur->Data);
		pcur = pcur->next;
	}
	printf("NULL");
}

4、单链表的声明

typedef int SLDataType;
typedef struct SListNode
{
	SLDataType Data;
	struct SListNode* next;
}SLTNode;

1、单链表的插入

1）头插

分析：

尾删思路比较简单，我们有头结点的指针phead，我们让我们新申请的节点的next指针，指向原来的头结点，就完成了，我们考虑一下特殊情况，如果链表为空，怎么办？那还不简单，直接成为新的节点，代码就跟不是空表一样，so easy!小小头插，拿下拿下。

void SLPushFront(SLTNode** pphead, SLDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLNewNode(x);
	newnode->next = *pphead;
	*pphead = newnode;


}

2）尾插

分析：

如图，我们想插入一个元素4，如何插入呢？首先，我们得找到原尾节点吧。然后让原尾节点的next指针指向4这个新节点，这样我们的4就成为了尾节点，再让4的next指针指向NULL。但有一个问题，那就是如果链表为空怎么办？那就没有尾节点了。直接将这个节点作为我们的新节点。所以，大体思路就是，先判断链表是否为空，如果是就直接作为新的节点，如果不是，我们就先找到尾节点，然后执行插入操作就可以了。

代码如下：

void SLPushBack(SLTNode** pphead, SLDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLNewNode(x);
	//链表为空，作为结点
	if (*pphead == NULL)
	{
		*pphead = newnode;
		return;
	}
	//链表不为空，寻找尾节点
	SLTNode* ptail = *pphead;//寻找尾节点
	while (ptail->next)
	{
		ptail = ptail->next;
	}
	//ptail就是尾节点
	ptail = newnode;
}

3）指定位置前插

分析：

我们看到，要想在pos(3)之前插入，我们就要找到pos之前的节点prev，prev的next指向newnode，newnode的next指向pos。考虑特殊情况，当pos是头结点时，就没有prev，怎么办呢？我们可以直接调用头插即可。

代码如下：

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLDataType x)
{
	assert(pphead);
	assert(pos);
	assert(*pphead);
	SLTNode* newnode=  SLNewNode(x);
	//如果pos是头结点
	if (pos == *pphead)
	{
		SLPushFront(newnode, x);
		return;
	}
	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	prev->next = newnode;
	newnode->next = pos;
}

4）指定位置后插

分析：

指定位置后插比指定位置前插较为简单，但要注意的是顺序，如果先把pos的next给newnode,newnode中的next保存的是pos的下一个节点地址，然后再将newnode的next指向下一节点，这样导致pos的next不再指向真正的下一节点。而应该先把pos的next赋值给newnode的next,再将pos的next指向newnode.

代码如下：

2、单链表的删除

1）头删

分析：

头删比较简单，将原来的第二个节点作为新链表的第一个节点，并将原来第一个节点释放掉,并将next赋给pphead

代码如下：

void SLPopFront(SLTNode** pphead)//头删
{
	assert(pphead);//链表不为空
	assert(*pphead);//->指向第一个节点的地址
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	(*pphead) = next;
}

2）尾删

分析：

既然要进行删除操作，那么链表至少得有一个节点吧，所以得提前判断一下。要进行尾删，首先，我们要找到尾节点的前一个节点，我们就叫他prev吧，让prv不再指向尾节点的next域，而是NULL，然后将尾节点用free函数将尾节点的内存还给操作系统。但只有一个节点的时候呢？我们只能将该节点释放掉咯（没办法的事，无奈）

void SLPopBack(SLTNode** pphead)
{
	assert(pphead);//链表不为空
	assert(*pphead);//->指向第一个节点的地址
	while ((*pphead)->next==NULL)//如果只有一个节点
	{
		free(*pphead);
		*pphead = NULL;
		return;
	}
	//具有多个节点
	SLTNode* ptail = *pphead;
	SLTNode* prev = NULL;
	while (ptail->next)
	{
		prev = ptail;
		ptail=ptail->next;
	}//找到prev了
	prev->next = NULL;
	free(ptail);
ptail=NULL//别忘了置空，以免疯狗乱咬人（狗头 狗头）
}

3）删除指定位置节点

分析：

删除指定位置的节点，我们定义一个指针prev，让prev找到pos之前的节点（寻找prev的循环条件：prev->next !=pos），此时，将prev的next指针指向pos的下一个节点，再将pos释放掉。注意，顺序不能颠倒！！！需要注意的是特殊情况，当pos就是头结点。此时没有prev，我们可以直接执行头删操作。

代码如下：

void SLErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);
	if (pos == *pphead)
	{
		SLPopFront(pphead);
		return;
	}
	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	(prev->next) = (pos->next);
	free(pos);
	pos = NULL;
}

4）删除指定位置之后节点

分析：

思路比较清晰，看图一目了然，将pos的next指针指向pos下一个节点的下一个节点

代码如下：

void SLEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);
	pos->next = pos->next->next;
	free(pos->next);
	pos->next = NULL;
}

3、单链表的查找

没什么好说的，上代码

SLTNode* SLTFind(SLTNode** pphead, SLDataType x)
{
	assert(pphead);
	//遍历链表
	SLTNode* pcur = *pphead;
	while (pcur) //等价于pcur != NULL
	{
		if (pcur->Data == x) {
			return pcur;
		}
		pcur = pcur->next;
	}
	//没有找到
	return NULL;
}

4、单链表的销毁

上代码

void SListDesTroy(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);

	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}

完整代码如下

sqlist.c

#define _CRT_SECURE_NO_WARNINGS 1
#define _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"

void SLPrint(SLTNode* phead)
{
	SLTNode* pcur = phead;
	while (pcur)
	{
		printf("%d->", pcur->Data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}
SLTNode* SLNewNode(SLDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	newnode->Data = x;
	newnode->next = NULL;
	return newnode;
}
void SLPushBack(SLTNode** pphead, SLDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLNewNode(x);
	//链表为空，作为结点
	if (*pphead == NULL)
	{
		*pphead = newnode;
		return;
	}
	//链表不为空，寻找尾节点
	SLTNode* ptail = *pphead;
	while (ptail->next)
	{
		ptail = ptail->next;
	}
	//ptail就是尾节点
	ptail = newnode;
}
void SLPushFront(SLTNode** pphead, SLDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLNewNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}
void SLPopBack(SLTNode** pphead)
{
	assert(pphead);//链表不为空
	assert(*pphead);//->指向第一个节点的地址
	while ((*pphead)->next==NULL)//如果只有一个节点
	{
		free(*pphead);
		*pphead = NULL;
		return;
	}
	//具有多个节点
	SLTNode* ptail = *pphead;
	SLTNode* prev = NULL;
	while (ptail->next)
	{
		prev = ptail;
		ptail=ptail->next;
	}//找到prev了
	prev->next = NULL;
	free(ptail);
}
void SLPopFront(SLTNode** pphead)//头删
{
	assert(pphead);//链表不为空
	assert(*pphead);//->指向第一个节点的地址
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	(*pphead) = next;
}

//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLDataType x)
{
	assert(pphead);
	assert(pos);
	assert(*pphead);
	SLTNode* newnode=  SLNewNode(x);
	//如果pos是头结点
	if (pos == *pphead)
	{
		SLPushFront(newnode, x);
		return;
	}
	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	prev->next = newnode;
	newnode->next = pos;
}
//在指定位置之后插入数据
void SLInsertAfter(SLTNode* pos, SLDataType x)
{
	assert(pos);
	SLTNode* newnode = SLNewNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}
//删除pos节点
void SLErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);
	if (pos == *pphead)
	{
		SLPopFront(pphead);
		return;
	}
	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	(prev->next) = (pos->next);
	free(pos);
	pos = NULL;
}
//删除pos之后的节点
void SLEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);
	pos->next = pos->next->next;
	free(pos->next);
	pos->next = NULL;
}
SLTNode* SLTFind(SLTNode** pphead, SLDataType x)
{
	assert(pphead);
	//遍历链表
	SLTNode* pcur = *pphead;
	while (pcur) //等价于pcur != NULL
	{
		if (pcur->Data == x) {
			return pcur;
		}
		pcur = pcur->next;
	}
	//没有找到
	return NULL;
}
//销毁链表
void SListDesTroy(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);

	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}

slist.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int SLDataType;
typedef struct SListNode
{
	SLDataType Data;
	struct SListNode* next;
}SLTNode;
void SLPrint(SLTNode* phead);
SLTNode* SLNewNode(SLDataType x);
void SLPushBack(SLTNode** phead, SLDataType x);
void SLPushFront(SLTNode** phead, SLDataType x);
void SLPopBack(SLTNode** pphead);
void SLPopFront(SLTNode** pphead);
SLTNode* SLFind(SLTNode** pphead, SLDataType x);

//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLDataType x);
//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLDataType x);

//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos);
//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos);

//销毁链表
void SListDesTroy(SLTNode** pphead);

测试文件这里就不包含了，读者朋友可以自己写代码的时候测试

3、链表的分类

链表的结构⾮常多样，以下情况组合起来就有8种（2 x 2 x 2）链表结构：

如下：

虽然有这么多的链表的结构，但是我们实际中最常⽤还是两种结构： 单链表 和 双向带头循环链表
1. ⽆头单向⾮循环链表：结构简单，⼀般不会单独⽤来存数据。实际中更多是作为其他数据结
构的⼦结构，如哈希桶、图的邻接表等等。另外这种结构在笔试⾯试中出现很多。
2. 带头双向循环链表：结构最复杂，⼀般⽤在单独存储数据。实际中使⽤的链表数据结构，都
是带头双向循环链表。另外这个结构虽然结构复杂，但是使⽤代码实现以后会发现结构会带
来很多优势，实现反⽽简单了，后⾯我们代码实现了就知道了。

4、 链表经典算法OJ题⽬

3.1 单链表相关经典算法OJ题1：移除链表元素(点击进入题目)

思路一：遍历原链表，当遇到等于vul节点的时候，就执行删除操作
但有一个问题就是，删除操作太麻烦，有没有别的更好地方法呢？
思路二：创建一个新链表，遍历原链表，当节点值不为val时，尾插到新链表尾部 
typedef  struct ListNode ListNode;
struct ListNode* removeElements(struct ListNode* head, int val) {
    //定义新链表的头尾巴指针
    ListNode* newHead,*newTail;
    newHead=newTail=NULL;
    ListNode* pcur=head;
    while(pcur) {
        if（pcur->val !=val）//节点值不为val，插入链表尾部
        {
        if(newHead=NULL)//链表为空
        {
            newHead=newTail=pcur;
        }
        else//链表不为空，插入尾部
        {
            newTail->next=pcur;
            newTail=newTail->next;
        }
        }
        //等于val，直接下一个节点
        pcur=pcur->next;
    }
    if(newTail){
        newTail->next=NULL;
    }
    return newTail；
}

3.2 单链表相关经典算法OJ题2：反转链表（点击进入题目）

思路一：创建一个新链表，遍历原链表，将原链表元素依次头插在新链表当中。

思路二：定义三个指针变量，分别指向，当前节点，前驱和后继节点，改变节点指向即可。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
 typedef struct ListNode ListNode;
struct ListNode* reverseList(struct ListNode* head) {
    if(head==NULL){
        return head;
    }
    ListNode* n1,*n2,*n3;
    n1=NULL,n2=head,n3=head->next;
    ListNode* pcur;
    
    while(n2){
        n2->next=n1;
        n1=n2;
        n2=n3;
        if(n3){
        n3=n3->next;
        }

    }
    return n1;
}

3.3 单链表相关经典算法OJ题3：合并两个有序链表（点击进入题目）

思路：建立一个新链表，比较俩个链表元素，谁小就插入新链表
代码： 
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */typedef struct ListNode ListNode;
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {
    if(list1==NULL){
        return list2;
    }
    if(list2==NULL){
        return list1;
    }
     ListNode* l1,*l2;
    l1=list1,l2=list2;
     ListNode* newHead,*newTail;
    newHead=newTail=(ListNode*)malloc(sizeof(ListNode));

   
    while(l1&&l2){
    if(l1->val<l2->val){
        newTail->next=l1;
        newTail=newTail->next;
        l1=l1->next;
    }
    else{
        newTail->next=l2;
        newTail=newTail->next;
        l2=l2->next;
    }
    }
    if(l1){
        newTail->next=l1;
    }
    if(l2){
        newTail->next=l2;
    }
    ListNode*ret =newHead->next;
    free(newHead);
    newHead=NULL;
    return ret;

}

3.4 单链表相关经典算法OJ题4：链表的中间结点（点击进入题目）

思路一：遍历统计节点个数，当遍历完链表，将节点个数除以2，可以得到中间节点位置
思路二：快慢指针，定义一个快指针和一个慢指针，快指针一次走俩个元素，慢指针一次走一个元素。那当快指针遍历完链表时，慢指针就刚好指向中间节点，输出该节点即可。 
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
 typedef struct ListNode ListNode;
struct ListNode* middleNode(struct ListNode* head) {
    ListNode* fast,*slow;
    fast=slow=head;
  
    while(fast&&fast->next){
        fast=fast->next->next;
        slow=slow->next;
        
    }
    return slow;
}

3.5 循环链表经典应⽤-环形链表的约瑟夫问题（点击进入题目）

著名的Josephus问题
据说著名犹太 历史学家 Josephus有过以下的故事：在罗⻢⼈占领乔塔帕特后，39 个犹太⼈与
Josephus及他的朋友躲到⼀个洞中，39个犹太⼈决定宁愿死也不要被⼈抓到，于是决定了⼀个⾃杀 ⽅式，41个⼈排成⼀个圆圈，由第1个⼈开始报数，每报数到第3⼈该⼈就必须⾃杀，然后再由下⼀ 个重新报数，直到所有⼈都⾃杀⾝亡为⽌。
然⽽Josephus 和他的朋友并不想遵从，Josephus要他的朋友先假装遵从，他将朋友与⾃⼰安排在
第16个与第31个位置，于是逃过了这场死亡游戏。 
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

typedef struct ListNode ListNode;
struct ListNode* partition(struct ListNode* head, int x){
if(head==NULL){
    return head;
}
ListNode* newHeadLess,*newTailLess,*newHeadGreagter,*newTailGreagter;

newHeadLess=newTailLess=(ListNode*)malloc(sizeof(ListNode));
newHeadGreagter=newTailGreagter=(ListNode*)malloc(sizeof(ListNode));

ListNode* pcur=head;
while(pcur){
    if(pcur->val<x){
        newTailLess->next=pcur;
        newTailLess=newTailLess->next;
    }else{
        newTailGreagter->next=pcur;
        newTailGreagter=newTailGreagter->next;
    }
    pcur=pcur->next;
}
    newTailGreagter->next=NULL;
    newTailLess->next=newHeadGreagter->next;
    ListNode*ret=newHeadLess->next;
    free(newHeadGreagter);
    free(newHeadLess);
    return ret;
}

3.6 单链表相关经典算法OJ题5：分割链表（点击进入题目）

思路：建立大小链表，大于x放大链表，小于x放小链表，最后连接起来

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

typedef struct ListNode ListNode;
struct ListNode* partition(struct ListNode* head, int x){
if(head==NULL){
    return head;
}
ListNode* newHeadLess,*newTailLess,*newHeadGreagter,*newTailGreagter;

newHeadLess=newTailLess=(ListNode*)malloc(sizeof(ListNode));
newHeadGreagter=newTailGreagter=(ListNode*)malloc(sizeof(ListNode));

ListNode* pcur=head;
while(pcur){
    if(pcur->val<x){
        newTailLess->next=pcur;
        newTailLess=newTailLess->next;
    }else{
        newTailGreagter->next=pcur;
        newTailGreagter=newTailGreagter->next;
    }
    pcur=pcur->next;
}
    newTailGreagter->next=NULL;
    newTailLess->next=newHeadGreagter->next;
    ListNode*ret=newHeadLess->next;
    free(newHeadGreagter);
    free(newHeadLess);
    return ret;
}

 

最后，感谢大家的观看~~

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

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

相关文章

最简洁的Docker环境配置

最简洁的Docker环境配置

Docker环境配置 Docker 是一个开源的应用容器引擎&#xff0c;让开发者可以打包他们的应用以及依赖包到一个可移植的镜像中&#xff0c;然后发布到任何流行的 Mac、Linux或Windows操作系统的机器上&#xff0c;也可以实现虚拟化。容器是完全使用沙箱机制&#xff0c;相互之间不…
阅读更多...
YOLOv8打印模型结构配置信息并查看网络模型详细参数：参数量、计算量（GFLOPS）

YOLOv8打印模型结构配置信息并查看网络模型详细参数：参数量、计算量（GFLOPS）

《博主简介》 小伙伴们好&#xff0c;我是阿旭。专注于人工智能、AIGC、python、计算机视觉相关分享研究。 ✌更多学习资源&#xff0c;可关注公-仲-hao:【阿旭算法与机器学习】&#xff0c;共同学习交流~ &#x1f44d;感谢小伙伴们点赞、关注&#xff01; 《------往期经典推…
阅读更多...
docker-compose yaml指定具体容器网桥ip网段subnet

docker-compose yaml指定具体容器网桥ip网段subnet

docker-compose 启动yaml有时可能的容器网段与宿主机的ip冲突导致宿主机上不了网&#xff0c;这时候可以更改yaml指定subnet 宿主机内网一般是192**&#xff0c;这时候容器可以指定172* version: 3.9 services:coredns:image: coredns/coredns:1.10.0container_name: coredns…
阅读更多...
【面试必备】MySQL索引是什么？怎么设计索引？

【面试必备】MySQL索引是什么？怎么设计索引？

在后端面试中&#xff0c;MySQL的索引是一个常见问题&#xff0c;尤其是最近掀起了去Oracle的风向。作为一个很宽泛的面试题&#xff0c;不仅考验对MySQL整体知识的了解&#xff0c;也方便面试官随着我们的回答逐渐往下延伸问题。众所周知&#xff0c;面试问题的答案&#xff0…
阅读更多...
【力扣题】关于单链表和数组习题

【力扣题】关于单链表和数组习题

&#x1f308; 个人主页&#xff1a;白子寰 &#x1f525; 分类专栏&#xff1a;python从入门到精通&#xff0c;魔法指针&#xff0c;进阶C&#xff0c;C语言&#xff0c;C语言题集&#xff0c;C语言实现游戏&#x1f448; 希望得到您的订阅和支持~ &#x1f4a1; 坚持创作博文…
阅读更多...
使用MATLAB的cylinder函数生成圆柱体及其他应用

使用MATLAB的cylinder函数生成圆柱体及其他应用

cylinder 函数是 MATLAB 中的一个内置函数&#xff0c;用于生成表示圆柱体表面的坐标点。这些坐标点可以用于绘制三维图形&#xff0c;如使用 surf 或 mesh 函数进行可视化。 cylinder函数生成单位圆柱体的x、y和z坐标。您可以使用surf或mesh来绘制圆柱形对象&#xff0c;或者…
阅读更多...
1233. 全球变暖---BFS

1233. 全球变暖---BFS

目录 1233. 全球变暖 输入格式 输出格式 数据范围 输入样例1&#xff1a; 输出样例1&#xff1a; 输入样例2&#xff1a; 输出样例2&#xff1a; 思路&#xff1a; 宽搜BFS 模板&#xff1a; 代码&#xff1a; 运行结果&#xff1a; 1233. 全球变暖 你有一张某海域 NN…
阅读更多...
Mongo 报错 Can‘t canonicalize query: BadValue $in needs an array

Mongo 报错 Can‘t canonicalize query: BadValue $in needs an array

一、遇到的问题 Mongo in查询 [ UserId > array($in>$userIds)] $userIds数组不是连续索引&#xff0c;报错Cant canonicalize query: BadValue $in needs an array 二、解决 array_values($userIds) 重新索引一下变成连续索引即可。 Mongo in查询的数组要是连续索…
阅读更多...
WEB3.0：互联网的下一阶段

WEB3.0：互联网的下一阶段

随着互联网的发展&#xff0c;WEB3.0时代正在逐步到来。本文将深入探讨WEB3.0的定义、特点、技术应用以及未来展望&#xff0c;为读者带来全新的思考。 一、什么是WEB3.0&#xff1f; WEB3.0可以被理解为互联网发展的下一阶段&#xff0c;是当前WEB2.0的升级版。相较于2.0时代…
阅读更多...
react状态管理库---zustand

react状态管理库---zustand

一个简单的&#xff0c;快速的状态管理解决方案&#xff0c;api设计基于函数式和hooks 安装&#xff1a; npm install zustand 基础使用 让我们实现一个非常简单的计数器案例完成我们的第一个store 1- 创建一个counterStore create( ) 有三个参数&#xff1a;函数、布尔值…
阅读更多...
[C++][算法基础]模拟散列表(哈希表)

[C++][算法基础]模拟散列表(哈希表)

维护一个集合&#xff0c;支持如下几种操作&#xff1a; I x&#xff0c;插入一个整数 x&#xff1b;Q x&#xff0c;询问整数 x 是否在集合中出现过&#xff1b; 现在要进行 N 次操作&#xff0c;对于每个询问操作输出对应的结果。 输入格式 第一行包含整数 N&#xff0c;…
阅读更多...
类和对象【一】类和对象简介

类和对象【一】类和对象简介

文章目录 C的类与C语言结构体的区别【引入类】类的定义类体中的成员函数的实现类中的访问限定符C中class和struct的区别 类的作用域类的实例化类中成员的存储位置类的大小 C的类与C语言结构体的区别【引入类】 类里面不仅可以定义变量还可以定义函数 例 类具有封装性【将在该…
阅读更多...
c++ 指针总结

c++ 指针总结

概述 内存地址 在计算机内存中&#xff0c;每个存储单元都有一个唯一的地址(内存编号)。通俗理解&#xff0c;内存就是房间&#xff0c;地址就是门牌号 指针和指针变量 指针&#xff08;Pointer&#xff09;是一种特殊的变量类型&#xff0c;它用于存储内存地址。指针的实质…
阅读更多...
libcurl 简单实用

libcurl 简单实用

LibCurl是一个开源的免费的多协议数据传输开源库&#xff0c;该框架具备跨平台性&#xff0c;开源免费&#xff0c;并提供了包括HTTP、FTP、SMTP、POP3等协议的功能&#xff0c;使用libcurl可以方便地进行网络数据传输操作&#xff0c;如发送HTTP请求、下载文件、发送电子邮件等…
阅读更多...
【Linux】UDP编程【上】{诸多编程接口/小白入门式讲解}

【Linux】UDP编程【上】{诸多编程接口/小白入门式讲解}

文章目录 0.预备知识0.1套接字0.2TCP/UDP0.3大小端问题 1.socket 常见API1.1socket1.2各个接口1.3int bind();1.3网络头文件四件套1.4bzero1.5recvfrom1.6sendto() 2.UDP编程2.1服务器编程2.2客户端编程2.3运行测试2.3.1本机通信2.3.2popen2.3.3strcasestr2.3.4回顾C11智能指针…
阅读更多...
dfs板子

dfs板子

递归实现排列 留着明早省赛之前看 #include<iostream> using namespace std; int arr[10010]; int brr[10010]; int n,k; void dfs(int num){if(num > n){for(int i 1;i < n;i){cout << arr[i] << " ";}cout << endl;return;}for(in…
阅读更多...
mysql题目2

mysql题目2

tj11: select sex,count(sex) from t_athletes group by sex; tj12: select name 姓名,TIMESTAMPDIFF(year,birthday,2024-1-1) 年龄 from t_athletes tj13: SELECT * FROM t_athletesWHERE id NOT IN (SELECT aid FROM t_match WHERE sid IN (SELECT id FROM t_sport WHE…
阅读更多...
python 的join函数

python 的join函数

join函数是一个对字符串处理的函数 字符串.join(str)的含义是把字符串加入到str的每一个间隙里面 如 str1234 ,.join(str) #打印的结果为 1,2,3,4
阅读更多...
C语言处理文本模板：格式信函编程

C语言处理文本模板：格式信函编程

开篇 本篇文章的问题来源为《编程珠玑》第3章其中一个问题&#xff0c;格式信函编程。说白了就是先在文件中定义一个文本模版&#xff0c;然后使用数据库中的数据去填充这个模版&#xff0c;最后得到填充后的文本&#xff0c;并输出。 问题概要 在常去的网店键入你的名字和密码…
阅读更多...
动态规划先导片

动态规划先导片

大家知道动规是由前一个状态推导出来的&#xff0c;而贪心是局部直接选最优的&#xff0c;对于刷题来说就够用了。 对于动态规划问题&#xff0c;我将拆解为如下五步曲&#xff0c;这五步都搞清楚了&#xff0c;才能说把动态规划真的掌握了&#xff01; 确定dp数组&#xff0…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023