C语言笔记数据结构（链表）

news2025/4/1 5:48:13

希望文章能对你有所帮助，有不足的地方请在评论区留言指正,一起交流学习!

目录

1.链表

1.1 链表概念和组成

1.2 链表的分类

1.3 顺序表和链表

2.单链表（无头单向不循环链表）

2.1 结点的创建

2.2 创建新的结点

2.3 单链表的打印

2.4 尾插和尾删

2.5 头插和头删

2.6 查找函数

2.7 在pos之前插入和pos位置的删除

2.8 在pos之后插入和删除

3.单链表的OJ题目

4.带头循环双向链表

        本文将介绍详细介绍链表中的不带头单向不循环链表（单链表）和带头双向循环链表的增删查改（使用），以及关于单链表的OJ题的分析和答案。

1.链表

        本部分介绍链表的概念以及组成、分类。

1.1 链表概念和组成

  链表是在存储空间是不连续的，但是每个数据结点是通过结点中的指针连接的。      

        下图是一个单链表存储的数据类型是整型，plist存储的链表的第一个结点的位置，通过第一个结点，可以通过结点中存储的指针访问下一个结点的内容。最后一个结点存储的指针是空的。

上图的结点创建通过结构体创建如下

//定义结点中存储的数据的类型
typedef int SLTDataType;
//创建结点内容 
struct SListNode
{
	SLTDataType data;            //数据域 节点中存在的数据
	struct SListNode * next;	 //指针域 域指向下一个节点的指针
};

          结点 一般有数据域和指针域组成，数据域存储的是链表所存储的数据，可以是结构体、整型等等数据类型；指针域，结点中可能有两个指针（双向链表，分别指向链表的前后结点）或者一个指针（单向链表，指向链表的下一个结点）。总之，链表由结点构成，结点中存储着数据以及连接链表的指针 。   

1.2 链表的分类

     链表和顺序表一样数用来存储数据的一种结构，链表分为8种，有单向、双向；带头、不带头；循环、不循环之间组合。分别是带头单向循环、带头单向不循环、带头双向循环、带头双向不循环、不带头单向不循环、不带头单向循环、不带头双向不循环、不带头双向循环。

先从简单的单向开始说起

1）单向不带头不循环链表 （d1、d2……代表数据）空白代表指针（这里不在编写指针，理解即可）

2）单向带头不循环链表

        带头和不带头的相同长度的链表，就是多一个结点，这个结点可以叫做哨兵位，哨兵位结点存储是链表起始结点的指针，结点类型和存储数据的结点一样。当链表中没有数据存储的时候，

guard->next = NULL 对比不带头的链表在链表为空的状态下存储数据的时候省去了判断链表是否为空的步骤。

3）单向不带头循环链表

        相比不循环就是多了一个圈，这个圈从来链表的结尾执行链表的起始地址，和链表中的环不一样（下面会有详细介绍链表环）。

4）单向带头循环链表

5）双向不带头不循环链表

        和单向不同的是双向链表有两个指针，可以指向两个方向就是双向了，下面就就是结点的创建，两个指针，在插入和删除操作时，逻辑简单，便于操作。

//定义结点中存储的数据的类型
typedef int SLTDataType;
//创建结点内容 
struct SListNode
{
	SLTDataType data;            //数据域 节点中存在的数据
	struct SListNode * next;	 //指针域 指向下一个结点
    struct SListNode * prev;	 //指针域 指向上一个结点
};

6）双向不带头循环链表

        和单向循环双向循环多了一个循环回路，有头结点的prev指向尾部结点，尾部的next指向头部的结点。

7）双向带头不循环链表

8）双向带头循环链表

9）单链表和双向带头循环链表的比较       

         由最初的单链表（单向不带头不循环）到最后的双向带头循环链表，看着结构逻辑更加的复杂了，但是后者的程序更加好编写，在后续的学习中大家可以体会的到，

二者相比

        单链表的结构简单，但在程序编写复杂，在接口的形参上，大部分需要传递是二级指针；且部分函数编写无法进行复用，在数据存储和调用上需要逐步遍历寻找，因此也不会单独存储数据，更多的是使用在其他数据结构的底层中，如哈希桶

        带头双向循环链表，结果较为复杂，但是程序好编写，由于一个结点两个指针的情况，在加入和删除数据的操作简单，因此适合存储数据；在形参的传递上仅需要传递一级指针即可，无论头部和尾部的插入和删除接口均可以复用函数实现。
        

1.3 顺序表和链表

        顺序表是内存是连续存储的，链表的内存在逻辑上是连续存储的；

        顺序表的内存申请的会造成一定成的内存浪费，链表是按需申请；

        顺序表的使用realloc函数开辟空间，异地开辟的情况，重新迁移数据，浪费时间，且浪费空间，链表均为小块的空间通过指针连接。

         总之，顺序表和链表各有各的好处，只是两者的用途不同。

2.单链表（无头单向不循环链表）

        本部分将详细介绍单链表中对数据的增删查改，分析其中的思路并给出示例。数据以整型为例。 

2.1 结点的创建

        在上文中提到结点由指针和存储的数据构成，使用结构体来创建的结点，因此就要结点的指针要使用结构体指针指向下一个结构体（结点）；数据类型重新定义名称方便的后续的修改。

//定义结点中存储的数据的类型
typedef int SLTDataType;
//创建结点内容 
struct SListNode
{
	SLTDataType data;            //数据域 节点中存在的数据
	struct SListNode * next;	 //指针域 域指向下一个节点的指针
};
typedef struct SListNode SLTNode //将结构体类型重新定义为简单的表达，便于使用
2.2 创建新的结点

        链表在使用过程中需要加入新的结点，就需要新的结点；结点函数形参为存储到结点的数据，返回值为新的结点的指针。创建新的结点，首先使用malloc为新的结点开辟空间，然后再给结点的中的data赋值，将结构体中的next指针置为NULL。

SLTNode* BuyNewNode(SLTDataType x)
{
	//创建新的节点
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	//判断空间是否开辟成功
	if (newnode == NULL)
	{
		perror("malloc fail");
	}
	//赋值
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}
2.3 单链表的打印

        单链表的打印，建议使用新的指针（cur，current 当前的）将链表的头指针（指向首个结点的指针），为什么遍历的条件结束的条件是cur ！= NULL 而不是cur->next ！=NULL呢？可以分析当cur->next为空的时候，cur刚刚指向最后一个指针。此时循环结束，未遍历所有的结点数据，

cur = cur->next 此行代码保证了链表的依次向后遍历数据。当链表为空的时候，phead可能为NULL，因此这里不能使用assert（phead）来判断链表是否为空，也可以使用来判断链表是否为空。

//输出链表顺序
void SLTPrintf(SLTNode* phead)//phead是链表指向链表的开端，链表的最后一个节点的的存储的指针是NULL
{
    //assert(phead);
	SLTNode* cur = phead;
	//创建一个新的节点，赋值
	while (cur != NULL)
	{
		printf("%d->",cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

当cur=NULL的时候，循环停止。

2.4 尾插和尾删

        代码中的注释较多，在次简单说一下思路和注意事项

尾插函数：分为两种情况，

        一种空链表，phead（链表的头指针:指向链表的第一个结点）

        我们在创建新的结点的时候，将结点的next置为NULL，因此尾插的时候不用考虑它，只需要考虑将phead指向newnode。

        本次要修改的是phead，如果传递的是一级指针和phead同级，无法对phead修改，所以要传递二级指针。所以*pphead= phead，如下图经过指令*pphead = newnode之后

        另一种情况就比较难一些了，首先我们需要找到尾部，找到之后再将新的结点插入。

找到尾部，我们需要使用while循环遍历整个链表，但是和遍历打印不同的是判断条件是

tail->next != NULL；为什么？循环遍历不一样导致cur和tail结束的位置不一样，在打印遍历的时候cur的位置最后指向的是NULL，而这里的遍历条件tail结束的的时候指向的是最后的结点。

        当找到最后一个结点的时候就要将tail和newnode连接起来了，根据结点的指向，tail的几点中的next应该指向newnode 结点，因此tail->next=newnode，可以将tail指向的结点和newnode指向的结点连接。

//尾插函数
void SLTPushBack(SLTNode** pphead,SLTDataType x)
{
	assert(pphead);//传递的是结构体指针，
	SLTNode* newnode = BuyNewNode(x);
	//将上述节点加在尾部
	//分为两种情况 一种为链表为空，一种是链表不为空
	if (*pphead == NULL)
	{
		*pphead = newnode;//将新开辟的节点指针赋值给链表首地址
	}
	else
	{
		SLTNode* tail = *(pphead);//对传递过来的数据进行修改 
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		//找到尾部后，将尾部的NULL替换为新节点的指针
		tail->next = newnode;
	}
}

尾删函数

        此函数中可能涉及到phead头指针的修改，例如链表中只有一个元素，删除之后链表可能为空，所以就要将phead =  NULL。综上所属，函数的形参需要传递的是二级指针。

       尾删分为三种情况，看图解吧，比较直观。

首先第一种情况 链表为空的情况使用assert（*pphead）直接进行空指针判断是否为空。

第二种情况：链表中只有一个结点的情况，将phead直接置为NULL，则链表为空。这里的

*pphead修改才能真正的修改到phead。

第三种情况：链表中有两个以及两个以上的元素，通过遍历递进找到链表最后一个结点的上一个结点。判断的遍历循环的结束条件是tail->next->next != NULL，循环结束的时候 tail指向的是倒数第二个结点，

将tail指向的这个结点的tailnext=NULL，就可以将最后一个结点和之前结点的指针连接断开。

        当然在删除掉结点的时候一定要将结点申请的空间释放掉，需要的是指向内存的的指针，即

free(tail->next)要在置为NULL之前使用，防止内存泄漏。

//尾删函数
void SLTPopBack(SLTNode** pphead)
{
	assert(pphead);//判断pphead是否为空
	assert(*pphead);//若链表为空，则直接报错
	//一个节点的情况下
	if ((*pphead)->next==NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else 
	{
		//找尾多个节点
		SLTNode* tail = *pphead;
		while (tail->next->next != NULL)//寻找的是下一个节点是否为最后一个节点
		{
			tail = tail->next;
		}
		//当找到位置的时候，
		free(tail->next);
		tail->next = NULL;
	
	}
}
2.5 头插和头删

头插函数

        在这里也要考虑两种情况，一种链表为空，一种链表不为空，如下图。和尾插不同的值这里不用再遍历链表了。

链表为空的情况和尾插一样的:

链表不为空的情况:分为两个步骤 看图吧，第一步要插入结点肯定要创建结点，新的结点的指针名字为plist。

        第二步，将新的结点的next指向第一个结点，plist->next = *pphead;
        第三步 将原本的头指针phead（*pphead）改为指向plist*pphead = plist。

//头插函数
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	//考虑两种情况 链表有数据 链表没有数据，
	assert(pphead);//判断是否为空指针
	//先创建一个新的节点 插入
	SLTNode* plist = BuyNewNode(x);
	//链表为空的情况下
	if(*pphead==NULL)
	*pphead = plist;
	//链表有数据的情况下
	else 
	{
		plist->next = *pphead;
		*pphead = plist;
	}
}

头部删除

           两种情况一种链表为空，另种情况链表不为空

对于链表为空的状态，使用了assert（*pphead）直接报错的；

对于链表不为空的情况（包含链表种只有一个元素的情况）

上图由*pphead = (*pphead)->next;操作由红色虚线变为蓝色虚线；然后释放删除结点的空间    free(head);  head = NULL。


//头删函数
void SLTPopFront(SLTNode** pphead)
{
	assert(pphead);//检测是否为空指针
	assert(*pphead);//链表为空的情况下
		//链表有多个节点
	SLTNode* head = *pphead;//创建临时指针 便于后续释放节点申请的空间
	*pphead = (*pphead)->next;
	free(head);
	head = NULL;

}
2.6 查找函数

        函数的形参的确定，再查找函数中，不会涉及对函数头指针以及结点（结构体的修改），因此传递二级指针，还有需要寻找的元素的数值（以整型为例）为形参。需要注意的是结点的返回值。

思路：遍历链表寻找具有相同的值的元素。这里循环结束的条件是ptr！=NULL；即ptr会走到NULL的位置结束。

       在链表种没有找到元素的时候，返回NULL；链表为空，使用的assert（phead）判断是个否为空；

        链表不为空的状态,没有做动图，大家将就一下，后面等我调试好软件改以一下。

        

//查找函数
SLTNode* SlistFind(SLTNode* phead, SLTDataType x)
{
	assert(phead);//查找函数考虑是否是空链表
	SLTNode* ptr = phead;
	while (ptr != NULL)
	{
		if (ptr->data == x)
		{
			return ptr;
		}
		else
		{
			ptr = ptr->next;
		}
	}
	return NULL;//空指针的情况下

	/*SLTNode* prev = phead;
	while (prev->next->data != x)
	{
		prev = prev->next;
	}
	return prev->next;*/
}
2.7 在pos之前插入和pos位置的删除

在pos位置之前插入

        函数的形参，以插入的结点的位置，插入结点的数据，链表头的二级指针（修改链表头）；分为两种情况，其实在前面的SlistFind（）函数种，我已经使用assert（phead）将空链表的情况排除了。

       第一种情况，pos指向phead，plist是前插函数创建的结点，下图的操作是红色的建有改为了蓝色的箭头

        第二种情况pos指向其他位置，首先创建prev变量，根据判断条件prev->next!=pos找到得指针prev指向得是pos位置得前一个结点。

        找到位置之后就可以创建新的结点，然后插入。详细过程如图：

//pos位置之前插入
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);//判断传递的指针是否为空
	assert(pos);
	//在数据中间插入
	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);//在空指针的情况下，直接插入
	}
	else
	{
		//创建新的节点
		SLTNode* newnode = BuyNewNode(x);
		SLTNode* prev = *pphead;//保证原来指针不要修改
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		prev->next = newnode;
		newnode->next = pos;
	}

	
}

删除pos位置结点

        由于删除pos位置之前的结点，容易造成非法访问，不便于操作，因此直接删除pos位置的结点。

        两种情况，一种为pos指向第一个结点，一个为pos不指向第一个结点。

第一种情况相当于头删，直接调用的头删函数就可以了。

第二种情况 遍历寻找到pos位置之前的结点，然后修改结点的指针。

//删除pos位置结点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);
	if (pos == *pphead)
	{
		
		SLTPopFront(pphead);
	}
	else //pos != *pphead
	{
		SLTNode* prev = *pphead;//创建新的节点寻找pos
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
        pos = NULL;//pos传递的是一级指针，在这里修改无用，应在主函数中修改
	}

}
2.8 在pos之后插入和删除

思路：

        在pos之后插入新的结点

          在pos之后插入新的结点操作较为简单，只需要修改指针的指向即可。

         首先创建新的结点，因为在确定位置之后的尾插在这里不用考虑头指针的修改，所以不用传递phead，pos和x即可。然后交换newnode和pos结点的next即可完成交换


//pos位置之后插入
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	//创建新的节点
	SLTNode* newnode = BuyNewNode(x);
	//插入 交换指针
	newnode->next = pos->next;
	pos->next = newnode;

}

      提示 ： 在pos之后删除新的结点，传递的形参只用pos指针就可以了，考虑到pos为尾结点的时候报错。 

//pos位置之后的删除
void SLTEraseAfter( SLTNode* pos)
{
	assert(pos->next);//判断pos是否为尾结点
	SLTNode* del = pos->next;
	pos->next = del->next;
	free(del);//
	del = NULL;
}

        在pos之前插入和在pos之后插入的时间复杂度比较，之前为O（N），之后插入为O(1)，因此在确定位置的插入，单链表也适合尾部插入。

3.单链表的OJ题目

        本部分包含单链表的OJ题目，其中会有使用带哨兵位的链表的使用（带头的单向链表）。此章节不会所有的题都有图，看代码可以看懂思路的不会有图。

3.1  删除链表等于给定值val的结点 

题目连接 ：203. 移除链表元素 - 力扣（LeetCode）

        和单链表中删除指定位置pos的操作相同，对于给定的val值找出对应的结点，然后删除结点。不同的是操作要遍历整个链表，因此结束条件是head=NULL。当然我还是会有绘图的。

        1. 首先按照给定的值找到对应结点，创建新的指针cur=head，哟哦与返回值是链表的头指针，不便于修改head。

        2.如何将对应的cur指向的结点删除，分两种种情况，一种cur是首结点，涉及到head，修改的时候较为麻烦；另一种是其他结点（包含尾结点），根据2.7中写的删除对应结点位置的指针，使用两个指针，cur前面的指针也要确定，因此需要定义另一个指针为prev。

1.寻找结点cur 当然寻找结点和删除结点时同步进行的

2. 删除对应val的结点，分为两种情况；一种情况是phead = cur（题目中的头指针是head）的情况， 需要修改头指针；第二种情况 删除指定结点操作。

上面是对于写思路的分析，下面是代码。

struct ListNode* removeElements(struct ListNode* head, int val) 
{
    struct ListNode* prev = NULL;
    struct ListNode* cur = head;
    while(cur)//遍历的循环条件 cur！=NULL
    {
        if(cur->val != val)  //在不是val值的情况
        {
            prev = cur;
            cur = cur->next;//prev->next = cur 意思是prev的next指向cur
        }
        else 
        {
            if(prev == NULL)// val是第一结点
            {
                head = cur->next;//删除第一个结点的操作
                free(cur);
                cur = head;

            }
            else                 //val不是第一个结点
            {
                prev->next = cur->next;
                free(cur);
                cur = prev->next;
            }
        }

    }
    return head;
}

        按照之前的说法想要修改头指针的情况就要传递二级指针，但是这里由返回值，返还的是修改之后的值，因此这里传递一级指针足够。当然函数种知道删去结点的指针，可以使用free函数释放归还操作空间，但是无法将其置为空，在同一级的指针种，形参的改变无法改变实参。

3.2 反转一个单链表

题目连接 ：206. 反转链表 - 力扣（LeetCode）

        提示 ：和单链表种的头插的操作相似，创建一个新的链表将上面的链表按下顺序从第一个结点依次头插如新的结点。

struct ListNode* reverseList(struct ListNode* head)
{
    struct ListNode* newhead = NULL;//新的链表的头结点指针
    struct ListNode* cur = head;//在子函数中，形参的数最好不修改，保证可用
    while(cur != NULL)
    {
        struct ListNode* next = cur->next;//存储指针，方便指针的更迭
        //头插
        cur->next = newhead;
        newhead = cur;
        cur = next;
    }
    return newhead;
}
3.3 寻找链表的中间结点

       描述： 给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。

        题目链接：876. 链表的中间结点 - 力扣（LeetCode）

        提示：使用两个指针来遍历链表，快慢指针思路，一个依次走两步，一个一次走一步。

分为两种情况

  • 奇数个结点 fast（快指针）走到尾结点就结束了，判断条件是 fast->next!=NULL
  • 偶数个结点 fast（快指针）走到NULL的时候才结束，判断条件是 fast！=NULL

偶数结点  

奇数结点

struct ListNode* middleNode(struct ListNode* head) 
{
    struct ListNode* slow = head; //慢指针
    struct ListNode* fast = head; //快指针

    while(fast && fast->next)
    {
        //移步
        slow = slow->next;     
        fast = fast->next->next;
    }
    return slow;
}
3.4 返回倒数第k个结点

题目链接：面试题 02.02. 返回倒数第 k 个节点 - 力扣（LeetCode）

提示：使用快慢指针，快指针走k步，当快指针为NULL的时候（画图分析），慢指针正好位于倒数第k个结点。

int kthToLast(struct ListNode* head, int k)
{
    struct ListNode* fast = head;
    struct ListNode* slow = head;
    while(k--)
    {
        fast = fast->next;
    }
    while(fast)
    {
        fast = fast->next;
        slow = slow->next;
    }
    return slow->val;
}
3.5 合并两个有序链表

题目链接：21. 合并两个有序链表 - 力扣（LeetCode）

提示：创建一个新的链表，然后比较大小，依次尾插进入新的链表中，会剩余一个链表还有结点，直接将新的链表和有剩余结点的链表链接起来。

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {
    
    //判断链表是否为空
    if(list1 == NULL)
        return list2;
    if(list2 == NULL)
        return list1;
    struct ListNode* cur1 = list1;
    struct ListNode* cur2 = list2;
    struct ListNode* head = NULL;
    struct ListNode* tail = NULL;
    //  创建一个新的链表赋值
    while(cur1 && cur2)
    {
        if(cur1->val < cur2->val)
        {
            //插入的为第一个元素 尾插
            if(head == NULL)
            {  
                tail = head = cur1;
            }  
            else
            {
                tail->next = cur1;
                tail = tail->next;
            }
            cur1 = cur1->next;
        }
        else
        {
            //插入的为第一个元素 尾插
            if(head == NULL)
            {  
                tail = head = cur2;
            }  
            else
            {
                tail->next = cur2;
                tail = tail->next;
            }
                cur2 = cur2->next;
        }
        //处理剩余结点
    if(cur1)
    {
        tail->next = cur1;
    }
     if(cur2)
    {
        tail->next = cur2;
    }
    return head;
}

3.6

3.7

3.8

3.9 * 给定一个链表，判断链表中是否有环（含只有证明）

        题目链接：141. 环形链表 - 力扣（LeetCode）

思路；快慢指针，等快指针和慢指针相等的时候，链表肯定存在环；如果使用的是链表中存在的数据相等，无法证明链表有环的，链表中含有重复的数值。

bool hasCycle(struct ListNode *head) {

    struct ListNode *slow = head;
    struct ListNode *fast = head;
    struct ListNode *cur = head;
    while(fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;
        if(fast == slow)
         return true;
    }
    return false;
}

        bool 布尔值，真的情况下，返回 true 错误的情况下，返回 false。

证明

        1.为什么fast走2步，slow走1步，二者会相遇，不会错过吗？

        追击和相遇的问题，当fast走2步，slow走1步；中间缩小1步，因此无论如何fast都会追上slow的。

        当fast追上slow的时候，fast走了多少步 ?

L+C+X ?  对吗？ 只能说存在这个可能，因为可能L很长，C很短，fast走了n圈，slow才进入环，因此fast走了 L+ N*C+X;（N≥1）

        2.为什么fast走n（n＞2）步，slow走1步，二者还会相遇？

        可能相遇可能不相遇；假设 n=3 那么之间没有一次，二者减小2步；进入环后，当fast和slow之间距离为偶数，可相遇；为奇数fast超出slow一步。

4.带头循环双向链表

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

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

相关文章

Leetcode 两数相除

Leetcode 两数相除

✅ LeetCode 29. 两数相除 — 思路总览 &#x1f9e9; 题目要求 给定两个整数 dividend 和 divisor&#xff0c;实现 整数除法&#xff0c;不能使用乘法 *、除法 / 和取余 % 运算符。 要求返回的结果应为 向零截断的整数商&#xff0c;即&#xff1a; 正数向下取整&#xf…
阅读更多...
人工智能图像识别Scala介绍

人工智能图像识别Scala介绍

Scala 一.Scala 简介 Scala即Scalable Language&#xff08;可伸缩的语言&#xff09;&#xff0c;Scala 语言是由 Martin Odersky 等人在 2003 年开发的&#xff0c;并于 2004 年首次发布。意味着这种语言设计上支持大规模软件开发&#xff0c;是一门多范式的编程语言。 Sc…
阅读更多...
C++中使用CopyFromRecordset将记录集拷贝到excel中时，如果记录集为0个，函数崩溃，是什么原因

C++中使用CopyFromRecordset将记录集拷贝到excel中时，如果记录集为0个，函数崩溃，是什么原因

文章目录 原因分析解决方案1. 检查记录集是否为空2. 安全调用COM方法3.进行异常捕获4. 替代方案&#xff1a;手动处理空数据 总结 在C中使用CopyFromRecordset将空记录集&#xff08;0条记录&#xff09;复制到Excel时崩溃的原因及解决方法如下&#xff1a; 原因分析 空记录集…
阅读更多...
c#的.Net Framework 的console 项目找不到System.Window.Forms 引用

c#的.Net Framework 的console 项目找不到System.Window.Forms 引用

首先确保是建立的.Net Framework 的console 项目,然后天健reference 应用找不到System.Windows.Forms 引用 打开对应的csproj 文件 在第一个PropertyGroup下添加 <UseWindowsForms>true</UseWindowsForms> 然后在第一个ItemGroup 下添加 <Reference Incl…
阅读更多...
蓝桥杯嵌入式学习笔记

蓝桥杯嵌入式学习笔记

用博客来记录一下参加蓝桥杯嵌入式第十六届省赛的学习经历 工具环境准备cubemx配置外部高速时钟使能设置串口时钟配置项目配置 keil配置烧录方式注意代码规范头文件配置 模块ledcubemx配置keil代码实现点亮一只灯实现具体操作的灯&#xff0c;以及点亮还是熄灭 按键cubemx配置k…
阅读更多...
Blender多摄像机怎么指定相机渲染图像

Blender多摄像机怎么指定相机渲染图像

如题目所说&#xff0c;当blender的场景里面有摄像机的时候&#xff0c;按F12可以预览渲染结果&#xff0c;但是当有多个摄像机的时候就不知道使用哪个进行渲染了。 之前在网上没有找到方法&#xff0c;就用笨方法&#xff0c;把所有的摄像机删除&#xff0c;然后设置自己需要…
阅读更多...
从 MySQL 到时序数据库 TDengine：Zendure 如何实现高效储能数据管理？

从 MySQL 到时序数据库 TDengine：Zendure 如何实现高效储能数据管理？

小T导读&#xff1a;TDengine 助力广州疆海科技有限公司高效完成储能业务的数据分析任务&#xff0c;轻松应对海量功率、电能及输入输出数据的实时统计与分析&#xff0c;并以接近 1 : 20 的数据文件压缩率大幅降低存储成本。此外&#xff0c;taosX 强大的 transform 功能帮助用…
阅读更多...
观察者模式：解耦对象间的依赖关系

观察者模式：解耦对象间的依赖关系

观察者模式&#xff1a;解耦对象间的依赖关系 JDK 中曾直接提供对观察者模式的支持&#xff0c;但因其设计局限性&#xff0c;现已被标记为“过时”&#xff08;Deprecated&#xff09;。不过&#xff0c;观察者模式的思想在 JDK 的事件处理、spring框架等仍有广泛应用。下面我…
阅读更多...
windows第二十章 单文档应用程序

windows第二十章 单文档应用程序

文章目录 单文档定义新建一个单文档应用程序单文档应用程序组成&#xff1a;APP应用程序类框架类&#xff08;窗口类&#xff09;视图类&#xff08;窗口类&#xff0c;属于框架的子窗口&#xff09;文档类&#xff08;对数据进行保存读取操作&#xff09; 直接用向导创建单文档…
阅读更多...
通信协议之串口

通信协议之串口

文章目录 简介电平标准串口参数及时序USART与UART过程引脚配置 简介 点对点&#xff0c;只能两设备通信只需单向的数据传输时&#xff0c;可以只接一根通信线当电平标准不一致时&#xff0c;需要加电平转换芯片&#xff08;一般从控制器出来的是信号是TTL电平&#xff09;地位…
阅读更多...
Java入门知识总结——章节（二）

Java入门知识总结——章节（二）

ps&#xff1a;本章主要讲数组、二维数组、变量 一、数组 数组是一个数据容器&#xff0c;可用来存储一批同类型的数据 &#x1f511;&#xff1a;注意 类也可以是一个类的数组 public class Main {public static class Student {String name;int age; // 移除 unsignedint…
阅读更多...
Verilog 中寄存器类型（reg）与线网类型（wire）的区别

Verilog 中寄存器类型（reg）与线网类型（wire）的区别

目录 一、前言 二、基本概念与分类 1.寄存器类型 2.线网类型 三、六大核心区别对比 四、使用场景深度解析 1.寄存器类型的典型应用 2. 线网类型的典型应用 五、常见误区与注意事项 1. 寄存器≠物理寄存器 2.未初始化值陷阱 3.SystemVerilog的改进 六、总结 …
阅读更多...
【Linux加餐-验证UDP:TCP】-windows作为client访问Linux

【Linux加餐-验证UDP:TCP】-windows作为client访问Linux

一、验证UDP-windows作为client访问Linux UDP client样例代码 #include <iostream> #include <cstdio> #include <thread> #include <string> #include <cstdlib> #include <WinSock2.h> #include <Windows.h>#pragma warning(dis…
阅读更多...
Rust vs. Go: 性能测试(2025)

Rust vs. Go: 性能测试(2025)

本内容是对知名性能评测博主 Anton Putra Rust vs. Go (Golang): Performance 2025 内容的翻译与整理, 有适当删减, 相关数据和结论以原作结论为准。 再次对比 Rust 和 Go&#xff0c;但这次我们使用的是最具性能优势的 HTTP 服务器库---Hyper&#xff0c;它基于 Tokio 异步运…
阅读更多...
JDBC的详细使用

JDBC的详细使用

1. JDBC概述 JDBC[Java Database Connectivity]是 Java 语言中用于连接和操作数据库的一套标准 API。它允许 Java 程序通过统一的方式与各种关系型数据库&#xff0c;如 MySQL、Oracle、SQL Server 等交互&#xff0c;执行 SQL 语句并处理结果。 1.1 JDBC原理 JDBC的核心原理…
阅读更多...
瑞芯微 RKrga接口 wrapbuffer_virtualaddr 使用笔记

瑞芯微 RKrga接口 wrapbuffer_virtualaddr 使用笔记

一、源码 官方在librga中给了很多 demo 以供参考&#xff0c;例如 imresize 操作&#xff1a; /** Copyright (C) 2022 Rockchip Electronics Co., Ltd.* Authors:* YuQiaowei <cerf.yurock-chips.com>** Licensed under the Apache License, Version 2.0 (the &qu…
阅读更多...
【数据结构】[特殊字符] 并查集优化全解：从链式退化到近O(1)的性能飞跃 | 路径压缩与合并策略深度实战

【数据结构】[特殊字符] 并查集优化全解：从链式退化到近O(1)的性能飞跃 | 路径压缩与合并策略深度实战

并查集的优化 导读一、合并优化1.1 基本原理1.2 按大小合并1.3 按秩合并1.4 两种合并的区别**1.4.1 核心目标****1.4.2 数据存储****1.4.3 合并逻辑****1.4.4 树高控制****1.4.5 适用场景****1.4.6 路径压缩兼容性****1.4.7 极端案例对比****1.4.8 小结**二、查找优化2.1 路径压…
阅读更多...
如何在 AI 搜索引擎（GEO）霸屏曝光，快速提升知名度？

如何在 AI 搜索引擎（GEO）霸屏曝光，快速提升知名度？

虽然大多数人仍然使用 Google 来寻找答案&#xff0c;但正在发生快速转变。ChatGPT、Copilot、Perplexity 和 DeepSeek 等 LLM 已成为主流。这主要是因为每个都有自己的免费和公共版本&#xff0c;并且总是有重大的质量改进。 许多人每天都使用这些工具来提问和搜索互联网&…
阅读更多...
VLAN综合实验二

VLAN综合实验二

一.实验拓扑&#xff1a; 二.实验需求&#xff1a; 1.内网Ip地址使用172.16.0.0/分配 2.sw1和SW2之间互为备份 3.VRRP/STP/VLAN/Eth-trunk均使用 4.所有Pc均通过DHCP获取IP地址 5.ISP只能配置IP地址 6.所有…
阅读更多...
Kubernetes》k8s》Containerd 、ctr 、cri、crictl

Kubernetes》k8s》Containerd 、ctr 、cri、crictl

containerd ctr crictl ctr 是 containerd 的一个客户端工具。 crictl 是 CRI 兼容的容器运行时命令行接口&#xff0c;可以使用它来检查和调试 k8s 节点上的容器运行时和应用程序。 ctr -v 输出的是 containerd 的版本&#xff0c; crictl -v 输出的是当前 k8s 的版本&#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023