【数据结构】单链表---C语言版

【数据结构】单链表---C语言版

  • 一、顺序表的缺陷
  • 二、链表的概念和结构
    • 1.概念：
  • 三、链表的分类
  • 四、链表的实现
    • 1.头文件：SList.h
    • 2.链表函数：SList.c
    • 3.测试函数：test.c
  • 五、链表应用OJ题
    • 1.移除链表元素
      • （1）题目描述：
      • （2）思路表述：
      • （3）代码实现：
    • 2.翻转一个单链表
      • （1）题目描述：
      • （2）思路表述：
      • （3）代码实现：
    • 3.返回一个链表的中间节点
      • （1）题目描述：
      • （2）思路表述：
      • （3）代码实现：
    • 4.链表中倒数第k个结点
      • （1）题目描述：
      • （2）思路表述：
      • （3）代码实现：
    • 5.合并两个有序链表
      • （1）题目描述：
      • （2）思路表述：
      • （3）代码实现：
    • 6. 链表分割
      • （1）题目描述：
      • （2）思路表述：
      • （3）代码实现：
    • 7. 链表的回文结构
      • （1）题目描述：
      • （2）思路表述：
      • （3）代码实现：
    • 8.相交链表
      • （1）题目描述：
      • （2）思路表述：
      • （3）代码实现：
    • 9.判断链表中是否有环
      • （1）题目描述：
      • （2）思路表述：
      • （3）代码实现：
  • 六、链表和顺序表的优缺点对比

一、顺序表的缺陷

（1）挪动数据时间开销较大：如果是头插或者头删，后面的数据都需要挪动时间复杂度为O（N），这样的代价就比较大。
（2）增容有代价：每次扩容都需要向系统申请空间，然后拷贝数据，然后再释放原来的旧空间，这样对系统的消耗还是不小的。
（3）空间浪费：我们每次空间不够，都会扩大原来空间的二倍，如果我只需要两个字节的空间，但是我扩大了原来100的2倍，那98个字节的空间就浪费了。

但是谁能来解决这个问题呢？那么就是接下来要讲的：链表！
![在这里插入图片描述](https://img-blog.csdnimg.cn/4ce633c0acf64b7f8a1f000bd5a1c4df.pn

二、链表的概念和结构

1.概念：

链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表
中的指针链接次序实现的 。
在这里插入图片描述
现实中的链表就是这样的：
在这里插入图片描述

  1. 从上面的图片我们可以看出链式结构在逻辑上是连续的，但是在物理上它不一定是连续的。
  2. 现实中也就是物理上的节点都是从堆上申请出来的。
  3. 从堆上申请的空间是按照一定的策略来分配的，两次申请的空间：可能连续，也可能不连续。

三、链表的分类

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

1. 单向或者双向：
在这里插入图片描述
2. 带头或者不带头：
在这里插入图片描述
3. 循环或者非循环：
在这里插入图片描述

4.虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：
无头单向非循环链表和带头双向循环链表。
在这里插入图片描述

四、链表的实现

1.头文件：SList.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>typedef int SLTDataType;typedef struct SListNode
{SLTDataType data;struct SListNode* next;
}SLTNode;//打印函数
void SLTPrint(SLTNode* phead);//申请新结点函数
SLTNode* BuySListNode(SLTDataType x);//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x);//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x);//头删
void SLTPopFront(SLTNode** pphead);//尾删
void SLTPopBack(SLTNode** pphead);//单链表查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);// 在pos之前插入x
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);//在pos位置之后插入一个数字x
void SLTInsertAfter(SLTNode* pos, SLTDataType x);//删除POS位置的值
void SLTErase(SLTNode** pphead, SLTNode* pos);//删除POS位置的下一个值
void SLTEraseAfter(SLTNode* pos);

2.链表函数：SList.c

#define _CRT_SECURE_NO_WARNINGS 1 
#include <stdio.h>
#include "SList.h"void SLTPrint(SLTNode* phead)
{SLTNode* cur = phead;while (cur){printf("%d-> ", cur->data);cur = cur->next;}printf("NULL\n");
}SLTNode* BuySListNode(SLTDataType x)
{SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));if (newnode == NULL){perror("malloc fail");exit(-1);}newnode->data = x;newnode->next = NULL;return newnode;
}//头插void SLTPushFront(SLTNode** pphead, SLTDataType x)
{SLTNode* newnode = BuySListNode(x);newnode->next = *pphead;*pphead = newnode;
}//尾插
//如果我要改变指针的指向，我不可能通过传值调用，我只能通过来改变指针的地址，
//也就是用二级指针才能改变结构体指针的指向。
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{SLTNode* newnode = BuySListNode(x);//创建新节点if (*pphead == NULL){// 改变的结构体的指针，所以要用二级指针*pphead = newnode;}else{SLTNode* tail = *pphead;while (tail->next)//tail->next!=NULL{tail = tail->next;}// 改变的结构体，用结构体的指针即可tail->next = newnode;//因为tail->next是结构体中的一个成员}
}//头删
void SLTPopFront(SLTNode** pphead)
{//空：//如果直接指向空指针,那就不用删了assert(*pphead);//非空：// 我们需要运用空瓶思想创建个临时变量来存放，要删那个节点的下一个节点的地址，//要不然删除那个节点之后，下一个节点的地址就连接不上了。SLTNode* newnode = (*pphead)->next;free(*pphead);*pphead = newnode;}//尾删
void SLTPopBack(SLTNode** pphead)
{//1.空assert(*pphead);//1个节点if ((*pphead)->next == NULL){free(*pphead);*pphead = NULL;}//1个以上结点else{//因为是尾删，所以需要一个前摇标志：tailPrevSLTNode* tailPrev = NULL;SLTNode* tail = *pphead;while (tail->next){tailPrev = tail;tail = tail->next;}free(tail);tailPrev->next = NULL;}//方法2//SLTNode* tail = *pphead;//while (tail->next->next)//{//	tail = tail->next;//}//free(tail->next);//tail->next = NULL;
}//查找函数
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{SLTNode* cur = phead;while (cur)//而不是cur->text!=NULL，查找因为我要遍历完！！！{if (cur->data == x){return cur;}cur = cur->next;}return NULL;//当全部都遍历完了，还没找到的话，就直接返回  空 （NULL）
}//在POS之前插入一个结点void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{assert(pphead);assert(pos);//SLTNode* prev = *pphead;if (pos == *pphead){SLTPushFront(pphead, x);}else{SLTNode* prev = *pphead;while (prev->next != pos){prev = prev->next;}SLTNode* newnode = BuySListNode(x);prev->next = newnode;newnode->next = pos;}
}//在pos位置后插入一个数字
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{assert(pos);SLTNode* newnode = BuySListNode(x);//while()为啥不用循环？？？？newnode->next = pos->next;pos->next = newnode;}void SLTErase(SLTNode** pphead, SLTNode* pos)
{assert(pos);if (pos == *pphead){SLTPopFront(pphead);}else{SLTNode* prev = *pphead;while (prev->next != pos){prev = prev->next;}prev->next = pos->next;free(pos);//pos = NULL;}
}//删除pos后位置的一个值
void SLTEraseAfter(SLTNode* pos)
{assert(pos);//检查尾节点是否为空assert(pos->next);//空瓶思想：需要先做一个标记,posnext就是空瓶存放,在pos的下一个位置SLTNode* posNext = pos->next;pos->next = posNext->next;free(posNext);posNext = NULL;}

3.测试函数：test.c

#define _CRT_SECURE_NO_WARNINGS 1 
#include <stdio.h>
#include "SList.h"void TestList1()
{int n=0;printf("请输入链表的长度：");scanf("%d", &n);printf("\n请依次输入每个节点的值：");SLTNode* plist = NULL;for (int i = 0; i < n; i++){int val = 0;scanf("%d", &val);SLTNode* newnode = BuySListNode(val);//头插newnode->next = plist;plist = newnode;}SLTPrint(plist);SLTPushBack(&plist, 10000);SLTPrint(plist);
}//void SLTPushBack(SLTNode** phead, SLTDataType x)
//{
//	//如果我要改变指针的指向，我不可能通过传值调用，我只能通过来改变指针的地址，也就是用二级指针才能改变结构体指针的指向。
//	SLTNode* newnode = BuySListNode(x);
//	SLTNode* tail = phead;
//	while (tail->next)//tail->next!=NULL
//	{
//		tail = tail->next;
//	}
//	tail->next = newnode;
//}//测试尾插
void TestList2()
{SLTNode* plist = NULL;SLTPushBack(&plist, 10);SLTPrint(plist);SLTPushBack(&plist, 20);SLTPrint(plist);SLTPushBack(&plist, 30);SLTPrint(plist);SLTPushBack(&plist, 40);SLTPrint(plist);SLTPushBack(&plist, 50);SLTPrint(plist);
}//测试头插
void TestList3()
{SLTNode* plist = NULL;SLTPushFront(&plist, 10);SLTPrint(plist);SLTPushFront(&plist, 20);SLTPrint(plist);SLTPushFront(&plist, 30);SLTPrint(plist);SLTPushFront(&plist, 40);SLTPrint(plist);SLTPushFront(&plist, 50);SLTPrint(plist);
}//测试尾删
void TestList4()
{SLTNode* plist = NULL;SLTPushFront(&plist, 10);SLTPushFront(&plist, 20);SLTPushFront(&plist, 30);SLTPushFront(&plist, 40);SLTPushFront(&plist, 50);SLTPrint(plist);SLTPopBack(&plist);SLTPrint(plist);SLTPopBack(&plist);SLTPrint(plist);SLTPopBack(&plist);SLTPrint(plist);SLTPopBack(&plist);SLTPrint(plist);SLTPopBack(&plist);SLTPrint(plist);
}//测试头删
void TestList5()
{SLTNode* plist = NULL;SLTPushFront(&plist, 10);SLTPushFront(&plist, 20);SLTPushFront(&plist, 30);SLTPushFront(&plist, 40);SLTPushFront(&plist, 50);SLTPrint(plist);SLTPopFront(&plist);SLTPrint(plist);SLTPopFront(&plist);SLTPrint(plist);SLTPopFront(&plist);SLTPrint(plist);SLTPopFront(&plist);SLTPrint(plist);SLTPopFront(&plist);SLTPrint(plist);
}//测试查找
void TestList6()
{SLTNode* plist = NULL;SLTPushFront(&plist, 10);SLTPushFront(&plist, 20);SLTPushFront(&plist, 30);SLTPushFront(&plist, 40);SLTPushFront(&plist, 50);SLTPrint(plist);SLTNode* pos = SLTFind(plist, 40);if (pos){pos->data *= 10;}SLTPrint(plist);int x = 0;printf("请输入要查找数字的位置：");scanf("%d", &x);pos = SLTFind(plist, x);if (pos){SLTInsert(&plist, pos, x * 10);}SLTPrint(plist);}void TestList7()
{SLTNode* plist = NULL;SLTPushFront(&plist, 10);SLTPushFront(&plist, 20);SLTPushFront(&plist, 30);SLTPushFront(&plist, 40);SLTPushFront(&plist, 50);SLTPrint(plist);int x;printf("请输入你想要查找的数字：");scanf("%d", &x);SLTNode* pos = SLTFind(plist, x);if (pos){SLTInsertAfter(pos, x * 10);}SLTPrint(plist);}void TestList8()
{SLTNode* plist = NULL;SLTPushFront(&plist, 10);SLTPushFront(&plist, 20);SLTPushFront(&plist, 30);SLTPushFront(&plist, 40);SLTPushFront(&plist, 50);SLTPrint(plist);int x = 0;printf("请输入你想要查找的数字：");scanf("%d", &x);SLTNode* pos = SLTFind(plist, x);if (pos){SLTErase(plist, pos);}SLTPrint(plist);
}void TestList9()
{SLTNode* plist = NULL;SLTPushFront(&plist, 10);SLTPushFront(&plist, 20);SLTPushFront(&plist, 30);SLTPushFront(&plist, 40);SLTPushFront(&plist, 50);SLTPrint(plist);int x = 0;printf("请输入你想要查找的数字：");scanf("%d", &x);SLTNode* pos = SLTFind(plist, x);if (pos){SLTEraseAfter(pos);}SLTPrint(plist);}int main()
{//TestList1();//TestList2();//TestList3();//TestList4();//TestList5();//TestList6();//TestList7();TestList8();//TestList9();return 0;
}

五、链表应用OJ题

1.移除链表元素

（1）题目描述：

点击链接
在这里插入图片描述

（2）思路表述：

创建的prev和tmp指针都是用来保存 cur当前节点指针的前一个和后一个：因为如果你直接销毁cur的话，他前一个和后一个连接不起来，所以说你要先创建暂时的节点来保存它。
分类讨论：

  1. 从头往后找，如果没找到要删的目标节点就一直往后走：
    prev->next=cur;
    cur=cur->next;

  2. 如果找到目标节点，这里面还要分为：如果目标节点是在“头”，我们要进行“头删”，如果在除了“头”的其他位置是另一种情况（注意：只要我找到了要删的目标节点，我一定要先保存，当前要删节点的下一个！）

（3）代码实现：

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
struct ListNode* removeElements(struct ListNode* head, int val) 
{struct ListNode* prev=NULL;struct ListNode* cur=head;while(cur){if(cur->val==val)//只要找到了，我就保存！{struct ListNode* tmp=cur->next;//接下来我就要判断了，//1.如果他这个链表里面第1个就是我们要删除的节点。prev==NULL就说明第1个就是目标if(prev==NULL){free(cur);head=tmp;cur=tmp;}else//2.除了头删的其他任意位置！{prev->next=tmp;free(cur);cur=tmp;}}else//没找到就都往下一个走{prev->next=cur;cur=cur->next;}}return head;
}

2.翻转一个单链表

（1）题目描述：

点击链接
在这里插入图片描述

（2）思路表述：

1.在这里插入图片描述
2.在这里插入图片描述
3.
在这里插入图片描述

（3）代码实现：

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
struct ListNode* reverseList(struct ListNode* head) 
{struct ListNode* cur=head;struct ListNode* newhead=NULL;while(cur){//1.保存cur的下一个结点struct ListNode* tmp=cur->next;//2.头插：头插之后一定要记得newhead要往前走一步cur->next=newhead;newhead=cur;//3.原链表中的cur继续往后走！cur=tmp;}return newhead;
}

3.返回一个链表的中间节点

（1）题目描述：

点击链接
在这里插入图片描述

（2）思路表述：

利用两个指针，一个是快指针（fast），一个慢指针（slow），快指针移动的速度是慢指针的二倍！

（3）代码实现：

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
struct ListNode* middleNode(struct ListNode* head) 
{struct ListNode* fast=head;struct ListNode* slow=head;while(fast&&fast->next)//1.fast存在：针对奇数个结点  2.fast—>next存在：针对偶数个结点{fast=fast->next->next;slow=slow->next;}return slow;
}

4.链表中倒数第k个结点

（1）题目描述：

点击链接
在这里插入图片描述

（2）思路表述：

如果要求倒数第k个节点并返回k节点：还是利用快慢指针法，先让fast指针走k步，slow在第一个节点不动，完了之后呢，然后他们再一起走，最后如果fast走到了NULL，那么就直接返回slow就OK了！
自己要尝试画画图

（3）代码实现：

/*** struct ListNode {*	int val;*	struct ListNode *next;* };*//*** * @param pListHead ListNode类 * @param k int整型 * @return ListNode类*/
struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) 
{struct ListNode* fast=pListHead;struct ListNode* slow=pListHead;//fast=(fast->next)*k;//先让fast指针走K步while(k--){if(fast==NULL){return NULL;}fast=fast->next;}while(fast){fast=fast->next;slow=slow->next;}return slow;
}

5.合并两个有序链表

（1）题目描述：

题目链接
在这里插入图片描述

（2）思路表述：

在这里插入图片描述
2.
在这里插入图片描述
3.
在这里插入图片描述
4.
在这里插入图片描述
5.
在这里插入图片描述

（3）代码实现：

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2) 
{struct ListNode* head=NULL;struct ListNode* tail=NULL;//前提：排除如果有一个链表就是空的咋办？if(l1==NULL){return l2;}if(l2==NULL){return l1;}//1.确定好：l1和l2谁为head,tailif(l1->val<l2->val){head=tail=l1;l1=l1->next;}else{head=tail=l2;l2=l2->next;}//2.逐个节点判断while(l1&&l2){if(l1->val<l2->val){tail->next=l1;l1=l1->next;tail=tail->next;}else{tail->next=l2;l2=l2->next;tail=tail->next;}}//3.如果跳出了循环，那么肯定有一个指向了NULLif(l1==NULL){tail->next=l2;}if(l2==NULL){tail->next=l1;}return head;
}

6. 链表分割

（1）题目描述：

点击链接
在这里插入图片描述

（2）思路表述：

分析：申请两个链表，一个放比x小的节点，一个放比x大的节点，最后将大链表链接在小链表末尾即可。

（3）代码实现：

/*
struct ListNode {int val;struct ListNode *next;ListNode(int x) : val(x), next(NULL) {}
};*/
#include <cstddef>
class Partition {public:ListNode* partition(ListNode* pHead, int x) {struct ListNode* cur = pHead;struct ListNode* lhead;struct ListNode* ltail;struct ListNode* ghead;struct ListNode* gtail;lhead= ltail= (struct ListNode*)malloc(sizeof(struct ListNode));ghead= gtail=(struct ListNode*)malloc(sizeof(struct ListNode));while (cur) {if (cur->val < x) {ltail->next = cur;ltail = ltail->next;}else {gtail->next = cur;gtail = gtail->next;}cur = cur->next;}ltail->next = ghead->next;//不置空，会导致死循环gtail->next = NULL;//释放哨兵位，但需先创建结构体保存：lhead的第一个struct ListNode* head = lhead->next;free(lhead);free(ghead);return head;}
};

7. 链表的回文结构

（1）题目描述：

点击链接
在这里插入图片描述

（2）思路表述：

分析：判断链表是否是回文结构，可以结合前面的题：

（1）利用快慢指针找到链表中间结点

（2）将后半部分逆置

（3）将（2）中的链表从第一个节点开始和中间结点开始同时进行访问，如果所有val相等，则链表为回文结构。

（3）代码实现：

/*
struct ListNode {int val;struct ListNode *next;ListNode(int x) : val(x), next(NULL) {}
};*/
class PalindromeList {public:bool chkPalindrome(ListNode* head) {struct ListNode* middleNode(struct ListNode * head);struct ListNode* reverseList(struct ListNode * head);//找到中间节点struct ListNode* middleNode(struct ListNode * head) {struct ListNode* fast = head;struct ListNode* slow = head;while (fast && fast->next) {slow = slow->next;fast = fast->next->next;}return slow;}//将中间节点后的都逆置struct ListNode* reverseList(struct ListNode * head) {struct ListNode* cur = head;struct ListNode* newhead = NULL;while (cur) {//这个next定义一定要在while循环内部，因为每次头插之前都要保存下一个节点的地址!!!struct ListNode* next = cur->next;//头插cur->next = newhead;newhead = cur;cur = next;}return newhead;}struct ListNode* mid = middleNode(head);struct ListNode* rmid = reverseList(mid);//head相当于原来链表的前一半的头指针//rmid相当于原来链表后一半的头指针while (head && rmid) {if (head->val != rmid->val) {return false;}head = head->next;rmid = rmid->next;}return true;}};

8.相交链表

（1）题目描述：

点击链接
在这里插入图片描述

（2）思路表述：

分别计算出L1链表和L2链表的总长度，然后用两个指针，一个是：fast，一个是：slow，让fast先走他们的差值步，让他们处在同一竖直平行线上，然后他们两个一起走，两个指针一起走后如果所指向的节点的值相同，那么就返回这个公共节点，也就是相交节点！

（3）代码实现：

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) 
{//1.极端条件的判断，要么L1为空，要么L2为空，我就返回空，所以说不可能有公共交点。if(headA == NULL || headB == NULL){return NULL;}struct ListNode *curA = headA, *curB = headB;int lenA = 0,lenB = 0;while(curA->next){curA = curA->next;lenA++;}while(curB->next){curB = curB->next;lenB++;}//2.此时此刻两个循环都结束了，current a指向的是最后一个节点，current b也指向最后一个节点，如果他们两个不相等的话，走到最后一个节点还没有公共交点，那么他们两个永远远远不可能会有公共节点，所以说我们直接返回空就ok了。if(curA != curB){return NULL;}//3.此时两个指针都指向数值水平线的平行线上处于同一位置,现在不知道lena大?还是lenb大?所以说我先假设lena大struct ListNode *longList = headA,*shortList = headB;if(lenA < lenB){longList = headB;shortList = headA;}int gap = abs(lenA - lenB);while(gap--){longList = longList->next;}while(longList != shortList){longList = longList->next;shortList = shortList->next;}return longList;
}

9.判断链表中是否有环

（1）题目描述：

点击链接

在这里插入图片描述

（2）思路表述：

分析：

如何判断链表是否有环：使用快慢指针，慢指针一次走1步，快指针一次走2步，如果链表带环，那么快慢同时从链表起始位置开始向后走，一定会在环内相遇，此时快慢指针都有可能在环内打圈，直到相遇；否则，如果链表不带环，那么快指针会先走到链表末尾，慢指针只能在链表末尾追上快指针。

在这里插入图片描述

如果快指针不是一次走2步，而是一次走3步，一次走4步一次走x步呢？能不能判断出链表是否带环呢？

如果快指针一次走两步，当slow从直线中间移动到直线末尾时，fast又走了slow的2倍，因此当slow进环时，fast可能在环的任意位置，具体要看直线有多长，环有多大。在环内，一定是fast追slow，因为fast比slow移动的快。

fast一次走3步：假设slow进环的时候，fast跟slow相差N步，环的长度为C，追击时，slow走1步，fast走3步，每走1次，差距就缩小

在这里插入图片描述

总结：如果slow进环时，slow和fast的差距N是奇数，且环的长度C为偶数(则C-1为奇数，上面举例可以看出差距最小为1或-1)，那么就永远追不上了。

（3）代码实现：

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
bool hasCycle(struct ListNode *head) 
{struct ListNode* slow=head;struct ListNode* fast=head;while(fast&&fast->next){slow=slow->next;fast=fast->next->next;if(fast==slow){return true;}}return false;
}

六、链表和顺序表的优缺点对比

在这里插入图片描述

没有谁好谁坏，不同情况具体对待，相辅相成罢了

好了，今天的分享就到这里了
如果对你有帮助，记得点赞👍+关注哦！
我的主页还有其他文章，欢迎学习指点。关注我，让我们一起学习，一起成长吧！

在这里插入图片描述

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

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

相关文章

京东数据产品推荐-京东数据挖掘-京东平台2023年10月滑雪装备销售数据分析

京东数据产品推荐-京东数据挖掘-京东平台2023年10月滑雪装备销售数据分析

如今&#xff0c;滑雪正成为新一代年轻人的新兴娱乐方式&#xff0c;借助北京冬奥会带来的发展机遇&#xff0c;我国冰雪经济已逐渐实现从小众竞技运动到大众时尚生活方式的升级。由此也带动滑雪相关生意的增长&#xff0c;从滑雪服靴到周边设备&#xff0c;样样都需要消费者掏…
阅读更多...
微信小程序 scrollview 滚动到指定位置

微信小程序 scrollview 滚动到指定位置

在微信小程序中&#xff0c;实现 ScrollView 滚动到指定位置有多种方法&#xff0c;下面将介绍三种主要的实现方式。 一、使用scroll-top属性实现滚动 通过设置 scroll-view 组件的 scroll-top 属性&#xff0c;我们可以实现滚动到指定位置。以下是具体实现方式&#xff1a; …
阅读更多...
基于STM32单片机的智能家居系统设计（论文+源码）

基于STM32单片机的智能家居系统设计（论文+源码）

1.系统设计 基于STM32单片机的智能家居系统设计与实现的具体任务&#xff1a; &#xff08;1&#xff09;可以实现风扇、窗帘、空调、灯光的开关控制&#xff1b; &#xff08;2&#xff09;具有语音识别功能&#xff0c;可以通过语音控制家电&#xff1b; &#xff08;3&a…
阅读更多...
Win中Redis部署与配置

Win中Redis部署与配置

1.下载msi版本 下载传送门 2.双击next-->next安装安装 3.密码配置以及开机自启 在配置文件中配置相应配置进行配置密码以及端口和ip port 6379指定 Redis 监听端口&#xff0c;默认端口为 6379&#xff0c;作者在自己的一篇博文中解释了为什么选用 6379 作为默认端口&…
阅读更多...
计算机网络 一到二章 PPT 复习

计算机网络 一到二章 PPT 复习

啥币老师要隔段时间测试&#xff0c;我只能说坐胡狗吧旁边 第一章 这nm真的会考&#xff0c;我是绷不住的 这nm有五种&#xff0c;我一直以为只有三种 广播帧在后面的学习中经常遇到 虽然老师在上课的过程中并没有太过强调TCP/IP的连接和断开&#xff0c;但我必须强调一下&…
阅读更多...
全新付费进群系统源码 完整版教程

全新付费进群系统源码 完整版教程

首先准备域名和服务器 安装环境&#xff1a;Nginx1.18 MySQL 5.6 php7.2 安装扩展sg11 伪静态thikphp 后台域名/admin账号admin密码123456 代理域名/daili账号admin密码123456 一、环境配置 二、建站上传源代码解压 上传数据库配置数据库信息 三、登入管理后台 后台域名/ad…
阅读更多...
基于yolov2深度学习网络的打电话行为检测系统matlab仿真

基于yolov2深度学习网络的打电话行为检测系统matlab仿真

目录 1.算法运行效果图预览 2.算法运行软件版本 3.部分核心程序 4.算法理论概述 4.1、YOLOv2网络原理 4.2、基于YOLOv2的打电话行为检测 5.算法完整程序工程 1.算法运行效果图预览 2.算法运行软件版本 matlab2022a 3.部分核心程序 .................................…
阅读更多...
人工智能-优化算法之动量法

人工智能-优化算法之动量法

对于嘈杂的梯度&#xff0c;我们在选择学习率需要格外谨慎。 如果衰减速度太快&#xff0c;收敛就会停滞。 相反&#xff0c;如果太宽松&#xff0c;我们可能无法收敛到最优解。 泄漏平均值 小批量随机梯度下降作为加速计算的手段。 它也有很好的副作用&#xff0c;即平均梯度…
阅读更多...
Java---抽象类讲解

Java---抽象类讲解

文章目录 1. 抽象类概述2. 抽象类特点3. 抽象类的成员特点4. 抽象类猫狗应用 1. 抽象类概述 在Java中&#xff0c;一个没有方法体的方法应该定义为抽象方法&#xff1b;而类中如果有抽象方法&#xff0c;该类必须定义为抽象类。 2. 抽象类特点 1. 抽象类和抽象方法必须使用abst…
阅读更多...
C语言进阶指南（14）（部分字符串库函数及其模拟实现）

C语言进阶指南（14）（部分字符串库函数及其模拟实现）

欢迎来到博主的专栏——C语言进阶指南 博主id&#xff1a;reverie_ly 文章目录 1、strlen&#xff08;&#xff09;——字符串长度计算函数自定义strlen函数的实现 2、strcpy——字符串拷贝函数strcpy的模拟实现 3.strcat——字符串追加函数strcat的模拟实现 4、strcmp——字符…
阅读更多...
【计算机毕业设计】nodejs+vue音乐播放器系统 微信小程序83g3s

【计算机毕业设计】nodejs+vue音乐播放器系统 微信小程序83g3s

本系统的设计与实现共包含12个表:分别是配置文件信息表&#xff0c;音乐列表评论表信息表&#xff0c;音乐论坛信息表&#xff0c;歌手介绍信息表&#xff0c;音乐资讯信息表&#xff0c;收藏表信息表&#xff0c;token表信息表&#xff0c;用户表信息表&#xff0c;音乐类型信…
阅读更多...
selenium使用记录

selenium使用记录

本文记录python环境下使用selenium的一些步骤 Step1&#xff1a;安装并配置驱动 pip install selenium # 使用pip在对应python中安装selenium包为了让selenium能调用指定的浏览器&#xff0c;需要下载对应浏览器的驱动程序&#xff08;这里以edge为例子&#xff09; #Firefo…
阅读更多...
DockerCompose修改某个服务的配置(添加或编辑端口号映射)后如何重启单个服务使其生效

DockerCompose修改某个服务的配置(添加或编辑端口号映射)后如何重启单个服务使其生效

场景 docker-compose入门以及部署SpringBootVueRedisMysql(前后端分离项目)以若依前后端分离版为例&#xff1a; docker-compose入门以及部署SpringBootVueRedisMysql(前后端分离项目)以若依前后端分离版为例_docker-compose部署java mysql redis-CSDN博客 上面讲了docker c…
阅读更多...
centos7-docker安装与使用

centos7-docker安装与使用

文章目录 一、docker简介1.1docker应用场景1.2docker的优点1.2.1快速&#xff0c;一致地交付应用程序1.2.2响应式部署和扩展1.2.3在同一硬件上运行更多工作负载 1.2docker的架构 二、docker的安装2.1新系统的环境搭建2.1.1更换yum源 2.2安装docker与卸载2.2.1yum安装docker2.2.…
阅读更多...
SpringBoot——Swagger2 接口规范

SpringBoot——Swagger2 接口规范

优质博文&#xff1a;IT-BLOG-CN 如今&#xff0c;REST和微服务已经有了很大的发展势头。但是&#xff0c;REST规范中并没有提供一种规范来编写我们的对外REST接口API文档。每个人都在用自己的方式记录api文档&#xff0c;因此没有一种标准规范能够让我们很容易的理解和使用该…
阅读更多...
【数据结构】八大排序 (三）

【数据结构】八大排序 (三）

目录 前言&#xff1a; 快速排序 快速排序非递归实现 快速排序特性总结 归并排序 归并排序的代码实现 归并排序的特性总结 计数排序 计数排序的代码实现 计数排序的特性总结 前言&#xff1a; 前文快速排序采用了递归实现&#xff0c;而递归会开辟函数栈帧&#xff0…
阅读更多...
谨慎Apache-Zookeeper-3.5.5以后在CentOS7.X安装的坑

谨慎Apache-Zookeeper-3.5.5以后在CentOS7.X安装的坑

目录 前言 一、现场还原 二、问题诊断 三、问题原因 总结 前言 最近由于项目需要&#xff0c;在服务器上需要搭建Hbase完全分布式集群环境。开发环境&#xff0c;采用的是最小节点的方式进行搭建&#xff08;即3个节点的模式&#xff09;。资源环境列表如下&#xff1a; 序号…
阅读更多...
[Docker]十二.Docker consul集群搭建、微服务部署,Consul集群+Swarm集群部署微服务实战

[Docker]十二.Docker consul集群搭建、微服务部署,Consul集群+Swarm集群部署微服务实战

一.Docker consul集群搭建 Consul 是 Go 语言写的开源的服务发现软件&#xff0c; Consul 具有 服务发现、健康检查、 服务治理、微服务熔断处理 等功能,在微服务中讲过如何搭建consul集群&#xff0c;接下来看看在 Dokcer 中如何去创建搭建consul 集群 1.linux上面部署consul集…
阅读更多...
kafka C++实现生产者

kafka C++实现生产者

文章目录 1 Kafka 生产者的逻辑2 Kafka 的C API2.1 RdKafka::Conf2.2 RdKafka::Message2.3 RdKafka::DeliveryReportCb2.4 RdKafka::Event2.5 RdKafka::EventCb2.6 RdKafka::PartitionerCb2.7 RdKafka::Topic2.8 RdKafka::Producer&#xff08;核心&#xff09; 3 Kafka 生产者…
阅读更多...
系列十八、Spring bean线程安全问题

系列十八、Spring bean线程安全问题

一、概述 我们知道Spring中的bean&#xff0c;默认情况下是单例的&#xff0c;那么Spring中的bean是线程安全的吗&#xff1f;这个需要分情况考虑&#xff0c;bean中是否存在成员变量&#xff1f;bean中的成员变量是怎么处理的&#xff1f;...&#xff0c;针对bean的状态会有不…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023