《C++》解密--单链表

《C++》解密--单链表

news2024/9/30 14:40:00

目录

一、概念与结构

二、实现单链表

三、链表的分类

四、单链表算法题

一、概念与结构

1、节点

结点的组成主要有：当前结点要保存的数据和保存下一个节点的地址（指针变量）

图中指针变量plist保存的是第一个结点的地址，我们称plist此时“指向”第一个结点。

链表中每个结点都是独立申请的（如果需要插入数据时才去申请一块结点的空间），我们需要通过指针变量来保存下一个结点位置才能从当前结点找到下一个结点。

2、链表的性质

【链表机构在逻辑上是连续的，在物理结构上不一定连续。

【结点一般是从堆上申请的。

【从堆上申请来的空间，是按照一定策略分配出来的，每次申请的空间可能连续，可能不连续。

二、实现单链表

1、创立文件

2、定义链表的结构

【SList.h】

//定义链表(结点)的位置
typedef int SLTDataType;
typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

void SLTPrint(SLTNode* phead);

3、打印函数

【SList.h】

//打印函数
void SLTPrint(SLTNode* phead);

【SList.c】

//打印函数
void SLTPrint(SLTNode* phead)
{
	SLTNode* pcur = phead;
	while (pcur)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}

【test.c】

//创建一个链表，并且打印链表
void createSList()
{
	SLTNode* node1 = (SLTNode*)malloc(sizeof(SLTNode));
	node1->data = 1;

	SLTNode* node2 = (SLTNode*)malloc(sizeof(SLTNode));
	node1->data = 2;

	SLTNode* node3 = (SLTNode*)malloc(sizeof(SLTNode));
	node1->data = 3;

	SLTNode* node4 = (SLTNode*)malloc(sizeof(SLTNode));
	node1->data = 4;

	node1->next = node2;
	node2->next = node3;
	node3->next = node4;
	node4->next = NULL;

	//第一个结点的地址作为参数传递过去
	SLTNode* plist = node1;
	SLTPrint(node1);
}

4、判断插入时，空间是否足够

【SList.c】

//判断插入数据时，空间是否足够
SLTNode* SLTBuyNode(SLTDataType x)
{
	SLTNode* node = (SLTNode*)malloc(sizeof(SLTNode));
	if (node == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	node->data = x;
	node->next = NULL;

	return node;
}

5、尾插

【SList.h】

//尾插
void SLTPushBack(SLTNode** pphead,SLTDataType x);

【SList.c】

//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	//形参：pphead --> 实参：&plist
	//*pphead 解引用 --> plist
	//申请新结点

	SLTNode* newnode = SLTBuyNode(x); //判断是否有足够空间

	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//尾节点 --> 新结点
		//找尾节点
		SLTNode* ptail = *pphead;
		while (ptail->next)
		{
			ptail = ptail->next;
		}
	//ptail --> newnode
		ptail->next = newnode;
	}
}

【test.c】

void SListTest01()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPrint(plist);  //1->NULL
	SLTPushBack(&plist, 2);
	SLTPrint(plist);  //1->2->NULL
	SLTPushBack(&plist, 3);
	SLTPrint(plist);  //1->2->3->NULL
	SLTPushBack(&plist, 4);
	SLTPrint(plist);  //1->2->3->4->NULL
}

【运行结果】

6、头插

【SList.h】

//头插
void SLTPushFront(SLTNode** pphead,SLTDataType x);

【SList.c】

//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTBuyNode(x); //判断是否有足够空间

	//newnode *pphead
	newnode->next = *pphead;
	*pphead = newnode;
}

【test.c】

void SListTest01()
{
	SLTNode* plist = NULL;

	//头插
	SLTPushFront(&plist, 1);
	SLTPushFront(&plist, 2);
	SLTPushFront(&plist, 3);
	SLTPushFront(&plist, 4);
	SLTPrint(plist);   //4->3->2->1->NULL
}

【运行结果】

7、尾删

【SList.h】

//尾删
void SLTPopBack(SLTNode** pphead);

【SList.c】

//尾删
void SLTPopBack(SLTNode** pphead)
{
	//判断链表是不是空，若为空则不可以删
	assert(pphead && *pphead);

	//处理只有一个结点的情况：要删除的就是头结点（当next指针为空）
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		//找尾结点ptail 和尾结点的前一个结点prev
		SLTNode* ptail = *pphead;
		SLTNode* prev = NULL;
		//遍历数组,找尾结点
		while (ptail->next)
		{
			prev = ptail;
			ptail = ptail->next;
		}
		prev->next = NULL;
		free(ptail);
		ptail = NULL;
	}
}

【test.c】

void SListTest01()
{
	SLTNode* plist = NULL;

	//头插
	SLTPushFront(&plist, 1);
	SLTPushFront(&plist, 2);
	SLTPushFront(&plist, 3);
	SLTPushFront(&plist, 4);


	//尾删
	SLTPopBack(&plist);
	SLTPrint(plist);  //4->3->2->NULL
	SLTPopBack(&plist);
	SLTPrint(plist);  //4->3->NULL
	SLTPopBack(&plist);
	SLTPrint(plist);  //4->NULL
	SLTPopBack(&plist);
	SLTPrint(plist);  //NULL
}

【运行结果】

8、头删

【SList.h】

//头删
void SLTPopFront(SLTNode** pphead);

【SList.c】

//头删
void SLTPopFront(SLTNode** pphead)
{
	assert(pphead && *pphead);
	SLTNode* next = (*pphead)->next;
	//删除*pphead --> next
	free(*pphead);
	*pphead = next;
}

【test.c】

void SListTest01()
{
	SLTNode* plist = NULL;

	//头插
	SLTPushFront(&plist, 1);
	SLTPushFront(&plist, 2);
	SLTPushFront(&plist, 3);
	SLTPushFront(&plist, 4);
	//SLTPrint(plist);   //4->3->2->1->NULL


	//头删
	SLTPopFront(&plist);
	SLTPrint(plist);  //3->2->1->NULL
	SLTPopFront(&plist);
	SLTPrint(plist);  //2->1->NULL
	SLTPopFront(&plist);
	SLTPrint(plist);  //1->NULL
	SLTPopFront(&plist);
	SLTPrint(plist);  //NULL
}

【运行结果】

9、查找

【SList.h】

//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);

【SList.c】

//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	assert(phead);
	SLTNode* pcur = phead;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	//跳出循环，说明没找到
	return NULL;
}

【test.c】

void SListTest01()
{
	SLTNode* plist = NULL;

	//头插
	SLTPushFront(&plist, 1);
	SLTPushFront(&plist, 2);
	SLTPushFront(&plist, 3);
	SLTPushFront(&plist, 4);
	//SLTPrint(plist);   //4->3->2->1->NULL


	//查找
	SLTNode* find = SLTFind(plist, 3);
	if (find == NULL)
	{
		printf("没找到！\n");
	}
	else
	{
		printf("find it!\n");
	}
}

【运行结果】

10、在指定位置之前插入数据

【SList.h】

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

【SList.c】

//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);

	//如果pos恰好是头结点
	if (pos == *pphead)
	{
		SLTPushFront(pphead, x); //相当于头插
	}
	else
	{
		SLTNode* newnode = SLTBuyNode(x);
		//找到pos的前一个结点:prev
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		//跳出这个循环，说明prev的前一个结点就是pos
		//将newnode插入prev和pos之间
		newnode->next = pos;
		prev->next = newnode;
	}
}

【test.c】

void SListTest01()
{
	SLTNode* plist = NULL;

	//头插
	SLTPushFront(&plist, 1);
	SLTPushFront(&plist, 2);
	SLTPushFront(&plist, 3);
	SLTPushFront(&plist, 4);
	SLTPrint(plist);   //4->3->2->1->NULL


	//查找
	SLTNode* find = SLTFind(plist, 2);


	//在指定位置之前插入数据
	SLTInsert(&plist, find, 11); //在2之前插入11
	SLTPrint(plist);   //4->3->11->2->1->NULL
}

【运行结果】

11、在指定位置之后插入数据

【SList.h】

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

【SList.c】

//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = SLTBuyNode(x);
	//把newnode放到pos的下一个位置（pos->next）
	newnode->next = pos->next;
	pos->next = newnode;
}

【test.c】

void SListTest01()
{
	SLTNode* plist = NULL;

	//头插
	SLTPushFront(&plist, 1);
	SLTPushFront(&plist, 2);
	SLTPushFront(&plist, 3);
	SLTPushFront(&plist, 4);
	SLTPrint(plist);   //4->3->2->1->NULL

	//查找
	SLTNode* find = SLTFind(plist, 2);
	

	//在指定位置之后插入数据
	SLTInsertAfter(find, 9);  //在2之后插入9
	SLTPrint(plist);  //4->3->2->9->1->NULL
}

【运行结果】

12、删除pos结点

【SList.h】

//删除pos结点
void SLTErase(SLTNode** pphead, SLTNode* pos);

【SList.c】

//删除pos结点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pos);
	assert(pphead && *pphead);

	//头插（如果pos恰好为头结点*pphead,那就没有前一个结点prev了）
	if (pos == *pphead)
	{
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{ //遍历数组，寻找pos
			prev = prev->next;
		}
	 //跳出循环，prev刚好是pos的前一个结点(要删除pos)
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}

}

【test.c】

void SListTest01()
{
	SLTNode* plist = NULL;

	//头插
	SLTPushFront(&plist, 1);
	SLTPushFront(&plist, 2);
	SLTPushFront(&plist, 3);
	SLTPushFront(&plist, 4);
	SLTPrint(plist);   //4->3->2->1->NULL

	//查找
	SLTNode* find = SLTFind(plist, 2);
	
	//删除pos结点
	SLTErase(&plist, find);  //删除pos(2)这个结点
	SLTPrint(plist);  //4->3->1->NULL
}

【运行结果】

13、删除pos之后的结点

【SList.h】

//删除pos之后的结点
void SLTEraseAfter(SLTNode* pos);

【SList.c】

//删除pos之后的结点
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);

	//删除pos的下一个结点，就要让pos的下一个结点直接指向pos的next的next
	//但是后面要把pos->next释放删除掉，所以先把这个指针保存起来
	SLTNode* del = pos->next;
	pos->next = pos->next->next;
	free(del);
	del = NULL;
}

【test.c】

void SListTest01()
{
	SLTNode* plist = NULL;

	//头插
	SLTPushFront(&plist, 1);
	SLTPushFront(&plist, 2);
	SLTPushFront(&plist, 3);
	SLTPushFront(&plist, 4);
	SLTPrint(plist);   //4->3->2->1->NULL

	//查找
	SLTNode* find = SLTFind(plist, 2);
	
	//删除pos之后的结点
	SLTEraseAfter(find);
	SLTPrint(plist);  //4->3->2->NULL
}

【运行结果】

14、销毁链表

【SList.h】

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

【SList.c】

//销毁链表
void SListDestroy(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}

【test.c】

void SListTest01()
{
	SLTNode* plist = NULL;

	//头插
	SLTPushFront(&plist, 1);
	SLTPushFront(&plist, 2);
	SLTPushFront(&plist, 3);
	SLTPushFront(&plist, 4);
	SLTPrint(plist);   //4->3->2->1->NULL

	//查找
	SLTNode* find = SLTFind(plist, 2);
	
	//销毁链表
    SListDestroy(&plist);
    SLTPrint(plist);  //NULL
}

【运行结果】

三、链表的分类

四、单链表算法题

1、反转链表

【思路】

【代码】

typedef struct ListNode ListNode;
struct ListNode* reverseList(struct ListNode* head)
{
    //处理空链表
    if(head == NULL)
    {
        return head;
    }
    //创建三个指针
 ListNode* n1,*n2,*n3;
 n1 = NULL , n2 = head , n3 = n2->next;   
 while(n2)
 {
  n2->next = n1;
  n1 = n2;
  n2 = n3;
  if(n3)
  {
    n3 = n3->next;
  }
 }
 //此时n1就是链表反转后新的头结点head
 return n1;
}

2、链表的中间结点

【思路】

【代码】

typedef struct ListNode ListNode;
struct ListNode* middleNode(struct ListNode* head) 
 {
    ListNode* slow = head,*fast = head;
  //慢指针每次走一步
  //快指针每次走两步
  while(fast && fast->next)  //等价于fast!=NULL && fast->next!=NULL
//当fast或fast->fast任何一个为空指针（为假）时，就跳出循环
  {
    slow = slow->next;
    fast = fast->next->next;
  }
    //此时slow指向得节点刚好就是中间节点
    return slow;
 }

3、合并两个有序链表

【思路】

【代码】

typedef struct ListNode ListNode;
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) 
{
  //处理链表为空的情况
  if(list1 == NULL)
  {
    return list2;
  }
  if(list2 == NULL)
  {
    return list1;
  }

  //创建新链表
  ListNode*newHead = NULL,*newTail = NULL;
  //创建两个指针分别指向两个链表的头结点
  ListNode* l1 = list1;
  ListNode* l2 = list2;

  //比大小
  while(l1 && l2)
  {
     if(l1->val < l2->val)
     {
       //l1尾插到新链表中
       if(newHead == NULL)
       {
        newHead = newTail = l1;
       }
       else
       {
        newTail->next = l1;
        newTail = newTail->next;
       }
       l1 = l1->next;
     }
     else
     {
         //l2尾插到新链表
         if(newHead == NULL)
       {
        newHead = newTail = l2;
       }
       else
       {
        newTail->next = l2;
        newTail = newTail->next;
       }
         l2 = l2->next;
     }
  }
  //跳出while循环，只有两种情况：l1为空（l2肯定不为空） 或 l2为空（l1不为）
  if(l1)  //l1不为空
  {
    newTail->next = l1;
  }
  if(l2)  //l2不为空
  {
    newTail->next = l2;
  }
  return newHead;
}

4、链表分割

【思路】

【代码】

class Partition 
{
public:
    ListNode* partition(ListNode* pHead, int x) 
    { 
        //创建两个非空链表：小链表、大链表
        //小链表
        ListNode* lessHead,*lessTail;
        lessHead = lessTail = (ListNode*)malloc(sizeof(ListNode));
        //大链表 
        ListNode* greaterHead,*greaterTail;
        greaterHead = greaterTail = (ListNode*)malloc(sizeof(ListNode));

        //遍历原链表，与x比较大小
        // >=x的尾插进入大链表 ， <x的尾插进入小链表
        ListNode* pcur = pHead;
        while(pcur)  //等价于pcur != NULL
        {
            if(pcur->val < x)
            { //尾插到小链表
               lessTail->next = pcur;
               lessTail = lessTail->next;
            }
            else 
            { //尾插到大链表
              greaterTail->next = pcur;
              greaterTail = greaterTail->next;
            }
            pcur = pcur->next;
        }
        //将大链表的尾结点的next置为空
         greaterTail->next = NULL;

         //让大小链表首尾相连
         lessTail->next = greaterHead->next;
         ListNode* ret = lessHead->next;
         free(lessHead);
         free(greaterHead);
         lessHead = greaterHead = NULL;
         return ret;
    }
};

5、链表的回文结构

【代码】

class PalindromeList 
{
public:
ListNode* findMidNode(ListNode* phead)
{//使用快慢指针，寻找中间结点
    ListNode* slow = phead;
    ListNode* fast = phead;
    while(fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;
}

ListNode* reverseList(ListNode* phead)
{
    //链表反转
    ListNode* n1,*n2,*n3;
    n1 = NULL;
    n2 = phead;
    n3 = n2->next;
    while(n2)
    {
        n2->next = n1;
        n1 = n2;
        n2 = n3;
        if(n3)
        {
            n3 = n3->next;
        }
    }
    return n1;
}

    bool chkPalindrome(ListNode* A) 
    {
        //1、找中间结点
        ListNode* mid = findMidNode(A);

        //2、根据中间结点，将中间结点后的链表反转
        ListNode* right = reverseList(mid);

        //3、从原链表的头和反转链表比较结点值 (开始时，left指头，right指尾)
        ListNode* left = A;
        while(right)
        {
            if(left->val != right->val)
            {
                return false;
            }
            left = left->next;
            right = right->next;
        }
        return true;
    }
};

未完待续...

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

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

相关文章

红日靶机(二)笔记

红日靶机(二)笔记

红日靶机二环境搭建只需要把虚拟机的 host-only（仅主机）网卡改为 10.10.10.0 网段，如下配置把 NAT 网卡，改为 192.168.96.0 网段，如下首先恢复到 v1.3 快照让后点击放弃，放弃后再开机，用…

阅读更多...

论文写作工具推荐小渡ai，MedSci，Open Access Library

论文写作工具推荐小渡ai，MedSci，Open Access Library

1、知网作为写过论文或者即将要写论文的人，这个网站真的真的真的是你用的最多最多的网站。但是你一定不用自己充会员，因为你的学校肯定给你买了这个资料库，从学校图书馆的网页进去就行，或者你校外访问，就算是没有账号不…

阅读更多...

【自动驾驶】控制算法（十一）深度解析车辆纵向控制 | 纵向双 PID 控制算法

【自动驾驶】控制算法（十一）深度解析车辆纵向控制 | 纵向双 PID 控制算法

写在前面： 🌟 欢迎光临清流君的博客小天地，这里是我分享技术与心得的温馨角落。📝 个人主页：清流君_CSDN博客，期待与您一同探索移动机器人领域的无限可能。 🔍 本文系清流君原创之作&…

阅读更多...

心觉：如何重塑高效学习的潜意识（5）终结篇

心觉：如何重塑高效学习的潜意识（5）终结篇

Hi，我是心觉，与你一起玩转潜意识、脑波音乐和吸引力法则，轻松掌控自己的人生！ 挑战每日一省写作184/1000天上篇文章讲了如何发挥边学边用的威力及其底层逻辑到此为止，我们已经系统地把“系统化学习”和“边学边用…

阅读更多...

scrapy 爬取微博(五)【最新超详细解析】: 爬取微博文章

scrapy 爬取微博(五)【最新超详细解析】: 爬取微博文章

1 读取配置参数爬取微博文章首先需要读取settings.py中的设置的配置变量，然后编写爬虫，读取的配置变量主要有爬取的关键词、时间范围、爬取区域等。 class WeiboSearchSpider(scrapy.Spider):name weibo_searchallowed_domains [weibo.com]settings…

阅读更多...

【北京迅为】《STM32MP157开发板嵌入式开发指南》- 第十五章 Linux 文件系统概念

【北京迅为】《STM32MP157开发板嵌入式开发指南》- 第十五章 Linux 文件系统概念

iTOP-STM32MP157开发板采用ST推出的双核cortex-A7单核cortex-M4异构处理器，既可用Linux、又可以用于STM32单片机开发。开发板采用核心板底板结构，主频650M、1G内存、8G存储，核心板采用工业级板对板连接器，高可靠，牢固耐…

阅读更多...

Navicat 工具下载安装

Navicat 工具下载安装

准备工作下载下载链接：http://localhost:8080 演示环境操作系统：windows10 产品：Navicat 版本： 15.0.25 注意：如果需要其他版本可以自行下载。安装步骤 1、解压（如果解压中出现提示威胁要允许&#…

阅读更多...

基于CNN+Transformer混合模型实现交通流量时序预测(PyTorch版)

基于CNN+Transformer混合模型实现交通流量时序预测(PyTorch版)

前言系列专栏:【深度学习：算法项目实战】✨︎ 涉及医疗健康、财经金融、商业零售、食品饮料、运动健身、交通运输、环境科学、社交媒体以及文本和图像处理等诸多领域，讨论了各种复杂的深度神经网络思想，如卷积神经网络、循环神经网络、生成对…

阅读更多...

PHP程序如何实现限制一台电脑登录？

PHP程序如何实现限制一台电脑登录？

PHP程序如何实现限制一台电脑登录？ 可以使用以下几种方法： 1. IP地址限制：在PHP中，可以通过获取客户端的IP地址，然后与允许登录的IP地址列表进行比对。如果客户端的IP地址不在列表中，就禁止登录。 “php $…

阅读更多...

洛谷P1789MC生存插火把

洛谷P1789MC生存插火把

洛谷P1789MC生存插火把这道题有一个小坑，就是火把照亮的地方可能不在数组里，注意要把那一块地方去掉，这道题的出题者把范围都告诉我们了，大大滴降低了这道题的难度下面是我的代码 #include <stdio.h>int n, m,k ;//一…

阅读更多...

HarmonyOS Next系列之水波纹动画特效实现（十三）

HarmonyOS Next系列之水波纹动画特效实现（十三）

系列文章目录 HarmonyOS Next 系列之省市区弹窗选择器实现（一） HarmonyOS Next 系列之验证码输入组件实现（二） HarmonyOS Next 系列之底部标签栏TabBar实现（三） HarmonyOS Next 系列之HTTP请求封装和Token…

阅读更多...

基于ssm+vue的在线家用电器销售系统

基于ssm+vue的在线家用电器销售系统

摘要本文介绍了一个基于SSM（SpringSpring MVCMyBatis）框架与Vue.js技术的在线家用电器销售系统。该系统旨在为用户提供便捷的家用电器购买体验，同时为商家提供一个高效的销售管理平台。系统前端采用Vue.js框架开发，实现了响应式布…

阅读更多...

【制作自解压程序】使用7Z制作自解压程序

【制作自解压程序】使用7Z制作自解压程序

文章目录 1.前言2.准备压缩包3.准备7zSD.sfx文件4.准备config.txt5.合并文件6.完成 1.前言自解压程序是利用压缩包制作一个类似于下载程序样式的文件，可以让用户直接点击使用，而不是解压以后去文件中找哪个是启动程序。 2.准备压缩包首先&#xff0…

阅读更多...

【U8+】安装用友U8+16.5后，应用服务管理中缺少加密服务。

【U8+】安装用友U8+16.5后，应用服务管理中缺少加密服务。

【问题描述】安装用友U8+后，应用服务管理中，没有加密服务。导致软件无法登录到加密服务器。【解决方法】此问题多为CPU所影响： 1、深信服和霆智虚拟机需要开启HOST CPU选项。不开启此选项无法发挥CPU的全部功能，对U8和SQL Server的性能影响很大，所以在U8V16.5中要求开…

阅读更多...

SOMEIP_ETS_142: SD_Request_non_existing_Major_Version

SOMEIP_ETS_142: SD_Request_non_existing_Major_Version

测试目的： 验证DUT能够拒绝一个请求不存在的主版本号的SubscribeEventgroup消息，并以SubscribeEventgroupNAck作为响应。描述本测试用例旨在确保DUT遵循SOME/IP协议，当接收到一个请求不存在主版本号的SubscribeEventgroup消息时&#xf…

阅读更多...

828华为云征文｜部署个人文档管理系统 Docspell

828华为云征文｜部署个人文档管理系统 Docspell

828华为云征文｜部署个人文档管理系统 Docspell 一、Flexus云服务器X实例介绍二、Flexus云服务器X实例配置2.1 重置密码2.2 服务器连接2.3 安全组配置2.4 Docker 环境搭建三、Flexus云服务器X实例部署 Docspell3.1 Docspell 介绍3.2 Docspell 部署3.3 Docspell 使用…

阅读更多...

PostgreSQL的学习心得和知识总结（一百五十二）|transaction_timeout：达到事务超时时终止会话

PostgreSQL的学习心得和知识总结（一百五十二）|transaction_timeout：达到事务超时时终止会话

目录结构注：提前言明本文借鉴了以下博主、书籍或网站的内容，其列表如下： 1、参考书籍：《PostgreSQL数据库内核分析》 2、参考书籍：《数据库事务处理的艺术：事务管理与并发控制》 3、PostgreSQL数据库仓库…

阅读更多...

影刀---如何进行自动化操作

影刀---如何进行自动化操作

本文不是广告，没有人给我宣传费，只是单纯的觉得这个软件很好用感谢大家的多多支持哦本文 1.基本概念与操作（非标准下拉框和上传下载）非标准对话框的操作上传对话框、下载的对话框、提示的对话框 2.综合案例3.找不到元素怎么办&a…

阅读更多...

从AR眼镜到智能巡检：XR技术的演变与未来潜力

从AR眼镜到智能巡检：XR技术的演变与未来潜力

XR，即扩展现实（Extended Reality），是一个涵盖了增强现实（AR）、虚拟现实（VR）和混合现实（MR）的广泛概念。从我们最初接触到的手机应用到Hololens，…

阅读更多...

（作业）第三期书生·浦语大模型实战营（十一卷王场）--书生入门岛通关第1关Linux 基础知识

（作业）第三期书生·浦语大模型实战营（十一卷王场）--书生入门岛通关第1关Linux 基础知识

关卡任务闯关任务需要在关键步骤中截图： 任务描述完成所需时间闯关任务完成SSH连接与端口映射并运行hello_world.py 10min 可选任务 1 将Linux基础命令在开发机上完成一遍 10min 可选任务 2 使用 VSCODE 远程连接开发机并创建一个conda环境 10min 可选任务 3 创…

阅读更多...

推荐文章

最新文章