数据结构四：线性表之带头结点的单向循环循环链表的设计

news2024/11/21 2:37:14

          前面两篇介绍了线性表的顺序和链式存储结构，其中链式存储结构为单向链表（即一个方向的有限长度、不循环的链表），对于单链表，由于每个节点只存储了向后的结点的地址，到了尾巴结点就停止了向后链的操作。也就是说只能向后走，如果走过了，就回不去了，还得重头开始遍历，所以就衍生出了循环链表。

目录

一、循环链表的产生原因

二、循环链表的基本概念和结构

三、循环与非循环的对比

3.1 特点

3.2 优势

3.3 修改

四、带头结点的单向循环链表的接口函数实现

4.1  单链表结点设计（结构体）

4.2  单循环链表的初始化

4.3 头插 

4.4 尾插

4.5 按位置插入

4.6 头删

4.7 尾删

4.8 按位置删除

4.9 按值删

4.10 查找

4.11 获取有效值个数

4.12 判空

4.13 销毁

4.14 打印

五、总结

一、循环链表的产生原因

       在之前学习单链表的时候，我们使用头结点来代表一个链表，可以用O(1)的时间复杂度便可以访问到第一个节点，但是在访问尾巴节点时，需要通过从头开始向后遍历，因此它的时间复杂度为O(n)，而循环链表则不同，完全可以使用O(1)的时间来访问第一个节点和尾节点。

        相比单链表，循环链表解决了一个很麻烦的问题。 即可以从任意一个结点出发，而不一定是要从头结点出发，就可访问到链表的全部结点，并且访问尾巴结点的时间复杂度也可以达到O(1)。

二、循环链表的基本概念和结构

       循环单链表是首尾相连的一种单链表，即将最后一个结点的空指针改为指向头结点形成一个环型。判断单链表为空的条件是 plist->next == NULL，而判断循环单链表为空的条件是 plist->next==plist。

         从上图可以看出，带头结点的循环链表与单链表的区别在于：最后一个有效结点的指针域指向头结点（保存头结点的地址), 通过这样的一种方式，使得链表构成一个闭环结构，在单链表中，从一已知结点出发，只能访问到该结点及其后续结点，无法找到该结点之前的其它结点。而在单循环链表中，从任一结点出发都可访问到表中所有结点，这是它的一大优点，遍历尾巴结点的时间复杂度也可以达到O(1)。

       上图是带头结点的单向循环链表为空的情况下的结构，即它不存在有效结点，此时，为了保证它是一个循环结构，头结点的指针域指向它自己（即头结点的指针域保存头结点的地址） ，这也是判断带头结点的单向循环链表为空的一个依据即：plist->next==plist。

三、循环与非循环的对比

3.1 特点

  • 若链表为空，则头结点的next结点还是指向其本身，即plist->next==plist；
  • 尾节点的next指针指向plist结点，即头尾相连；
  • 判断是否遍历了完，直接判断p->next==plist即可；
  • 由单链表变化的循环也成为单向循环链表；
  • 循环链表的特点是无须增加存储量，仅对表的链接方式稍作改变，即可使得表处理更加方便灵活；

3.2 优势

       对单向链表中任一个节点的访问都需要从头结点开始；而对单向循环链表从任意节点出发都能遍历整个列表，极大的增强了其灵活性。其实循环链表和单链表的主要差异就在于循环的判断条件上，原本是判断 p->next 是否为空，现在则是 p-> next 不等于头结点，则循环未结束。

3.3 修改

  • 判断是否为空：
    单向链表：如果头结点指向空，那么为空链表（头结点的指针域为NULL）
    单向循环链表：如果头结点指向自身，那么为空链表（头结点的指针域为自身）

  • 判断是否为尾结点
    单向链表：指向空的节点为尾结点（尾结点的指针域为NULL）
    单向循环链表：指向头结点的节点为尾结点（尾结点的指针域为头结点）

四、带头结点的单向循环链表的接口函数实现

      单循环链表的基本操作也同样有：初始化，头插，尾插，按位置插，头删，尾删，按位置删，查找，按值删，获取有效值个数，判空，清空，销毁，打印。这里详细展示这些基本操作的实现思想和画图分析以及代码实现和算法效率分析，

      注意：同样单循环链表与顺序表不同，由于它是按需索取，因此，不需要进行判满和扩容操作；

//引入必要的头文件
#include "SeqList.h"
#include<assert.h>
#include<stdlib.h>
 

//初始化
void Init_circlelist(struct CNode *cls);

//头插
void Insert_head(struct CNode* cls, ELEM_TYPE val);

//尾插
void Insert_tail(struct CNode* cls, ELEM_TYPE val);

//按位置插
void Insert_pos(struct CNode* cls, ELEM_TYPE val, int pos);

//头删
void Del_head(struct CNode* cls);

//尾删
void Del_tail(struct CNode *cls);

//按位置删
void Del_pos(struct CNode *cls, int pos);

//按值删
void Del_val(struct CNode *cls, ELEM_TYPE val);

//查找val值出现的第一次位置
struct CNode *Search(struct CNode *cls, ELEM_TYPE val);

//获取有效长度
int Get_length(struct CNode* cls);

//销毁1
void Destroy1(struct CNode *cls);

//销毁2
void Destroy2(struct CNode *cls);

//判空
bool IsEmpty(struct CNode *cls);

//打印
void Show(PCNode cls);

4.1  单链表结点设计（结构体）

      单循环链表结构体设计非常简单，和单链表有效节点结构体设计一样,只需要一个数据域和指针域。

      每个结点包括两个部分：存储数据的数据域和指针域（指向下一个结点/存储下一个结点地址的指针）构成。因此设计结点主要设计这两个成员变量。

       强调结构体自身引用（自己嵌套自己必须使用struct，即使使用typedef关键字进行重命名）结构体内部不可以定义自身的结构体变量，但是可以定义自身结构体指针变量，因为指针与类型无关，占用内存空间就是4个字节！

typedef int ELEM_TYPE;

//带头结点的单循环链表

//单循环链表结构体设计
typedef struct CNode
{
	ELEM_TYPE data;   //数据域   保存节点有效值
	struct CNode *next;//指针域  保存下一个有效节点的地址
}CNode, *PCNode;


//typedef struct CNode  CNode;
//typedef struct CNode* PCNode;

4.2  单循环链表的初始化

      单循环链表的初始化主要是对其指针域赋值，数据域不使用，不需要操作！并且此时头结点的指针域应该指向自身，而不是空！！！

//初始化
void Init_circlelist(struct CNode *cls)
{
	//头结点的数据域不使用，不用赋值
	cls->next = cls;    //初始化时，链表为空，头结点的指针域指向自身
}

4.3 头插 

循环和非循环单链表的头插法是一样的，不用修改代码。

头插的基本思路如下：

    第0步：assert对传入的指针检测；

    第1步：购买新节点（购买好节点之后，记得将val值赋值进去）；

    第2步：找到合适的插入位置；

    第3步：插入，注意核心代码，先牵右手，再牵左手！！！否则会发生内存泄漏。

 

//头插
void Insert_head(struct CNode* cls, ELEM_TYPE val)
{
	//0：assert对传入的指针检测
	assert(cls != NULL);
	//1.购买新节点
	struct CNode* pnewnode = (struct CNode*)malloc(sizeof(struct CNode));
	pnewnode->data = val;

	//2.找到合适的插入位置(头插，不需要找)
   //因为是头插函数  所以不需要特意的去合适的位置 直接向cls后面插即可
 

	//3.插入
分两步：先让新购买的节点也指向第一个有效节点，这时，头结点的指针域就可以指向新购买的节点了
	pnewnode->next = cls->next;
	cls->next = pnewnode;

}

4.4 尾插

   尾插的基本思路如下：

    第0步：assert对传入的指针检测；

    第1步：购买新节点（购买好节点之后，记得将val值赋值进去）；

    第2步：找到合适的插入位置，在这里就是找到最后一个有效结点，如何找？因为最后一个有效结点的指针域为头结点，只需要从头开始通过地址，遍历每一个结点，直到遇到最后一个节点，此时指针域指向头结点；与单链表相比，只是尾巴结点的判断条件发生变化。

    第3步：利用插入的通用代码！

 

//尾插
void Insert_tail(struct CNode* cls, ELEM_TYPE val)
{
	//0：assert对传入的指针检测
	assert(cls != NULL);
	//1.购买新节点
	struct CNode *pnewnode = (struct CNode*)malloc(sizeof(struct CNode));
	pnewnode->data = val;

	//2.找到合适的插入位置(用最后一个有效节点的next域和头结点的地址做判断)
	struct CNode * p = cls;
	for( ; p->next!=cls; p=p->next);  //退出循环时，此时p便指向最后一个有效结点（尾巴结点）
	
	//3.插入
	pnewnode->next = p->next;
	p->next = pnewnode;
}

4.5 按位置插入

 按位置插入的基本思路如下：

    第0步：assert对传入的指针和插入的位置检测；要插入的位置必须大于等于零且小于等于  链表总长度。

    第1步：购买新节点（购买好节点之后，记得将val值赋值进去）；

    第2步：找到合适的插入位置，在这里就是找到插入位置的前一个结点，如何找？用指针p指向(例如pos=2，则让临时指针p，从头结点开始向后走pos步)

    第3步：利用插入的通用代码！

 

//按位置插
void Insert_pos(struct CNode* cls, ELEM_TYPE val, int pos)
{
	
	//0：assert对传入的指针检测
	assert(cls != NULL);
	assert(pos>=0 && pos<=Get_length(cls));

	//1.购买新节点
	struct CNode *pnewnode = (struct CNode*)malloc(sizeof(struct CNode));
	pnewnode->data = val;

	//2.找到合适的插入位置(pos=几，则让p从头结点开始向后跑pos步)
	struct CNode *p = cls;
	for(int i=0; i<pos; i++)
	{
		p=p->next;
	}

	//3.插入
	pnewnode->next = p->next;
	p->next = pnewnode;


}

4.6 头删

       对于删除操作，则需要对链表进行判空操作！并且删除操作遵循基本同样的4个步骤，需要理解加记忆。删除操作的基本思路如下：

①:用指针q指向待删除节点；
②:用指针p指向待删除节点的前驱节点；(头删的话，这里p可以被plist代替)
③:跨越指向；
④:释放待删除节点。

//头删
void Del_head(struct CNode* cls)
{
	//0：assert对传入的指针检测
	assert(cls != NULL);
	//1.判空
	if(IsEmpty(cls))
	{
		return;
	}

	//2.用q指向待删除节点， 用p指向待删除节点的前一个节点
	struct CNode *q = cls->next;
	//p用cls代替即可

	//3.跨越指向+释放
	cls->next = q->next;
	free(q);
	q = NULL;
}

4.7 尾删

       尾删的基本思路还是那四个步骤，只是具体实现的方式不一样。与单链表相比，只是尾巴节点的判断条件发生变化。

 

//尾删
void Del_tail(struct CNode *cls)
{
	//0：assert对传入的指针检测
	assert(cls != NULL);
	//1.判空
	if(IsEmpty(cls))
	{
		return;
	}

	//2.用q指向待删除节点， 用p指向待删除节点的前一个节点
	struct CNode *q = cls;
	for(; q->next!=cls; p=p->next);

	struct CNode *p = cls;
	for(; p->next!=q; p=p->next);

	//3.跨越指向+释放
	p->next = q->next;
	free(q);
	q = NULL;
}

4.8 按位置删除

     根据位置删除结点，需要判断结点的合法性，这次的pos需要小于链表长度，基本思路还是那四个步骤，只是具体实现的方式不一样。

 

//按位置删
void Del_pos(struct CNode *cls, int pos)
{
	//0：assert对传入的指针检测
	assert(cls != NULL);
	//0.5  pos做合法性判断
	assert(pos>=0 && pos<=Get_length(cls)-1);

	//1.判空
	if(IsEmpty(cls))
	{
		return;
	}

	//2.用q指向待删除节点， 用p指向待删除节点的前一个节点
	struct CNode *q = cls;
	for(int i=0; i<=pos; i++)
	{
		q = q->next;
	}

	struct CNode *p = cls;
	for(int i=0; i<pos; i++)
	{
		p = p->next;
	}
	
	//3.跨越指向+释放
	p->next = q->next;
	free(q);
	q = NULL;

}

4.9 按值删

    按值删需要先找到数据域是该值的结点，然后将其删除，基本思路还是那四个步骤，只是具体实现的方式不一样。

//按值删
void Del_val(struct CNode *cls, ELEM_TYPE val)
{
	//0：assert对传入的指针检测
	assert(cls != NULL);

   //1.判空
	if(IsEmpty(cls))
	{
		return;
	}

    //调用函数找该值，返回对应的结点
	struct CNode* q = Search(cls, val);

	//进行判断是否存在该结点
	if(q == NULL)
	{
		return;
	}

	//2.找到合适位置,待删除结点的前一个结点
	struct CNode * p = cls;
	for(; p->next!=q; p=->next);

	//3.跨越指向+释放
	p->next = q->next;
	free(q);
	q = NULL;
}

4.10 查找

      按值查找，返回该值的结点，查找操作只需要定义一个临时结点类型指针变量，让它从第一个有效节点开始遍历，只要结点存在就往后遍历。这里的循环条件：p!=cls，意思是从第一个有效节点遍历到最后一个结点（只要结点存在，就往后走）,与单链表相比，只是尾巴节点的判断条件发生变化。

//查找val值出现的第一次位置
struct CNode *Search(struct CNode *cls, ELEM_TYPE val)
{
    //0：assert对传入的指针检测
	assert(cls != NULL);

   //1.从第一个有效节点开始向后遍历
	struct CNode *p = cls->next;
	for( ; p!=cls; p=p->next)
	{
		if(p->data == val)
		{
			return p;
		}
	}
	return NULL;
}

4.11 获取有效值个数

    只需要定义一个临时结点类型指针变量，让它从第一个有效节点开始遍历，只要没有到最后一个结点就往后遍历。 采用计数器思想，计数器加1，返回计数器变量即是有效结点个数。与单链表相比，只是尾巴节点的判断条件发生变化。

//获取有效长度
int Get_length(struct CNode* cls)
{
    //0：assert对传入的指针检测
	assert(cls != NULL);

    //1.从第一个有效节点开始向后遍历
	struct CNode *p = cls->next;
	int count = 0;

	for( ; p!=cls; p=p->next)
	{
		count++;
	}

	return count;
}

4.12 判空

     在进行删除操作时，需要对链表进行判空操作，如果链表为空，则无法删除！！如何判断链表为空？在链表只有一个头结点时，代表链表为空，此时就是最初始的状态，只有一个头结点，并且头结点的指针域为它自己（指向它自己），因此，只需要判断头结点的指针域是否为自身，便可以知道链表是否为空。与单链表相比，只是空链表的判断条件发生变化。


//判空
bool IsEmpty(struct CNode *cls)
{
     //0：assert对传入的指针检测
	assert(cls != NULL);

	return cls->next==cls;
}

4.13 销毁

第一种：无限头删

       只要链表不为空，一直调用头删函数，直到把所有结点删除完，此时，退出循环。

//销毁1
void Destroy1(struct CNode *cls)
{
	//0：assert对传入的指针检测
	assert(cls != NULL);

    while(!IsEmpty(cls))
	{
		Del_head(cls);
	}
}

第二种：不借助头结点，但是需要两个指针变量p和q(双指针思想)。与单链表相比，只是空链表的判断条件发生变化。 

//销毁2
void Destroy2(struct CNode *cls)
{
	struct CNode *p = cls->next;
	struct CNode *q = NULL;

	cls->next = cls;

	while(p != cls)
	{
		q = p->next;
		free(p);
		p = q;
	}


}

4.14 打印

    只需要定义一个临时结点类型指针变量，让它从第一个有效节点开始遍历，只要没有到最后一个结点就往后遍历，同时打印结构体的数据域成员。

//打印
void Show(PCNode cls)
{
    //0：assert对传入的指针检测
	assert(cls != NULL);

	struct CNode *p = cls->next;
	
	for( ; p!=cls; p=p->next)
	{
		printf("%d ", p->data);
	}

	printf("\n");
}

五、总结

       单向循环链表的插入，删除算法与单链表基本一致，所不同的是若操作在链表的尾部进行，则判断条件发生变化不同，以让单链表继续保持循环的性质。因此，需要记住循环链表判空和判断是否为尾巴结点的条件！即循环链表中没有NULL指针。涉及遍历操作时，其终止条件就不再是像非循环链表那样判别p或p->next是否为空，而是判别它们是否等于某一指定指针，如头指针或尾指针等。

       以上便是我为大家带来的带头结点的单向循环链表设计内容，若有不足，望各位大佬在评论区指出，谢谢大家！可以留下你们点赞、收藏和关注，这是对我极大的鼓励，我也会更加努力创作更优质的作品。再次感谢大家！

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

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

相关文章

2023平航杯——手机取证复现

2023平航杯——手机取证复现

手机最近连接的wifi"只有红茶可以吗"的密码是&#xff1f;【标准格式&#xff1a;ABCabc123!#】 手机上安装了某个运动软件&#xff0c;它的包名是&#xff1f;【标准格式&#xff1a;com.baidu.gpt】 com.dizhisoft.changdongli 该运动软件中最近一次运动记录的起点…
阅读更多...
【产品经理修炼之道】- 如何从0到1搭建B端产品

【产品经理修炼之道】- 如何从0到1搭建B端产品

随着数字化转型的不断深化，B端产品也面临着升级。本文总结分析了如何从0到1搭建B端产品，希望对你有所帮助。 背景 随着公司数字化转型的不断的推进和实施，数字化转型成功越来越明显的体现在财务报上，这也增强了管理层对数字转型的信心，在推进中我们也发现几年建设的系统的…
阅读更多...
【继承和多态】

【继承和多态】

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言一、pandas是什么&#xff1f;二、使用步骤 1.引入库2.读入数据总结 前言 提示&#xff1a;这里可以添加本文要记录的大概内容&#xff1a; 例如&#xff1a;…
阅读更多...
ios微信小程序禁用下拉上拉

ios微信小程序禁用下拉上拉

第一步&#xff1a; page.json配置页面的"navigationStyle":"custom"属性&#xff0c;禁止页面滑动 "navigationStyle":"custom" 第二步&#xff1a; 页面里面使用scroll-view包裹内容&#xff0c;内容可以内部滑动 <view class&…
阅读更多...
Java中的 JDK环境变量配置详解

Java中的 JDK环境变量配置详解

JDK安装后&#xff0c;接下我们来学习一个补充知识&#xff0c;叫做Path环境变量 什么是Path环境变量&#xff1f; Path环境变量是让系统程序的路径&#xff0c;方便程序员在命令行窗口的任意目录下启动程序&#xff1b; 如何配置环境变量呢&#xff1f; 比如把QQ的启动程序&a…
阅读更多...
面试二十二、跳表SkipLists

面试二十二、跳表SkipLists

跳表全称为跳跃列表&#xff0c;它允许快速查询&#xff0c;插入和删除一个有序连续元素的数据链表。跳跃列表的平均查找和插入时间复杂度都是O(logn)。快速查询是通过维护一个多层次的链表&#xff0c;且每一层链表中的元素是前一层链表元素的子集&#xff08;见右边的示意图&…
阅读更多...
竞赛报名赛事管理系统技术分析

竞赛报名赛事管理系统技术分析

竞赛报名赛事管理系统是一个复杂的应用&#xff0c;涉及到用户管理、赛事信息管理、报名管理、成绩管理等多个方面。使用PHP框架来开发这样的系统&#xff0c;可以大大提高开发效率&#xff0c;保证代码的可维护性和可扩展性。以下是对基于PHP框架的竞赛报名赛事管理系统进行功…
阅读更多...
【C++航海王：追寻罗杰的编程之路】C++11(二)

【C++航海王：追寻罗杰的编程之路】C++11(二)

目录 C11(上) 1 -> STL中的一些变化 2 -> 右值引用和移动语义 2.1 -> 左值引用和右值引用 2.2 -> 左值引用与右值引用比较 2.3 -> 右值引用使用场景与意义 2.4 -> 右值引用引用左值及其更深入的使用场景分析 2.5 -> 完美转发 C11(上) 1 -> STL…
阅读更多...
百面算法工程师 | 卷积基础知识——Convolution

百面算法工程师 | 卷积基础知识——Convolution

目录 8.1 图像卷积过程 8.2 卷积层基本参数 8.3 卷积后图像的长和宽大小的计算方式 8.4 卷积神经网络中的权重共享 8.5 上采样中的反卷积 8.6 空洞卷积 8.7 深度可分离卷积 8.8 为什么可分离卷积中Depthwise卷积后还要进行pointwise卷积 8.9 分组卷积 Group Conv 8.1…
阅读更多...
【A-024】基于SSH的房屋租赁管理系统（含论文）

【A-024】基于SSH的房屋租赁管理系统（含论文）

【A-024】基于SSH的房屋租赁管理系统&#xff08;含论文&#xff09; 开发环境&#xff1a; Jdk7(8)Tomcat7(8)MySQLIntelliJ IDEA(Eclipse) 数据库&#xff1a; MySQL 技术&#xff1a; SpringStruts2HiberanteBootstrapJquery 适用于&#xff1a; 课程设计&#xff0c;毕…
阅读更多...
账号安全及应用

账号安全及应用

一、账号安全控制 1.1系统账号清理 将用户设置为无法登陆 锁定账户 删除账户 设定账户密码&#xff0c;本质锁定 锁定配置文件-chattr&#xff1a; -a 让文件或目录仅供附加用途。只能追加 -i 不得任意更动文件或目录。 1.2密码安全控制 chage 1.3历史命令 history&am…
阅读更多...
SSL证书安装失败怎么办？

SSL证书安装失败怎么办？

在互联网时代&#xff0c;SSL&#xff08;Secure Sockets Layer&#xff09;证书已成为保障网站数据传输安全、提升用户信任度的重要工具。然而&#xff0c;在实际操作过程中&#xff0c;SSL证书的安装并非总能一帆风顺&#xff0c;有时会遇到各种导致安装失败的问题。本文将详…
阅读更多...
轻松上手Python Schedule模块，实现高效定时任务

轻松上手Python Schedule模块，实现高效定时任务

&#x1f340; 前言 博客地址&#xff1a; CSDN&#xff1a;https://blog.csdn.net/powerbiubiu &#x1f44b; 简介 Schedule是Python中的一个轻量级进程调度程序库&#xff0c;用于安排任务以指定的时间间隔定期运行 &#x1f4d6; 正文 1 Schedule的介绍 1.1 安装 pip…
阅读更多...
详解MySQL C API 相关接口(大白话就是：MySQL的c语言怎么写)

详解MySQL C API 相关接口(大白话就是：MySQL的c语言怎么写)

文章目录 1、C API 官方文档2、初始化 MYSQL3、连接 MySQL设置连接字符集&#xff08;使得客户端编码方式匹配&#xff09; 4、下发 mysql 指令5、获取 mysql 查询结果(保存起来)获取行与列遍历存储结果 6、释放 MYSQL\_RES 对象7、关闭 MySQL 连接8、总结 1、C API 官方文档 …
阅读更多...
CSS中的 5 类常见伪元素详解！

CSS中的 5 类常见伪元素详解！

你好&#xff0c;我是云桃桃。 一个希望帮助更多朋友快速入门 WEB 前端的程序媛。 云桃桃-大专生&#xff0c;一枚程序媛&#xff0c;感谢关注。回复 “前端基础题”&#xff0c;可免费获得前端基础 100 题汇总&#xff0c;回复 “前端工具”&#xff0c;可获取 Web 开发工具合…
阅读更多...
【运维自动化-配置平台】如何通过模板创建集群和模块

【运维自动化-配置平台】如何通过模板创建集群和模块

通过【每天掌握一个功能点】配置平台如何创建业务机拓扑&#xff08;集群-模块&#xff09;我们知道了直接创建集群和模块的操作方法&#xff0c;直接创建的方式适合各集群模块都相对独立的场景&#xff0c;那大量的、标准规范的集群模块如何快速创建呢&#xff0c;这里就引入了…
阅读更多...
企业实施定制鞋厂ERP软件需要注意哪些问题？

企业实施定制鞋厂ERP软件需要注意哪些问题？

企业实施定制鞋厂ERP软件是个复杂的管理系统工程&#xff0c;为了成功地为企业定制实施ERP软件&#xff0c;需要注意和解决几个关键的问题&#xff1a; . 确立ERP系统实施和定制的决策者&#xff1b;. 做好前期咨询与调研工作&#xff1b;. 做好系统产品或项目迭代规划&#x…
阅读更多...
Linux安装Docker的多版本PHP和多版本MySQL共存

Linux安装Docker的多版本PHP和多版本MySQL共存

1： 先安装docker 安装完后执行，权限设置 sudo usermod -aG docker $USER或者sudo usermod -aG docker kentrl#添加当前用户到Docker用户组中 sudo newgrp docker#更新用户组数据，必须执行否则无效 sudo systemctl restart docker 先看目录结构： 2：按照目录结构挂载磁盘，…
阅读更多...
ZDOCK linux 下载（无需安装）、配置、使用

ZDOCK linux 下载（无需安装）、配置、使用

ZDOCK 下载 使用 1. 下载1&#xff09;教育邮箱提交申请&#xff0c;会收到下载密码2&#xff09;选择相应的版本3&#xff09;解压 2. 使用方法Step 1&#xff1a;将pdb文件处理为ZDOCK可接受格式Step 2&#xff1a;DockingStep 3&#xff1a;创建所有预测结构 1. 下载 1&…
阅读更多...
Java | Leetcode Java题解之第43题字符串相乘

Java | Leetcode Java题解之第43题字符串相乘

题目&#xff1a; 题解&#xff1a; class Solution {public String multiply(String num1, String num2) {if (num1.equals("0") || num2.equals("0")) {return "0";}int m num1.length(), n num2.length();int[] ansArr new int[m n];for…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023