【数据结构】链表的大概认识及单链表的实现

目录

一、链表的概念及结构

二、链表的分类

三、单链表的实现

建立链表的节点：

尾插——尾删： 

头插——头删：

查找：

指定位置之后删除——插入：

指定位置之前插入——删除指定位置：

销毁链表：

打印：

四、链表面试题

五、总体代码

一、链表的概念及结构

概念：链表是一种 物理存储结构上非连续 、非顺序的存储结构，数据元素的 逻辑顺序 是通过链表
中的 指针链接 次序实现的 。

二、链表的分类

实际中链表的结构非常多样，以下情况组合起来就有 8 种链表结构：
1. 单向或者双向
2. 带头或者不带头

3. 循环或者非循环

虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：

1. 无头单向非循环链表： 结构简单 ，一般不会单独用来存数据。实际中更多是作为 其他数据结 构的子结构 ，如哈希桶、图的邻接表等等。另外这种结构在 笔试面试 中可能出现比较多。
2. 带头双向循环链表： 结构最复杂 ，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了。

三、单链表的实现

建立链表的节点：

链表中的节点结构体大概有这些内容：节点数据，下一个节点的地址

typedef int SLTDateType;
typedef struct SListNode
{SLTDateType data;struct SListNode* next;
}SListNode;

尾插——尾删： 

不管是尾插还头插还是任意位置插入，我们都需要先创建一个新节点。

尾插和尾删都需要注意一些点：

用二级指针接收：

因为我们这个是无头的链表，在链表没有一个节点的时候，我们需要创建一个节点。然后将链表的头指向这个新节点，这个时候就涉及到需要修改一级结构体的一级指针。一级指针类型的变量需要修改的话，就要用到二级指针。

尾插：是否链表一个数据都没有，这个时候我们要特殊处理一下，检查链表有效性

尾删：是否链表只有一个数据 ，检查是否有数据可以删除，检查链表有效性

// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x)
{SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));if (newnode == NULL){perror("malloc fail");}newnode->data = x;newnode->next = NULL;return newnode;
}
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x)
{assert(pplist);SListNode* newnode = BuySListNode(x);if (*pplist == NULL){*pplist = newnode;return;}//找尾巴SListNode* tail = *pplist;while (tail->next != NULL)tail = tail->next;tail->next = newnode;
}
// 单链表的尾删
void SListPopBack(SListNode** pplist)
{assert(pplist);assert(*pplist);//有数据才能删，没有数据不删，至少有一个及其以上节点if ((*pplist)->next == NULL){free(*pplist);*pplist = NULL;}else{//找尾巴SListNode* prev = NULL;SListNode* tail = *pplist;while (tail->next != NULL){prev = tail;tail = tail->next;}free(tail);prev->next = NULL;}
}

头插——头删：

 头插和头删在链表中还是比较简单，一个是把头节点保存起来，另一个是头节点的下一个节点保存起来，然后进行删除就行了。

头插：注意需要检查链表有效性

头删：注意这里需要检查数据个数，有数据才能删除；

// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x)
{assert(pplist);SListNode* newnode = BuySListNode(x);newnode->next = *pplist;*pplist = newnode;
}
// 单链表头删
void SListPopFront(SListNode** pplist)
{assert(pplist);assert(*pplist);SListNode* next = (*pplist)->next;free(*pplist);*pplist = next;
}

查找：

通过简单遍历就行了，注意返回的是节点的指针；

我们在外面定义的是一个链表节点的指针，打印的时候按照传值的方式传递变量，他会把变量的内容（链表中首节点的地址）拷贝过来，最终返回的也是链表节点的地址

// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x)
{assert(plist);SListNode* cur = plist;while (cur){if (cur->data == x)return cur;cur = cur->next;}return NULL;
}

指定位置之后删除——插入：

注意：写这两个接口，我们首先就要想到的是检查 指定位置的有效性 还有检查 链表有效性。

代码还是很简单的，这里的删除要检查是不是最后一个节点；

// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDateType x)
{assert(pos);SListNode* newnode = BuySListNode(x);newnode->next = pos->next;pos->next = newnode;
}
// 单链表删除pos位置之后的值void SListEraseAfter(SListNode* pos)
{assert(pos);assert(pos->next);//检查是不是最后一个SListNode* next = pos->next;pos->next = next->next;free(next);
}

指定位置之前插入——删除指定位置：

这两个接口：我们需要像尾插那个样子 遍历找到指定位置前的位置：然后进行插入，删除，同时也要注意检查链表有效性，

注意： 如果链表只有一个位置或者指定位置为第一个节点，那删除就变成了头删，可以复用原来的头删接口。尾删则没有必要，我们已经遍历一遍找到尾了，不需要调用尾删接口再遍历一遍了，直接像尾删一样删除就行了。

// 在pos的前面插入
void SLTInsert(SListNode** pphead, SListNode* pos, SLTDateType x)
{assert(pphead);assert((!pos&&!(*pphead))||(pos&&(*pphead)))//这里我们让他都为空（头插）或者都不为空//我们想暴露出一个问题，不允许乱位置插入  限定pos一定是有效节点if (pos == *pphead){SListPushFront(pphead, x);return;}SListNode* prev = *pphead;while (prev->next!=pos){prev = prev->next;}SListNode* newnode = BuySListNode(x);newnode->next = pos;prev->next = newnode;
}
// 删除pos位置
void SLTErase(SListNode** pphead, SListNode* pos)
{assert(pphead);assert(*pphead);assert(pos);//这里进行检查pos，必须有这个节点才能删除if (pos == *pphead){SListPopFront(pphead);return;}SListNode* prev = *pphead;while (prev->next != pos){prev = prev->next;}prev->next = pos->next;free(pos);pos = NULL;
}

销毁链表：

这个按照遍历的同时free就行了。

注意：遍历完了，全部空间释放了把链表置空

void SLTDestroy(SListNode** pphead)
{assert(pphead);assert(*pphead);SListNode* cur = *pphead;while (cur){SListNode* next = cur->next;free(cur);cur = next;}*pphead = NULL;
}

打印：

为了好测试写的接口是否正确，我们还是写一个打印接口，方便我们观察：同样的，循环遍历打印就行了；这里不需要检查链表是否为空，空链表也可以打印

// 单链表打印
void SListPrint(SListNode* plist)
{SListNode* cur = plist;while (cur){printf("%d-> ", cur->data);cur = cur->next;}printf("\n");
}

四、链表面试题

1. 删除链表中等于给定值 val 的所有结点。  203. 移除链表元素 - 力扣（LeetCode）
这个题我们找到与 给定值相等的节点和他的前一个节点就可以进行删除了，但是我们要处理两种情况：
1：链表为空
2：需要删除头（需要循环删除，因为有可能连续好几个都需要删）

参考代码： 

struct ListNode* removeElements(struct ListNode* head, int val) {//处理链表为空if(!head) return NULL;//处理链表第一个就是该删的元素if(head->val==val){while(head&&head->val==val){struct ListNode* next=head->next;free(head);head=next;}}struct ListNode* cur=head;struct ListNode* prev=NULL;while(cur){if(cur->val==val){prev->next=cur->next;free(cur);cur=prev->next;}else{prev=cur;cur=cur->next;}}return head;
}
2. 反转一个单链表。  206. 反转链表 - 力扣（LeetCode）

 这个题，就是一个简单头插就行了

当然我们也可以用三个指针将链表的指向反转（注意检查链表是否为空），这里我们用两种方法实现，两种方法任选其一都能通过，

struct ListNode* reverseList(struct ListNode* head) {//头插处理// struct ListNode* newhead=NULL;// while(head)// {//     struct ListNode* next=head->next;//     head->next=newhead;//     newhead=head;//     head=next;// }// return newhead;//直接反转if(!head)return head;struct ListNode* n1=NULL,*n2=head,*n3=head->next;while(n2){n2->next=n1;n1=n2;n2=n3;if(n3)n3=n3->next;        }return n1;
}
3. 给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。 876. 链表的中间结点 - 力扣（LeetCode）
这个题是一个标准的 快慢指针

值得注意的是：我们判断条件是快指针为NULL或者快指针的下一个节点为NULL，他们在循环中判断的先后为先判断自己再判断下一个，因为先判断下一个的话，有可能出现野指针问题。 

struct ListNode* middleNode(struct ListNode* head) {//快慢指针法struct ListNode* fast=head;struct ListNode* slow=head;while(fast&&fast->next){fast=fast->next->next;slow=slow->next;}return slow;
}

 4. 输入一个链表，输出该链表中倒数第k个结点。 面试题 02.02. 返回倒数第 k 个节点 - 力扣（LeetCode）

这个题也是一个经典的双指针，可以让快指针先走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;
}
5. 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有结点组成的。 21. 合并两个有序链表 - 力扣（LeetCode）

 这个题就要用到并归和尾插了，选择小的尾插到新链表里面，这个尾插是移动他的链表节点到我们新的链表里面。

需要注意的是：1.需要处理空链表情况，一个为空或者两个为空

                         2.处理头节点

 

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {//处理为空的情况  if(!list1)return list2;if(!list2)return list1;struct ListNode* head=NULL;struct ListNode* tail=NULL;while(list1&&list2){if(list1->val<list2->val){struct ListNode* next=list1->next;if(head==NULL)//处理头节点head=tail=list1;else{tail->next=list1;tail=tail->next;tail->next=NULL;//这个可以不处理，后面剩余节点的尾巴也一定是NULL}list1=next;}else{struct ListNode*next=list2->next;if(head==NULL)//处理头节点head=tail=list2;else{tail->next=list2;tail=tail->next;tail->next=NULL;}list2=next;}}if(list1==NULL)//处理剩余未插入的节点tail->next=list2;elsetail->next=list1;return head;
}
6. 编写代码，以给定值 x 为基准将链表分割成两部分，所有小于 x 的结点排在大于或等于 x 的结
点之前 。 链表分割_牛客题霸_牛客网 (nowcoder.com)
这个题呢，我们用把链表分成两条，小于给定值的在一条，大于给定值的在一条，然后在连接起来就行了。
注意：这里我们要用到 带头的单链表，无头的单链表会有很多问题要处理。我们还需要将链表移动后 置空，不然后面连接起来可能会出现很多问题 
class Partition {public:ListNode* partition(ListNode* pHead, int x) {ListNode* head1, *tail1, *head2, *tail2;head1 = tail1 = (ListNode*)malloc(sizeof(ListNode));//第一条链表head2 = tail2 = (ListNode*)malloc(sizeof(ListNode));//第二条链表tail1->next = tail2->next = NULL;while (pHead) {if (pHead->val < x) {ListNode* next = pHead->next;tail1->next = pHead;tail1 = tail1->next;tail1->next = NULL;pHead = next;} else {ListNode* next = pHead->next;tail2->next = pHead;tail2 = tail2->next;tail2->next = NULL;pHead = next;}}tail1->next=head2->next;ListNode* re=head1->next;free(head2);free(head1);return re;}
};

7. 链表的回文结构。OJ链接

这个题，我们需要找到中间节点（先遍历找出节点个数即可找到），然后翻转一半节点到创建的另一个链表当中，然后进行比对即可得到是否为回文结构； 
class PalindromeList {
public:bool chkPalindrome(ListNode* A) {if(!A) return true;int count=0;ListNode* cur=A;while(cur){cur=cur->next;count++;}count=(count+1)/2;int i=count;ListNode*head=NULL;while(i--){ListNode*next=A->next;A->next=head;head=A;A=next;}while(head&&A){if(head->val!=A->val)return false;head=head->next;A=A->next;}return true;}
};
8. 输入两个链表，找出它们的第一个公共结点。 160. 相交链表 - 力扣（LeetCode）

这个题我们可以首先想到暴力解法：先在定一条链表中的某个节点，然后再另一个链表中找该节点，如果找到了有返回该节点，不过这样的解法时间复杂度太高了

第二种方法是我们先遍历各自链表，找出其中个数，先让长的那一条链表先走他们的节点个数差，然后两条链表同时遍历，找出相交节点；

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {int cnt1=0,cnt2=0;struct ListNode* cur1=headA;while(cur1){cur1=cur1->next;cnt1++;}struct ListNode* cur2=headB;while(cur2){cur2=cur2->next;cnt2++;}if(cur2!=cur1)//如果链表到最后都不相等，说明不相交，没有交点return NULL;//假定A比B长struct ListNode* ha=headA;struct ListNode* hb=headB;if(cnt1<cnt2){ha=headB;hb=headA;}int cnt=abs(cnt1-cnt2);while(cnt--)//让长的先走个数差ha=ha->next;while(ha)//两条链表同时遍历{if(ha==hb)//注意两个节点相等，不是节点值相等  ！！！！！！！return ha;ha=ha->next;hb=hb->next;}return NULL;
}

9.给定一个链表，判断链表中是否有环。141. 环形链表 - 力扣（LeetCode）

这是一个经典快慢指针：

bool hasCycle(struct ListNode *head) {struct ListNode* fast=head;struct ListNode* slow=head;while(fast&&fast->next){fast=fast->next->next;slow=slow->next;if(fast==slow)return true;}return false;
}
10.给定一个链表，返回链表开始入环的第一个结点。 如果链表无环，则返回  NULL
142. 环形链表 II - 力扣（LeetCode）

这个题需要我么用到简单的数学知识：

 

struct ListNode *detectCycle(struct ListNode *head) {struct ListNode* fast=head;struct ListNode* slow=head;while(fast&&fast->next){fast=fast->next->next;slow=slow->next;if(fast==slow){struct ListNode* cur=head;while(cur!=fast){cur=cur->next;fast=fast->next;}return cur;}}return NULL;
}
11. 给定一个链表，每个结点包含一个额外增加的随机指针，该指针可以指向链表中的任何结点或空结点。 要求返回这个链表的深度拷贝。 138. 随机链表的复制 - 力扣（LeetCode）

这个题我们可以用这个方法： 在原链表中，每个节点都复制一个节点插入在自己的后面，

然后进行random处理，如果原节点的random存在，则新节点的random指向原节点的random的下一个。最后，将两条链表分离即可。

struct Node* copyRandomList(struct Node* head) {if(!head) return NULL;struct Node* cur=head;while(cur){struct Node* newnode=(struct Node*)malloc(sizeof(struct Node));newnode->next=cur->next;newnode->val=cur->val;newnode->random=NULL;cur->next=newnode;cur=newnode->next;}cur=head;while(cur){struct Node* new=cur->next;if(cur->random)new->random=cur->random->next;cur=new->next;}cur=head;struct Node* newhead=cur->next;struct Node* tail=cur->next;while(cur){cur->next=tail->next;cur=cur->next;if(cur)tail->next=cur->next;tail=tail->next;}return newhead;
}

五、总体代码

SList.h

#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
// slist.h
typedef int SLTDateType;
typedef struct SListNode
{SLTDateType data;struct SListNode* next;
}SListNode;// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x);
// 单链表打印
void SListPrint(SListNode* plist);
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x);
// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x);
// 单链表的尾删
void SListPopBack(SListNode** pplist);
// 单链表头删
void SListPopFront(SListNode** pplist);
// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x);
// 单链表在pos位置之后插入x
// 分析思考为什么不在pos位置之前插入？
void SListInsertAfter(SListNode* pos, SLTDateType x);
// 单链表删除pos位置之后的值
// 分析思考为什么不删除pos位置？
void SListEraseAfter(SListNode* pos);// 在pos的前面插入
void SLTInsert(SListNode** pphead, SListNode* pos, SLTDateType x);
// 删除pos位置
void SLTErase(SListNode** pphead, SListNode* pos);
void SLTDestroy(SListNode** pphead);

SList.h

#define _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x)
{SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));if (newnode == NULL){perror("malloc fail");}newnode->data = x;newnode->next = NULL;return newnode;
}
// 单链表打印
void SListPrint(SListNode* plist)
{assert(plist);SListNode* cur = plist;while (cur){printf("%d-> ", cur->data);cur = cur->next;}printf("\n");
}
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x)
{assert(pplist);SListNode* newnode = BuySListNode(x);if (*pplist == NULL){*pplist = newnode;return;}//找尾巴SListNode* tail = *pplist;while (tail->next != NULL)tail = tail->next;tail->next = newnode;
}
// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x)
{assert(pplist);SListNode* newnode = BuySListNode(x);newnode->next = *pplist;*pplist = newnode;
}
// 单链表的尾删
void SListPopBack(SListNode** pplist)
{assert(pplist);assert(*pplist);//有数据才能删，没有数据不删if ((*pplist)->next == NULL){free(*pplist);*pplist = NULL;}else{//找尾巴SListNode* prev = NULL;SListNode* tail = *pplist;while (tail->next != NULL){prev = tail;tail = tail->next;}free(tail);prev->next = NULL;}
}
// 单链表头删
void SListPopFront(SListNode** pplist)
{assert(pplist);assert(*pplist);SListNode* next = (*pplist)->next;free(*pplist);*pplist = next;
}
// 单链表查找
//plist是一个变量，保存的是地址，传的时候也是地址，传过去就是将变量里面的地址拷贝一份传过去了
SListNode* SListFind(SListNode* plist, SLTDateType x)
{assert(plist);SListNode* cur = plist;while (cur){if (cur->data == x)return cur;cur = cur->next;}return NULL;
}
// 单链表在pos位置之后插入x
// 分析思考为什么不在pos位置之前插入？
void SListInsertAfter(SListNode* pos, SLTDateType x)
{assert(pos);SListNode* newnode = BuySListNode(x);newnode->next = pos->next;pos->next = newnode;
}
// 单链表删除pos位置之后的值
// 分析思考为什么不删除pos位置？
void SListEraseAfter(SListNode* pos)
{assert(pos);assert(pos->next);//检查是不是最后一个SListNode* next = pos->next;pos->next = next->next;free(next);
}// 在pos的前面插入
void SLTInsert(SListNode** pphead, SListNode* pos, SLTDateType x)
{assert(pphead);assert(*pphead);//这里没有检查pos是否为NULL，我认为在最后一个节点之后插入也是可以的if (pos == *pphead){SListPushFront(pphead, x);return;}SListNode* prev = *pphead;while (prev->next!=pos){prev = prev->next;}SListNode* newnode = BuySListNode(x);newnode->next = pos;prev->next = newnode;
}
// 删除pos位置
void SLTErase(SListNode** pphead, SListNode* pos)
{assert(pphead);assert(*pphead);assert(pos);//这里进行检查pos，必须有这个节点才能删除if (pos == *pphead){SListPopFront(pphead);return;}SListNode* prev = *pphead;while (prev->next != pos){prev = prev->next;}prev->next = pos->next;free(pos);pos = NULL;
}
void SLTDestroy(SListNode** pphead)
{assert(pphead);assert(*pphead);SListNode* cur = *pphead;while (cur){SListNode* next = cur->next;free(cur);cur = next;}*pphead = NULL;
}

Test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"
void test1()
{SListNode* SL = NULL;SListPushBack(&SL, 1);SListPushBack(&SL, 2);SListPushBack(&SL, 3);SListPushBack(&SL, 4);SListPushBack(&SL, 5);SListPrint(SL);SListPushFront(&SL, 6);SListPushFront(&SL, 7);SListPushFront(&SL, 8);SListPushFront(&SL, 9);SListPushFront(&SL, 10);SListPushFront(&SL, 99);SListPushFront(&SL, 88);SListPushFront(&SL, 77);SListPrint(SL);SListPopBack(&SL);SListPopBack(&SL);SListPopBack(&SL);SListPopBack(&SL);SListPrint(SL);SListPopFront(&SL);SListPopFront(&SL);SListPopFront(&SL);SListPrint(SL);SListInsertAfter(SListFind(SL, 1), 99);SListInsertAfter(SListFind(SL, 10), 99);SListPrint(SL);SListEraseAfter(SListFind(SL, 1));SListEraseAfter(SListFind(SL, 10));//printf("%d\n", SListFind(SL, 1)->data);SListPrint(SL);SLTInsert(&SL, SListFind(SL, 10), 99);SLTInsert(&SL, NULL, 99);SListPrint(SL);SLTErase(&SL, SListFind(SL, 99));SLTErase(&SL, SListFind(SL, 99));SListPrint(SL);SLTDestroy(&SL);}
int main()
{test1();return 0;
}

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

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

相关文章

【GD32】从零开始学兆易创新32位微处理器——RTC实时时钟+日历例程

【GD32】从零开始学兆易创新32位微处理器——RTC实时时钟+日历例程

1 简介 RTC实时时钟顾名思义作用和墙上挂的时钟差不多&#xff0c;都是用于记录时间和日历&#xff0c;同时也有闹钟的功能。从硬件实现上来说&#xff0c;其实它就是一个特殊的计时器&#xff0c;它内部有一个32位的寄存器用于计时。RTC在低功耗应用中可以说相当重要&#xf…
阅读更多...
stm32学习笔记---OLED调试工具（理论部分和代码部分）

stm32学习笔记---OLED调试工具（理论部分和代码部分）

目录 理论部分 三种常用的程序调试方法 第一种是串口调试 第二种是显示屏调试 第三种是Keil调试模式 其他调试方式 OLED显示屏的介绍 OLED的硬件电路 OLED驱动程序中所包含的驱动函数 OLED_Init(); OLED_Clear(); OLED的显示函数 OLED_ShowChar(1, 1, A); OLED_S…
阅读更多...
【教学类-36-09】20240622钓鱼（通义万相）-A4各种大小的鱼

【教学类-36-09】20240622钓鱼（通义万相）-A4各种大小的鱼

背景需求&#xff1a; 用通义万相获得大量的简笔画鱼的图片&#xff0c;制作成不同大小&#xff0c;幼儿用吸铁石钓鱼的纸片&#xff08;回形针&#xff09;&#xff0c;涂色、排序等 补一张通义万相的鱼图 素材准备 &#xff08;一&#xff09;优质的鱼图片 &#xff08;二&a…
阅读更多...
獭崎酱酒：传承百年酱香，品味经典之选

獭崎酱酒：传承百年酱香，品味经典之选

在中国白酒文化中&#xff0c;酱香型白酒以其独特的风味和精湛的酿造工艺&#xff0c;一直受到广大酒友的青睐。而在众多酱香型白酒品牌中&#xff0c;獭崎酱酒以其传承百年的酱香工艺和高品质的产品&#xff0c;成为了众多酒友心中的经典之选。 　　 | | | |–|–| | | | 百…
阅读更多...
英伟达能保住全球市值第一的桂冠吗？

英伟达能保住全球市值第一的桂冠吗？

内容提要 《巴伦周刊》认为&#xff0c;英伟达市值的迅速上涨是该公司可能难以保持市值第一桂冠的关键原因。另一个担忧是&#xff0c;英伟达的崛起主要基于一项单一技术——为人工智能应用提供动力的芯片和平台。一些人担心&#xff0c;如果购买英伟达产品的公司无法从投资中…
阅读更多...
《机器学习》读书笔记：总结“第3章线性模型”中的概念

《机器学习》读书笔记：总结“第3章线性模型”中的概念

&#x1f4a0;线性模型(linear model) 线性模型(linear model) 试图学得一个通过属性的线性组合来进行预测的函数&#xff0c;即&#xff1a; f ( x ) w 1 x 1 w 2 x 2 . . . w d x d b f(\bold{x})w_1x_1w_2x_2...w_dx_db f(x)w1​x1​w2​x2​...wd​xd​b 向量形式写…
阅读更多...
JAVA复习4

JAVA复习4

目录 44、定义 int x5; 执行 int yx; 和 xy;&#xff0c;x 和 y 分别为&#xff08; B &#xff09;。 45、下列内容描述错误的是&#xff08; C &#xff09;。 46、以下 Java 语句在编译时不通过的是 (A) 47、在 Java 中&#xff0c;Scanner 类提供控制台获取键盘输入的功…
阅读更多...
idea配置本地maven

idea配置本地maven

软件名地址链接说明MavenMaven – Download Apache Maven依赖管理 下载bin.zip 环境变量 测试安装 修改配置文件 本地依赖存储位置 新建文件夹 修改配置 国内镜像源 <mirror><id>alimaven</id><mirrorOf>central</mirrorOf><name>ali…
阅读更多...
Scrivener v3 解锁版安装教程 (写作辅助软件)

Scrivener v3 解锁版安装教程 (写作辅助软件)

前言 Scrivener&#xff0c;一个多功能的写作软件&#xff0c;被世界各地的作家广泛采用&#xff0c;从小说家到剧本家&#xff0c;再到非小说类作家和学术研究者&#xff0c;它的用户群跨越了广泛的领域&#xff0c;包括学生、法律专业人士、记者和翻译。这个软件非常注重用户…
阅读更多...
HTML(18)——浮动

HTML(18)——浮动

标准流 标准流也叫文档流&#xff0c;指的是标签在页面中默认的排布规则&#xff0c;例如&#xff1a;块元素独占一行&#xff0c;行内元素可以一行显示多个 浮动 作用&#xff1a;让块级元素水平排列 属性名&#xff1a;float 属性值 left&#xff1a;左对齐right&#…
阅读更多...
颠覆传统编程：用ChatGPT十倍提升生产力

颠覆传统编程：用ChatGPT十倍提升生产力

我们即将见证一个新的时代&#xff01;这是最好的时代&#xff0c;也是最坏的时代&#xff01; 需求背景 背景&#xff1a; 平时会编写博客&#xff0c;并且会把这个博客上传到github上&#xff0c;然后自己买一个域名挂到github上。 我平时编写的博客会有一些图片来辅助说明的…
阅读更多...
Docker网络介绍

Docker网络介绍

网络是虚拟化技术中最复杂的部分&#xff0c;也是Docker应用中的一个重要环节。 Docker中的网络主要解决容器与容器、容器与外部网络、外部网络与容器之间的互相通信的问题。 这些复杂情况的存在要求Docker有一个强大的网络功能去保障其网络的稳健性。因此&#xff0c;Docker…
阅读更多...
【Linux】了解冯诺伊曼体系结构

【Linux】了解冯诺伊曼体系结构

文章目录 冯诺依曼体系结构概念冯诺依曼体系结构的推导过程理解冯诺依曼体系 冯诺依曼体系结构概念 冯诺依曼结构是现代计算机发展所遵循的基本结构形式之一&#xff0c;其特点是“程序存储&#xff0c;共享数据&#xff0c;顺序执行”。冯诺依曼结构消除了原始计算机体系中&a…
阅读更多...
PCDViewer-5.0.0——开启漫游的世界

PCDViewer-5.0.0——开启漫游的世界

在点云相关的研发和生产中&#xff0c;按Pose进行场景漫游是一个十分有用的功能&#xff0c;它可以快速地检查SLAM建图质量或点云编辑效果。用 ros rviz进行点云漫游是一项不错的选择&#xff0c;但它存在的一定的开发门槛&#xff0c;而且需要安装额外的资源。 PCDViewer-5.0.…
阅读更多...
物理隔离状态下，如何保障数据单向导入的安全性？

物理隔离状态下，如何保障数据单向导入的安全性？

为了保护企业的核心数据&#xff0c;像一些涉密行业会通过物理隔离方式&#xff0c;将网络隔离成内网和外网&#xff0c;比如军工、党政、生物医药、金融等行业&#xff0c;网络隔离后会存在外网数据单向导入内网&#xff0c;内网数据单向导出外网等交互需求。在实施数据单向导…
阅读更多...
Flink-03 Flink Java 3分钟上手 Stream 给 Flink-02 DataStreamSource Socket写一个测试的工具！

Flink-03 Flink Java 3分钟上手 Stream 给 Flink-02 DataStreamSource Socket写一个测试的工具！

代码仓库 会同步代码到 GitHub https://github.com/turbo-duck/flink-demo 当前章节 继续上一节的内容&#xff1a;https://blog.csdn.net/w776341482/article/details/139875037 上一节中&#xff0c;我们需要使用 nc 或者 telnet 等工具来模拟 Socket 流。这节我们写一个 …
阅读更多...
36.Http协议的设计与解析

36.Http协议的设计与解析

Http协议比Redis协议复杂的多，如果程序员自己去实现，工作量大。 Netty已经把Http协议的编解码器实现好了，只需要简单的配置就可以使用。 做一个http的服务端需要HttpServerCodec。 看它继承的父类： 结合了两个类： HttpRequestDecoder(入站处理器extends Channelnbound…
阅读更多...
【网络安全常用术语解读 ：什么是0day、1day、nday漏洞】

【网络安全常用术语解读 ：什么是0day、1day、nday漏洞】

脆弱性攻击的时间窗被称作脆弱性窗口。通常情况下&#xff0c;一个安全漏洞的时间越久&#xff0c;攻击者就会有更多的机会去攻击它。 2. 0day 漏洞 0天漏洞&#xff0c;也被称作"零日漏洞"&#xff0c;是指尚未由供应商公布的缺陷&#xff0c;表示攻击者已知晓该缺…
阅读更多...
FlowUs2024重磅革新预告：RAG技术赋能『问问AI』，笔记变现新纪元等你开启！

FlowUs2024重磅革新预告：RAG技术赋能『问问AI』，笔记变现新纪元等你开启！

&#x1f389; 在FlowUs的广阔天地间&#xff0c;知识的边界被无限拓展&#xff0c;引领着一场场创新与收获的庆典&#xff01;&#x1f680; 随着一年间不断的精进与革新&#xff0c;FlowUs与众多用户并肩前行&#xff0c;在追求极致体验的道路上迈出坚实步伐。步入2024年&am…
阅读更多...
WordPress项目教程：自动采集并发布，让你轻松实现网站内容更新

WordPress项目教程：自动采集并发布，让你轻松实现网站内容更新

随着互联网的发展&#xff0c;越来越多的人开始关注自己的个人网站&#xff0c;通过网站展示自己的才华、分享知识、推广产品等。然而&#xff0c;个人网站的运营并非易事&#xff0c;尤其是内容更新方面。为了解决这个问题&#xff0c;今天我们将为大家推荐一款WordPress插件主…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023