C语言详解双向链表的基本操作

news2024/12/24 8:19:31

目录

双链表的定义与接口函数

定义双链表

 接口函数

详解接口函数的实现

创建新节点（BuyLTNode）

初始化双链表（ListInit）

双向链表打印（ListPrint）

双链表查找（ListFind）

双链表销毁（ListDestory）

        1、双链表pos位置之前插入（ListInsert）

        2、双链表删除pos位置（ListEarse）

        3、双向链表尾插（ListPushBack）

        4、双向链表头插（ListPushFront）

        5、双链表头删（ListPopFront）

        6、双链表尾删（ListPopBack）

总结

完整代码

链表OJ练习巩固

前言：

为了更好地理解本节，建议先阅读： 数据结构 - c语言链表操作

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

  1.  单向、双向
  2.  带头、不带头
  3.  循环、非循环

解读： 

带头：

存在一个哨兵位的节点，该节点不存储任何有效数据，属于无效节点，但通过这个无效节点当头节点让我们在某些方面使用会有一些优势。

双向：

指的是节点中不再只有一个指针，而是有两个指针，一个指向前一个节点，另一个指向后一个节点。

循环：

尾指针不再指向NULL，而是指向头节点。 

然而，现实中实用的只有两种：分别是无头单向非循环链表；带头双向循环链表。

  • 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
  • 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外，这个结构虽然结构复杂，但是使用代码实现后会发现结构会带来很多优势。双向链表严格来说只需要快速的实现两个接口，insert 和 earse 头尾的插入和删除就可以搞定了！

双链表的定义与接口函数

定义双链表

typedef int LTDataType;
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}LTNode;

 接口函数

void ListPrint(LTNode* phead);
//void ListInit(LTNode** pphead);
LTNode* ListInit();
LTNode* BuyLTNode(LTDataType x);
void ListPushBack(LTNode* phead, LTDataType x);
void ListPopBack(LTNode* phead);

void ListPushFront(LTNode* phead, LTDataType x);
void ListPopFront(LTNode* phead);
LTNode* ListFind(LTNode* phead, LTDataType x);

// 在pos之前插入
void ListInsert(LTNode* pos, LTDataType x);
//void ListInsert(int i, LTDataType x);

// 删除pos位置的节点
void ListErase(LTNode* pos);
void ListDestory(LTNode* phead);

详解接口函数的实现

 创建新节点（BuyLTNode）

LTNode* BuyLTNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}

	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}

初始化双链表（ListInit）

LTNode* ListInit()
{
	LTNode* phead = BuyLTNode(0);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}

这里我们使用 BuyLTNode 函数开辟一块空间作为 "哨兵位" pHead ，最后将其进行一个初始化。最后再将 pHead 作为结果返回回去，外面就可以接收到了。这就是返回值的方法，当然这里也可以采用二级指针的方法来完成。

双向链表打印（ListPrint）

void ListPrint(LTNode* phead)
{
	assert(phead);

	LTNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n\n");
}

双链表查找（ListFind）

LTNode* ListFind(LTNode* phead, LTDataType x)
{
	assert(phead);

	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
		{
			return cur;
		}

		cur = cur->next;
	}

	return NULL;
}

双链表销毁（ListDestory）

void ListDestory(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		//ListErase(cur);
		free(cur);
		cur = next;
	}

	free(phead);
	//phead = NULL;
}

1、双链表pos位置之前插入（ListInsert）

void ListInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	/*LTNode* newnode = BuyLTNode(x);
	pos->prev->next = newnode;
	newnode->prev = pos->prev;

	pos->prev = newnode;
	newnode->next = pos;*/

	LTNode* newnode = BuyLTNode(x);
	LTNode* posPrev = pos->prev;

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

非常简单，假设d2是新节点，就是让新节点的两条链接在d3上，然后把d1的两条链接新节点上

2、双链表删除pos位置（ListEarse）

void ListErase(LTNode* pos)
{
	assert(pos);

	LTNode* prev = pos->prev;
	LTNode* next = pos->next;

	free(pos);
	pos = NULL;

	prev->next = next;
	next->prev = prev;
}

 假设要删除d2，那么只需要直接把d1的两条链接d3上即可

3、双向链表尾插（ListPushBack）

void ListPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);

	LTNode* tail = phead->prev;
	LTNode* newnode = BuyLTNode(x);

	tail->next = newnode;
	newnode->prev = tail;

	newnode->next = phead;
	phead->prev = newnode;

	
}

4、双向链表头插（ListPushFront）

void ListPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	ListInsert(phead->next, x);
}

5、双链表头删（ListPopFront）

void ListPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	ListErase(phead->next);
}

6、双链表尾删（ListPopBack）

void ListPopBack(LTNode* phead)
{
	assert(phead);
	// 链表为空
	assert(phead->next != phead);

	LTNode* tail = phead->prev;
	LTNode* tailPrev = tail->prev;

	free(tail);
	tail = NULL;

	tailPrev->next = phead;
	phead->prev = tailPrev;

	
}

总结：

用ListInsert和ListEarse的复用优化后：

void ListPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);

	ListInsert(phead, x);
}

void ListPopBack(LTNode* phead)
{
	assert(phead);
	// 链表为空
	assert(phead->next != phead);

	ListErase(phead->prev);
}

void ListPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	ListErase(phead->next);
}

void ListPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	ListInsert(phead->next, x);
}

所以，双向链表严格来说只需要快速地实现 insert 和 earse 这两个接口就可以搞定了。如果以后让你快速实现一个双向链表，你把 "pos位置之前插入" 和 "删除pos位置" 这两个接口写好，头尾的插入和删除直接复用就可以搞定了。

完整代码

List.h

#pragma once

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

typedef int LTDataType;
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}LTNode;

void ListPrint(LTNode* phead);
//void ListInit(LTNode** pphead);
LTNode* ListInit();
LTNode* BuyLTNode(LTDataType x);
void ListPushBack(LTNode* phead, LTDataType x);
void ListPopBack(LTNode* phead);

void ListPushFront(LTNode* phead, LTDataType x);
void ListPopFront(LTNode* phead);
LTNode* ListFind(LTNode* phead, LTDataType x);

// 在pos之前插入
void ListInsert(LTNode* pos, LTDataType x);
//void ListInsert(int i, LTDataType x);

// 删除pos位置的节点
void ListErase(LTNode* pos);
void ListDestory(LTNode* phead);

List.c

#include"List.h"

LTNode* BuyLTNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}

	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}

void ListPrint(LTNode* phead)
{
	assert(phead);

	LTNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n\n");
}

//void ListInit(LTNode** pphead)
//{
//	assert(pphead);
//	*pphead = BuyLTNode(0);
//	(*pphead)->next = *pphead;
//	(*pphead)->prev = *pphead;
//}

LTNode* ListInit()
{
	LTNode* phead = BuyLTNode(0);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}

void ListPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);

	//LTNode* tail = phead->prev;
	//LTNode* newnode = BuyLTNode(x);

	//tail->next = newnode;
	//newnode->prev = tail;

	//newnode->next = phead;
	//phead->prev = newnode;

	ListInsert(phead, x);
}

void ListPopBack(LTNode* phead)
{
	assert(phead);
	// 链表为空
	assert(phead->next != phead);

	/*	LTNode* tail = phead->prev;
	LTNode* tailPrev = tail->prev;

	free(tail);
	tail = NULL;

	tailPrev->next = phead;
	phead->prev = tailPrev;*/

	ListErase(phead->prev);
}

void ListPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	ListErase(phead->next);
}

void ListPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	ListInsert(phead->next, x);
}

LTNode* ListFind(LTNode* phead, LTDataType x)
{
	assert(phead);

	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
		{
			return cur;
		}

		cur = cur->next;
	}

	return NULL;
}

void ListInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	/*LTNode* newnode = BuyLTNode(x);
	pos->prev->next = newnode;
	newnode->prev = pos->prev;

	pos->prev = newnode;
	newnode->next = pos;*/

	LTNode* newnode = BuyLTNode(x);
	LTNode* posPrev = pos->prev;

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

// 驼峰法
// 函数和类型所有单词首字母大写
// 变量：第一个单词小写后续单词首字母大写
void ListErase(LTNode* pos)
{
	assert(pos);

	LTNode* prev = pos->prev;
	LTNode* next = pos->next;

	free(pos);
	pos = NULL;

	prev->next = next;
	next->prev = prev;
}

void ListDestory(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		//ListErase(cur);
		free(cur);
		cur = next;
	}

	free(phead);
	//phead = NULL;
}


------------------------------------------------------------------------------

#include "List.h"
 
ListNode* BuyListNode(LTDataType x)
{
	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
	node->data = x;
	node->next = NULL;
	node->prev = NULL;
 
	return node;
}
 
ListNode* ListCreate()
{
	ListNode* head = (ListNode*)malloc(sizeof(ListNode));
	head->next = head;
	head->prev = head;
	return head;
}
 
void ListPrint(ListNode* pHead)
{
	assert(pHead);
	ListNode* cur = pHead->next;
	while (cur != pHead)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("\n");
}
 
void ListDestroy(ListNode* pHead)
{
	ListNode* cur = pHead->next;
	while (cur != pHead)
	{
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	
	free(pHead);
}
 
void ListPushBack(ListNode* pHead, LTDataType x)
{
	assert(pHead);
 
	//ListNode* newnode = BuyListNode(x);
	 phead         tail   newnode
	//ListNode* tail = pHead->prev;
 
	//tail->next = newnode;
	//newnode->prev = tail;
	//newnode->next = pHead;
	//pHead->prev = newnode;
 
	ListInsert(pHead, x);
}
 
void ListPushFront(ListNode* pHead, LTDataType x)
{
	assert(pHead);
 
	//ListNode* newnode = BuyListNode(x);
	//ListNode* first = pHead->next;
	//pHead->next = newnode;
	//newnode->prev = pHead;
	//newnode->next = first;
	//first->prev = newnode;
 
	/*ListNode* newNode = BuyListNode(x);
	newNode->next = pHead->next;
	pHead->next->prev = newNode;
 
	pHead->next = newNode;
	newNode->prev = pHead;*/
 
	ListInsert(pHead->next, x);
}
 
void ListPopBack(ListNode* pHead)
{
	assert(pHead);
 
	//ListNode* tail = pHead->prev;
	//ListNode* tailPrev = tail->prev;
 
	 pHead     tailPrev tail
	//tailPrev->next = pHead;
	//pHead->prev = tailPrev;
	//free(tail);
 
	/*ListNode* tail = pHead->prev;
	pHead->prev = tail->prev;
	tail->prev->next = pHead;
 
	free(tail);*/
 
	ListErase(pHead->prev);
}
 
void ListPopFront(ListNode* pHead)
{
	//...
	ListErase(pHead->next);
}
 
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* prev = pos->prev;
	ListNode* newnode = BuyListNode(x);
 
	// prev newnode pos
	prev->next = newnode;
	newnode->prev = prev;
	newnode->next = pos;
	pos->prev = newnode;
}
 
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos)
{
	assert(pos);
 
	ListNode* prev = pos->prev;
	ListNode* next = pos->next;
 
	prev->next = next;
	next->prev = prev;
	free(pos);
}

链表OJ练习巩固

138. 复制带随机指针的链表 - 力扣（LeetCode）

 

解题思路：
此题可以分三步进行：
1.拷贝链表的每一个节点，拷贝的节点先链接到被拷贝节点的后面
2.复制随机指针的链接：拷贝节点的随机指针指向被拷贝节点随机指针的下一个位置
3.拆解链表，把拷贝的链表从原链表中拆解出来 



class Solution {
public:
    Node* copyRandomList(Node* head) {
        // 1.拷贝链表，并插入到原节点的后面，如图1
        Node* cur = head;
        while(cur)
        {
            Node* next = cur->next;
 
            Node* copy = (Node*)malloc(sizeof(Node));
            copy->val = cur->val;
 
            // 插入
            cur->next = copy;
            copy->next = next;
 
            // 迭代往下走
            cur = next;
        }
 
        // 2.置拷贝节点的random，如图2
        cur = head;
        while(cur)
        {
            Node* copy = cur->next;
            if(cur->random != NULL)
                copy->random = cur->random->next;
            else
                copy->random = NULL;
 
            cur = copy->next;
        }
 
        // 3.解拷贝节点，链接拷贝节点，如图3
        Node* copyHead = NULL, *copyTail = NULL;
        cur = head;
        while(cur)
        {
            Node* copy = cur->next;
            Node* next = copy->next;
 
            // copy解下来尾插
            if(copyTail == NULL)
            {
                copyHead = copyTail = copy;
            }
            else
            {   
                copyTail->next = copy;
                copyTail = copy;
            }
 
            cur->next = next;
 
            cur = next;
        }
 
        return copyHead;
    }
};

图1： 

 图2：

图3： 

链表知识点题库 - 力扣（LeetCode）

牛客网 - 找工作神器|笔试题库|面试经验|实习招聘内推，求职就业一站解决_牛客网 (nowcoder.com)

 

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

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

相关文章

SiteWhere 宣布推出 SiteWhere 企业版 (EE) 测试版

SiteWhere 宣布推出 SiteWhere 企业版 (EE) 测试版

开源物联网应用程序支持平台 (AEP) 供应商 SiteWhere 刚刚宣布推出SiteWhere 企业版 (EE) Beta。SiteWhere EE基于SiteWhere 开源开发项目&#xff0c;是为企业客户打造的平台。SiteWhere EE 已经引起了全球各行业公司的兴趣。 SiteWhere EE 有许多功能&#xff0c;但 MachNati…
阅读更多...
Vue3之组件间传值

Vue3之组件间传值

何为组件间传值 在Vue3之组件文章中&#xff0c;我们学会了定义使用组件&#xff0c;但是我们似乎还缺少什么将组件之间联系起来&#xff0c;说到组件之间的联系就不得不提组件间的传值&#xff0c;而组件间的传值其实也不难理解&#xff0c;就是如何在子组件中接收到父组件传…
阅读更多...
C语言再学习第三章

C语言再学习第三章

例题3-1 编写一个函数&#xff0c;实现华氏度和摄氏度的转化。 已知公式&#xff1a;c &#xff08;5/9)*(f-32) #include <stdio.h>double f_value 0; double c_value 0; int main(void) {printf("请输入华氏温度\n");scanf("%lf",&f_valu…
阅读更多...
两阶段提交(2 Phase Commit) 在 PostgreSQL 和 RocksDB 中的实现

两阶段提交(2 Phase Commit) 在 PostgreSQL 和 RocksDB 中的实现

文章目录前言用法PostgreSQLRocksDB实现PostgreSQL 2PCRocksDB 2PCWRITE_COMMITTEDWRITE_PREPARED解决 snapshot-read 问题解决 rollback 问题WRITE_UNPREPARED总结前言 本节中提到的代码实现是基于 PG&#xff1a;REL_15_STABLE 和 Rocksdb: master-fcd816d534 代码介绍的 2PC…
阅读更多...
shell：#!/usr/bin/env python作用是什么

shell：#!/usr/bin/env python作用是什么

我们经常会在别人的脚本文件里看到第一行是下面这样 #!/usr/bin/python或者 #!/usr/bin/env python 那么他们有什么用呢&#xff1f; 要理解它&#xff0c;得把这一行语句拆成两部分。 第一部分是 #! 第二部分是 /usr/bin/python 或者 /usr/bin/env python 关于 #! 这个…
阅读更多...
Java8 新特性 之 lambda 表达 和 函数式接口

Java8 新特性 之 lambda 表达 和 函数式接口

—— lambda 表达式 概念 lambda 表达式是一个匿名函数&#xff0c;可以把 lambda 表达式理解为是一段可以传递的代码。更简洁、更灵活&#xff0c;使 Java 的语言表达能力得到了提升lambda 表达式是作为接口的实现类的对象&#xff08;万事万物皆对象&#xff09; 使用语法…
阅读更多...
世界那么大，你哪都别去了，来我带你了解CSS3(三)

世界那么大，你哪都别去了，来我带你了解CSS3(三)

文章目录‍❤️‍&#x1f525;CSS动画‍❤️‍&#x1f525;CSS雪碧图‍❤️‍&#x1f525;CSS字体图标‍❤️‍&#x1f525;CSS盒子模型&#xff08;Box Model&#xff09;‍❤️‍&#x1f525;CSS新特性‍❤️‍&#x1f525;CSS动画 动画是使元素从一种样式逐渐变化为另…
阅读更多...
【Rides】使用Xshell 链接云服务器安装Rides及其三种启动方法详解

【Rides】使用Xshell 链接云服务器安装Rides及其三种启动方法详解

文章目录一.NoSQL和SQl的概念1.1 总结二.Rides2.1 Rides特点2.2 Rides安装2.2.1 上传安装包并解压2.3 Redis启动&#xff08;前台启动不推荐&#xff09;2.4.指定配置启动2.5 开机自启三.Redis客户端2.1.Redis命令行客户端2.2.图形化桌面客户端2.2.1.安装2.2.2.建立连接一.NoSQ…
阅读更多...
Vue.js 实现带拖动功能的时间轴

Vue.js 实现带拖动功能的时间轴

带拖动功能的时间轴timeline-slider-vueDemoGithub环境node V12.20.0npm 6.14.8&#x1f4e6; Installnpm install --save timeline-slider-vue全局引用main.jsimport TimelineSliderVue from timeline-slider-vueimport timeline-slider-vue/lib/timeline-slider-vue.cssVue.u…
阅读更多...
数据库复习

数据库复习

什么是数据库系统 数据库系统是指在计算机系统中引入数据库后构成的系统&#xff0c;一般由数据库、数据库管理系统(及其开发工具)、应用系统、数据库管理员和用户构成 数据库系统的特点是什么&#xff1f; 数据结构化数据的共享性高&#xff0c;冗余度低且易扩充数据独立性高数…
阅读更多...
吐血整理的TCP协议相关原理

吐血整理的TCP协议相关原理

文章目录一、 TCP报文的结构二、TCP建立连接-三次握手2.1 三次握手建立连接的过程2.2 三次握手的思考2.3 针对连接过程的DDOS攻击-SYN flood三、 TCP断开链接-四次挥手3.1 客户端主动断开链接的过程3.2 四次挥手的思考四、 TCP状态机六、 TCP的流量控制-滑动窗口协议七、 TCP拥…
阅读更多...
openpnp - 顶部相机高级矫正的细节

openpnp - 顶部相机高级矫正的细节

文章目录openpnp - 顶部相机高级矫正的细节概述ENDopenpnp - 顶部相机高级矫正的细节 概述 设备到手的时候, 只有一个主校准点, 是一块只带一个mark点的小PCB拧在设备正面前部中间的凸台上. 配置openpnp时, 需要指定次校准点. 开始自己做了一块长条形PCB, 上面有mark点, 拧在…
阅读更多...
【C++知识点】重载

【C++知识点】重载

✍个人博客&#xff1a;https://blog.csdn.net/Newin2020?spm1011.2415.3001.5343 &#x1f4da;专栏地址&#xff1a;C/C知识点 &#x1f4e3;专栏定位&#xff1a;整理一下 C 相关的知识点&#xff0c;供大家学习参考~ ❤️如果有收获的话&#xff0c;欢迎点赞&#x1f44d;…
阅读更多...
阿赵的MaxScript学习笔记分享十二《获取和导出各种数据》

阿赵的MaxScript学习笔记分享十二《获取和导出各种数据》

大家好&#xff0c;我是阿赵&#xff0c;周日的早上继续分享MaxScript学习笔记&#xff0c;这是第十二篇&#xff0c;获取和导出各种数据 1、导出数据的目的 使用3DsMax建立3D模型后&#xff0c;很多时候需要输出模型到别的引擎去使用&#xff0c;常用的格式有Obj、FBX、SLT等…
阅读更多...
geoserver之BlobStores使用

geoserver之BlobStores使用

概述 geoserver是常用的地图服务器之一&#xff0c;除了基本的能力之外&#xff0c;也提供了很多的插件方便大家使用。在本文&#xff0c;讲述一下如何在geoserver中使用BlobStores和gwc-sqlite-plugin插件实现地图的切片和部署。 BlobStores简介 在geoserver中&#xff0c;…
阅读更多...
Linux安装Nginx和Nginx基础配置

Linux安装Nginx和Nginx基础配置

下载Nginx 方式一&#xff1a;通过官网下载后上传 通过官网下载安装包。下载地址https://nginx.org/en/download.html 这里选择稳定版的进行下载。 这里使用FinalShell终端工具操作&#xff0c;使用其他工具操作亦可。FinalShell工具下载地址&#xff1a;http://www.hostbuf…
阅读更多...
带加权的贝叶斯自举法 Weighted Bayesian Bootstrap

带加权的贝叶斯自举法 Weighted Bayesian Bootstrap

在去年的文章中我们介绍过Bayesian Bootstrap&#xff0c;今天我们来说说Weighted Bayesian Bootstrap Bayesian bootstrap 贝叶斯自举法&#xff08;Bayesian bootstrap&#xff09;是一种统计学方法&#xff0c;用于在缺乏先验知识的情况下对一个参数的分布进行估计。这种方…
阅读更多...
【Node.js】HTTP协议、HTTP的请求报文和响应报文

【Node.js】HTTP协议、HTTP的请求报文和响应报文

HTTP协议、HTTP的请求报文和响应报文HTTP协议HTTP主要特点HTTP的请求报文和响应报文请求报文请求行请求消息头空行请求体响应报文响应状态行响应消息头空行响应体总结HTTP协议 HTTP 全称为超文本传输协议&#xff0c;是用于从WWW服务器传输超文本到本地浏览器的传送协议&#…
阅读更多...
硬件基础专题-01电阻篇

硬件基础专题-01电阻篇

目录 课程链接 学习目的 电阻 电阻理论讲解 电阻定义​ 欧姆定律​ 电阻单位换算 电阻选型考虑 安装方式 常见电阻值 各种贴片电阻的读取方式 确定电阻值的方法 电阻数据手册 电阻测量 电阻的产品应用​ 零欧姆电阻 热敏电阻 光敏电阻 课程链接 视频专辑 - 硬件…
阅读更多...
linux入门---权限

linux入门---权限

目录标题什么是权限人的分类为什么会有所属组查看文件属性文件的分类如何查看权限文件不同权限的表现rwx权限修改八进制权限修改umask有关内容文件中人的修改目录不同权限的表现rwx什么是权限 首先来看一个例子&#xff1a;比如说我没有爱奇艺的vip&#xff0c;那么我也就没有…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023