C/C++ 数据结构 - 链表
1.单链表
https://blog.csdn.net/qq_36806987/article/details/79858957
1 #include<stdio.h>2 #include<stdlib.h>3 4 /*结构体部分*/5 typedef struct Node6 {7 int data; //数值域8 struct Node *next; //指针域9 }N;10 11 N *Init() //初始化单链表12 {13 N *n;14 n = (N *)malloc(sizeof(N));15 n->next = NULL;16 return n;17 }18 19 N* Create(N* n)20 {21 /*通过输入n个数据，创建一个单链表*/22 int x;23 N *p,*r,*l;24 l = r = n;25 printf("输入-1结束\n");26 scanf("%d",&x);27 while(-1 != x )28 {29 p = (N *)malloc(sizeof(N));30 p -> data = x;31 p -> next = NULL;32 r->next = p;33 r = r->next; //指针r始终指向链表中末数据元素所在位置34 scanf("%d",&x);35 }36 return l;37 }38 39 void output(N* n) //输出40 {41 N *p;42 p = n->next;43 while(p)44 {45 printf("%d ",p->data);46 p = p->next;47 }48 printf("\n");49 }50 51 int InsItem(N *L,int item,int x) /*给定的序号来插入*/52 {53 int i = 1;54 N *p,*t;55 p = L;56 t = (N *)malloc(sizeof(N));57 t ->data = item;58 if(L->next==NULL)59 { /*若L为空表且要求将新结点插入到第0个位置*/60 if(x==1)61 {62 L->next=t;63 t->next=NULL;64 return 1;65 }66 }67 while(p->next!=NULL&&i<x)/*查找第i个节点*/68 {69 p = p->next;70 i++;71 }72 if(p->next==NULL&&i<x)/*在表中不存在插入位置i ，找不到，则插入操作失败*/73 {74 return 0;75 }76 else77 {78 t->next = p->next;79 p->next = t;80 return 1;81 }82 }83 84 int DelItem(N *L,int x)//在单链表中删除数据元素85 {86 int i = 1;87 N *p,*q;88 p = L;89 if(L->next==NULL) /*L为空表，无结点可删除*/90 {91 return 0;92 }93 while(p->next!=NULL&&i<x)94 {95 p = p->next;96 i++;97 }98 if(p->next==NULL)/*若没有第i个结点，则删除操作失败*/99 {
100 return 0;
101 }
102 else
103 {
104 q = p->next;
105 p->next = p->next->next;
106 free(q);
107 return 1;
108 }
109 }
110
111 int main()
112 {
113 N* n = Init();
114 n = Create(n);
115 output(n);
116 InsItem(n,5,5);
117 output(n);
118 DelItem(n,5);
119 output(n);
120
121 return 0;
122 }2.双链表
https://blog.csdn.net/qq_16933601/article/details/105351119
1 #include <stdio.h>2 #include <stdlib.h>3 4 typedef struct Node{5 struct Node *pre;6 int data;7 struct Node *next;8 }N;9 10 N *Init()11 {12 N *n;13 n=(N*)malloc(sizeof(N));//鍒涘缓閾捐〃绗竴涓粨鐐癸紙棣栧厓缁撶偣锛?14 n->next = n->pre=NULL;15 return n;16 }17 18 N* Create(N* n)19 {20 /*通过输入n个数据，创建一个单链表*/21 int x;22 N *p,*r,*l;23 l = r = n;24 printf("输入-1结束\n");25 scanf("%d",&x);26 while(-1 != x )27 {28 p = (N *)malloc(sizeof(N));29 p -> data = x;30 p->pre = p -> next = NULL;31 r->next = p;32 p->pre = r;33 r = r->next; //指针r始终指向链表中末数据元素所在位置34 scanf("%d",&x);35 }36 return l;37 }38 39 void output(N* n) //输出40 {41 N *p;42 p = n->next;43 while(p)44 {45 printf("%d ",p->data);46 p = p->next;47 }48 printf("\n");49 }50 51 int InsItem(N *L,int item,int x) /*给定的序号来插入*/52 {53 int i = 1;54 N *p,*t;55 p = L;56 t = (N *)malloc(sizeof(N));57 t ->data = item;58 if(L->next==NULL)59 { /*若L为空表且要求将新结点插入到第0个位置*/60 if(x==1)61 {62 L->next=t;63 t->pre = L;64 t->next=NULL;65 return 1;66 }67 }68 while(p->next!=NULL&&i<x)/*查找第i个节点*/69 {70 p = p->next;71 i++;72 }73 if(p->next==NULL&& i == x)/*在表中不存在插入位置i ，找不到，则插入操作失败*/74 {75 t->next = NULL;76 p->next = t;77 t->pre = p;78 return 1;79 }80 else81 {82 p->next->pre=t;83 t->next=p->next;84 p->next=t;85 t->pre=p;86 return 1;87 }88 }89 90 int DelItem(N *L,int x)//在单链表中删除数据元素91 {92 int i = 0;93 N *p,*q;94 p = L;95 if(L->next==NULL) /*L为空表，无结点可删除*/96 {97 return 0;98 }99 while(p->next!=NULL&&i<x)
100 {
101 p = p->next;
102 i++;
103 }
104 if(p->next==NULL && i == x)/*若没有第i个结点，则删除操作失败*/
105 {
106 p->pre->next = NULL;
107 free(p);
108 return 1;
109 }
110 else
111 {
112 p->pre->next=p->next;
113 p->next->pre=p->pre;
114 free(p);
115 return 1;
116 }
117 }
118
119 int main()
120 {
121 N* n;
122 n = Init();
123 n = Create(n);
124 output(n);
125 InsItem(n,5,5);
126 output(n);
127 DelItem(n,5);
128 output(n);
129
130 return 0;
131 }3.单链表的反转
https://liang.blog.csdn.net/article/details/90116419
1 #include<stdio.h>2 #include<stdlib.h>3 4 typedef int ElemType;5 6 typedef struct Node7 {8 ElemType data; //数值域9 struct Node *next; //指针域
10 }Linklist;
11
12 Linklist *InitList(Linklist *L) //初始化单链表
13 {
14 L = (Linklist *) malloc(sizeof(Linklist));
15 L->next = NULL;
16 return L;
17 }
18
19 Linklist *CreateList(int n)
20 {
21 /*通过输入n个数据，创建一个单链表*/
22 int x,i;
23 Linklist *L,*r,*p;
24 L = InitList(L); //构造头结点
25 r = L;
26 printf("input %d value: ",n);
27 for(i=0;i<n;i++)
28 {
29 scanf("%d",&x);
30 p = (Linklist *)malloc(sizeof(Linklist));
31 p -> data = x;
32 p -> next = NULL;
33 r->next = p;
34 r = r->next; //指针r始终指向链表中末数据元素所在位置
35
36 }
37 return L;
38 }
39
40 //头插法
41 int add_node_head(Linklist* head, Linklist* new_node)
42 {
43 if(NULL == head || NULL == new_node)
44 return -1;
45 new_node->next = head->next;
46 head->next = new_node;
47 return 0;
48 }
49
50 //头插方式1-反转链表
51 Linklist* revert_list(Linklist* head)
52 {
53 if(NULL == head)
54 return NULL;
55
56 Linklist* p = head->next;
57 head->next= NULL;
58 Linklist* tmp = NULL;
59 while(p)
60 {
61 tmp = p->next;
62 add_node_head(head, p);
63 p = tmp;
64 }
65 return head;
66 }
67
68 void output(Linklist *L) //输出
69 {
70 Linklist *p;
71 p = L->next;
72 printf("output element: \n");
73 for(;p!=NULL;p=p->next)
74 {
75 printf(" %d ",p->data);
76 }
77 printf("\n");
78 }
79
80 int main()
81 {
82 Linklist *l = CreateList(6);
83 output(l);
84 l = revert_list(l);
85 output(l);
86
87 return 0;
88 }4.删除链表中的重复元素
https://blog.csdn.net/m0_59938453/article/details/123021127
1 #include<stdio.h>2 #include<stdlib.h>3 4 typedef int ElemType;5 6 typedef struct Node7 {8 ElemType data; //数值域9 struct Node *next; //指针域
10 }Linklist;
11
12 Linklist *InitList(Linklist *L) //初始化单链表
13 {
14 L = (Linklist *) malloc(sizeof(Linklist));
15 L->next = NULL;
16 return L;
17 }
18
19 Linklist *CreateList(int n)
20 {
21 /*通过输入n个数据，创建一个单链表*/
22 int x,i;
23 Linklist *L,*r,*p;
24 L = InitList(L); //构造头结点
25 r = L;
26 printf("input %d value: ",n);
27 for(i=0;i<n;i++)
28 {
29 scanf("%d",&x);
30 p = (Linklist *)malloc(sizeof(Linklist));
31 p -> data = x;
32 p -> next = NULL;
33 r->next = p;
34 r = r->next; //指针r始终指向链表中末数据元素所在位置
35
36 }
37 return L;
38 }
39
40 void output(Linklist *L) //输出
41 {
42 Linklist *p;
43 p = L->next;
44 printf("output element: \n");
45 for(;p!=NULL;p=p->next)
46 {
47 printf(" %d ",p->data);
48 }
49 printf("\n");
50 }
51
52 Linklist* deleteDuplicates(Linklist* head)
53 {
54 //空链表就直接返回空指针
55 if(NULL == head) // 注：在条件判断中，head == NULL 和 !head 所起的作用是一样的。
56 return NULL;
57
58 Linklist* cur = head;
59 while(cur->next) // 注意循环条件
60 {
61 Linklist* next = cur->next;
62 //若相等，则删掉下一个节点
63 if(cur->data == next->data)
64 {
65 cur->next = next->next;
66 free(next);
67 }
68 //若不等，则将下一个节点变为当前节点
69 else
70 cur = cur->next;
71 }
72 return head;
73 }
74
75 int main()
76 {
77 Linklist *l = CreateList(6);
78 output(l);
79 l = deleteDuplicates(l);
80 output(l);
81
82 return 0;
83 }c++实现删除链表的重复元素，把重复的元素全部删除（力扣82题）：
1 #include <iostream>2 #include <vector>3 using namespace std;4 5 typedef struct Node6 {7 int data; 8 struct Node *next; 9 }Linklist;
10
11 class node1{
12 public:
13 Linklist *InitList(Linklist *L){ //初始化单链表
14 L = new Linklist;
15 L->next = NULL;
16 return L;
17 }
18
19 Linklist *CreateList(int n){
20 /*通过输入n个数据，创建一个单链表*/
21 int x,i;
22 Linklist *L,*r,*p;
23 L = InitList(L); //构造头结点
24 r = L;
25 for(i=0;i<n;i++){
26 cin >> x;
27 p = new Linklist;
28 p -> data = x;
29 p -> next = NULL;
30 r->next = p;
31 r = r->next; //指针r始终指向链表中末数据元素所在位置
32 }
33 return L;
34 }
35
36 void output(Linklist *L){ //输出
37 Linklist *p;
38 p = L->next;
39 for(;p!=NULL;p=p->next)
40 cout << p->data;
41 cout << endl;
42 }
43
44 Linklist *deletedup(Linklist *L){
45 Linklist *dumy = new Linklist,*p = dumy;
46 dumy->next = L;
47 while(p->next){
48 Linklist* q = p->next;
49 while(q->next && q->next->data == q->data) q = q->next;
50 if(q == p->next) p = p->next;
51 else p->next = q->next;
52 }
53 return dumy->next;
54 }
55 };
56
57 int main()
58 {
59 node1 n;
60 Linklist *l,*p;
61 l = n.CreateList(5);
62 n.output(l);
63 p = n.deletedup(l);
64 n.output(p);
65
66 return 0;
67 }c++实现 删除链表重复元素，使得重复元素只出现一次（力扣83题）
1 #include <iostream>2 #include <vector>3 using namespace std;4 5 typedef struct Node6 {7 int data; 8 struct Node *next; 9 }Linklist;
10
11 class node1{
12 public:
13 Linklist *InitList(Linklist *L){ //初始化单链表
14 L = new Linklist;
15 L->next = NULL;
16 return L;
17 }
18
19 Linklist *CreateList(int n){
20 /*通过输入n个数据，创建一个单链表*/
21 int x,i;
22 Linklist *L,*r,*p;
23 L = InitList(L); //构造头结点
24 r = L;
25 for(i=0;i<n;i++){
26 cin >> x;
27 p = new Linklist;
28 p -> data = x;
29 p -> next = NULL;
30 r->next = p;
31 r = r->next; //指针r始终指向链表中末数据元素所在位置
32 }
33 return L;
34 }
35
36 void output(Linklist *L){ //输出
37 Linklist *p;
38 p = L->next;
39 for(;p!=NULL;p=p->next)
40 cout << p->data;
41 cout << endl;
42 }
43
44 Linklist *deletedup(Linklist *L){
45 Linklist *p = L;
46 while(p && p->next){
47 Linklist *q = p->next;
48 while(q && q->data == p->data) q = q->next;
49 p->next = q;
50 p = p->next;
51 }
52 return L;
53 }
54 };
55
56 int main()
57 {
58 node1 n;
59 Linklist *l,*p;
60 l = n.CreateList(5);
61 n.output(l);
62 p = n.deletedup(l);
63 n.output(p);
64
65 return 0;
66 }5.链表排序
https://blog.csdn.net/Vectory0213/article/details/79168475
1 #include<stdio.h>2 #include<stdlib.h>3 4 typedef int ElemType;5 6 typedef struct Node7 {8 ElemType data; //数值域9 struct Node *next; //指针域
10 }Linklist;
11
12 Linklist *InitList(Linklist *L) //初始化单链表
13 {
14 L = (Linklist *) malloc(sizeof(Linklist));
15 L->next = NULL;
16 return L;
17 }
18
19 Linklist *CreateList(int n)
20 {
21 /*通过输入n个数据，创建一个单链表*/
22 int x,i;
23 Linklist *L,*r,*p;
24 L = InitList(L); //构造头结点
25 r = L;
26 printf("input %d value: ",n);
27 for(i=0;i<n;i++)
28 {
29 scanf("%d",&x);
30 p = (Linklist *)malloc(sizeof(Linklist));
31 p -> data = x;
32 p -> next = NULL;
33 r->next = p;
34 r = r->next; //指针r始终指向链表中末数据元素所在位置
35
36 }
37 return L;
38 }
39
40 void output(Linklist *L) //输出
41 {
42 Linklist *p;
43 p = L->next;
44 printf("output element: \n");
45 for(;p!=NULL;p=p->next)
46 {
47 printf(" %d ",p->data);
48 }
49 printf("\n");
50 }
51
52 void BubbleSort(Linklist *head)
53 {
54 Linklist *cur,*tail;
55 cur=head;
56 tail=NULL;
57 if(cur==NULL||cur->next==NULL){
58 return;
59 }
60 while(cur!=tail)
61 {
62 while(cur->next!=tail)
63 {
64 if(cur->data > cur->next->data)
65 {
66 int temp=cur->data;
67 cur->data=cur->next->data;
68 cur->next->data=temp;
69 }
70 cur=cur->next;
71 }
72 tail=cur;
73 cur=head;
74 }
75 }
76
77 int main()
78 {
79 Linklist *l = CreateList(6);
80 output(l);
81 BubbleSort(l);
82 output(l);
83
84 return 0;
85 }6.旋转链表（链表的移位） 力扣61题
1 #include<stdio.h>2 #include<stdlib.h>3 4 #include<stdio.h>5 #include<stdlib.h>6 7 typedef int ElemType;8 /*结构体部分*/9 typedef struct Node
10 {
11 ElemType data; //数值域
12 struct Node *next; //指针域
13 }Linklist;
14
15 Linklist *InitList(Linklist *L) //初始化单链表
16 {
17 int x;
18 scanf("%d",&x);
19 L = (Linklist *) malloc(sizeof(Linklist));
20 L->data = x;
21 L->next = NULL;
22 return L;
23 }
24
25 Linklist *CreateList(int n)
26 {
27 /*通过输入n个数据，创建一个单链表*/
28 int x,i;
29 Linklist *L,*r,*p;
30 L = InitList(L); //构造头结点
31 r = L;
32 printf("input %d value: ",n);
33 for(i=0;i<n;i++)
34 {
35 scanf("%d",&x);
36 p = (Linklist *)malloc(sizeof(Linklist));
37 p -> data = x;
38 p -> next = NULL;
39 r->next = p;
40 r = r->next; //指针r始终指向链表中末数据元素所在位置
41
42 }
43 return L;
44 }
45
46 Linklist *rotatRight(Linklist *head,int k)
47 {
48 if(NULL == head) return NULL;
49 Linklist *cur = head;
50 int n = 1;
51 while(cur->next) cur = cur->next;n++;
52 cur->next = head;
53 for(int i = 0;i<n-k%n;i++)
54 {
55 cur = cur->next;
56 }
57 head = cur->next;
58 cur->next = NULL;
59 return head;
60 }
61
62 void output(Linklist *L) //输出
63 {
64 Linklist *p;
65 p = L;
66 printf("output element: \n");
67 for(;p!=NULL;p=p->next)
68 {
69 printf(" %d ",p->data);
70 }
71 printf("\n");
72 }
73
74 int main()
75 {
76 Linklist *l = CreateList(4);
77 output(l);
78 l = rotatRight(l,5);
79 output(l);
80
81 return 0;
82 }7.两数之和（力扣第二题）
创建2个链表，对两个链表对应位进行相加。
1 #include<iostream>2 using namespace std;3 4 typedef struct Node5 {6 int data; 7 struct Node *next; 8 }Linklist;9
10 class node{
11 public:
12 Linklist *InitList(Linklist *L) //初始化单链表
13 {
14 L = new Linklist;
15 L->next = NULL;
16 return L;
17 }
18
19 Linklist *CreateList(int n)
20 {
21 /*通过输入n个数据，创建一个单链表*/
22 int x,i;
23 Linklist *L,*r,*p;
24 L = InitList(L); //构造头结点
25 r = L;
26 for(i=0;i<n;i++)
27 {
28 cin >> x;
29 p = new Linklist;
30 p -> data = x;
31 p -> next = NULL;
32 r->next = p;
33 r = r->next; //指针r始终指向链表中末数据元素所在位置
34 }
35 return L;
36 }
37
38 void output(Linklist *L) //输出
39 {
40 Linklist *p;
41 p = L->next;
42 for(;p!=NULL;p=p->next)
43 {
44 cout << p->data;
45 }
46 cout << endl;
47 }
48
49 Linklist *addtwonumbers(Linklist *l1,Linklist *l2)
50 {
51 Linklist *dumy = new Linklist,*cur = dumy;
52 int sum = 0;
53 while(l1 || l2 || sum){
54 if(l1) sum += l1->data,l1=l1->next;
55 if(l2) sum += l2->data,l2=l2->next;
56 cur->next = new Linklist;
57 cur->data = sum%10;
58 cur = cur->next;
59 sum /= 10;
60 }
61 return dumy->next;
62 }
63 };
64
65 int main()
66 {
67 node n;
68 Linklist *l,*r,*p;
69 l = n.CreateList(3);
70 n.output(l);
71 r = n.CreateList(3);
72 n.output(r);
73 p = n.addtwonumbers(l,r);
74 n.output(p);
75
76 return 0;
77 }8.合并两个有序链表（力扣21题）
1 #include<iostream>2 using namespace std;3 4 typedef struct Node5 {6 int data; 7 struct Node *next; 8 }Linklist;9
10 class node{
11 public:
12 Linklist *InitList(Linklist *L) //初始化单链表
13 {
14 L = new Linklist;
15 L->next = NULL;
16 return L;
17 }
18
19 Linklist *CreateList(int n)
20 {
21 /*通过输入n个数据，创建一个单链表*/
22 int x,i;
23 Linklist *L,*r,*p;
24 L = InitList(L); //构造头结点
25 r = L;
26 for(i=0;i<n;i++)
27 {
28 cin >> x;
29 p = new Linklist;
30 p -> data = x;
31 p -> next = NULL;
32 r->next = p;
33 r = r->next; //指针r始终指向链表中末数据元素所在位置
34 }
35 return L;
36 }
37
38 void output(Linklist *L) //输出
39 {
40 Linklist *p;
41 p = L->next;
42 for(;p!=NULL;p=p->next)
43 {
44 cout << p->data;
45 }
46 cout << endl;
47 }
48
49 Linklist *addtwonumbers(Linklist *l1,Linklist *l2)
50 {
51 Linklist* dumy = new Linklist,*cur = dumy;
52 while(l1 && l2){
53 if(l1->data <=l2->data){
54 cur->next = new Linklist;
55 cur->next->data = l1->data;
56 l1 = l1->next;
57 }else{
58 cur->next = new Linklist;
59 cur->next->data = l2->data;
60 l2 = l2->next;
61 }
62 cur = cur->next;
63 }
64 cur->next = l1 ? l1 : l2;
65 return dumy->next->next;
66 }
67 };
68
69 int main()
70 {
71 node n;
72 Linklist *l,*r,*p;
73 l = n.CreateList(3);
74 n.output(l);
75 r = n.CreateList(3);
76 n.output(r);
77 p = n.addtwonumbers(l,r);
78 n.output(p);
79
80 return 0;
81 }9.删除链表的倒数第N个元素（力扣第十九题）
#include <iostream>
using namespace std;typedef struct Node
{int data; //数值域struct Node *next; //指针域
}Linklist;class node{
public:Linklist *InitList(Linklist *L) //初始化单链表{L = new Linklist;L->next = NULL;return L;}Linklist *CreateList(int n){/*通过输入n个数据，创建一个单链表*/int x,i;Linklist *L,*r,*p;L = InitList(L); //构造头结点r = L;for(i=0;i<n;i++){cin >> x;p = new Linklist;p -> data = x;p -> next = NULL;r->next = p;r = r->next; //指针r始终指向链表中末数据元素所在位置}return L;}void output(Linklist *L) //输出{Linklist *p;p = L->next;for(;p!=NULL;p=p->next){cout << p->data << " ";}cout << endl;}Linklist* removee(Linklist* head,int n){Linklist *dumy = new Linklist;Linklist *slow = dumy,*fast = dumy;dumy->next = head;for(int i = 0;i<n;i++){fast = fast->next;}while(fast->next){slow = slow->next;fast = fast->next;}slow->next = slow->next->next;return dumy->next;}
};int main()
{node n;Linklist *l = n.CreateList(5);n.output(l);l = n.removee(l,4);n.output(l);return 0;
}相关文章：
C/C++ 数据结构 - 链表
1.单链表 https://blog.csdn.net/qq_36806987/article/details/79858957 1 #include<stdio.h>2 #include<stdlib.h>3 4 /*结构体部分*/5 typedef struct Node6 {7 int data; //数值域8 struct Node *next; //指针域9 }N;10 11 N *Init() //初始化单…...
【算法基础】一文掌握十大排序算法，冒泡排序、插入排序、选择排序、归并排序、计数排序、基数排序、希尔排序和堆排序
目录 1 冒泡排序（Bubble Sort） 2 插入排序（Insertion Sort） 3 选择排序（Selection Sort） 4. 快速排序（Quick Sort） 5. 归并排序（Merge Sort） 6 堆排序 …...
：指定数组元素的特定属性进行搜索)
javascript二维数组(3)：指定数组元素的特定属性进行搜索
js中对数组， var data [{“name”: “《西游记》”, “author”: “吴承恩”, “cat”: “A级书刊”, “num”: 3},{“name”: “《三国演义》”, “author”: “罗贯中”, “cat”: “A级书刊”, “num”: 8},{“name”: “《红楼梦》”, “author”: “曹雪芹”,…...
使用Qt进行HTTP通信的方法
文章目录 1 HTTP协议简介1.1 HTTP协议的历史和发展1.2 HTTP协议的特点1.3 HTTP的工作过程1.4 请求报文1.5 响应报文 2 使用Qt进行HTTP通信2.1 Qt的HTTP通信类2.2 HTTP通信过程 3 JSON3.1 cJSON库简介3.2 cJSON库的设计思想和数据结构3.3 cJSON库的使用方法 1 HTTP协议简介 1.1…...
第45节——页面中修改redux里的数据
一、什么是action 在 Redux 中，Action 是一个简单的 JavaScript 对象，用于描述对应应用中的某个事件（例如用户操作）所发生的变化。它包含了一个 type 属性，用于表示事件的类型，以及其他一些可选的数据。 …...
软考 系统架构设计师系列知识点之软件架构风格（2）
接前一篇文章：软考 系统架构设计师系列知识点之软件架构风格（1） 这个十一注定是一个不能放松、保持“紧”的十一。由于报名了全国计算机技术与软件专业技术资格（水平）考试，11月4号就要考试，因此…...
【C++11】Lambda 表达式：基本使用 和 底层原理
文章目录 Lambda 表达式1. 不考虑捕捉列表1.1 简单使用介绍1.2 简单使用举例 2. 捕捉列表 [ ] 和 mutable 关键字2.1 使用方法传值捕捉传引用捕捉 2.2 捕捉方法一览2.3 使用举例 3. lambda 的底层分析 Lambda 表达式 书写格式： [capture_list](parameters) mutabl…...
【网络安全---ICMP报文分析】Wireshark教程----Wireshark 分析ICMP报文数据试验
一，试验环境搭建 1-1 试验环境示例图 1-2 环境准备 两台kali主机（虚拟机） kali2022 192.168.220.129/24 kali2022 192.168.220.3/27 1-2-1 网关配置： 编辑-------- 虚拟网路编辑器 更改设置进来以后 ，先选择N…...
【Docker】Docker的应用包含Sandbox、PaaS、Open Solution以及IT运维概念的详细讲解
前言 Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的容器中,然后发布到任何流行的Linux或Windows操作系统的机器上,也可以实现虚拟化,容器是完全使用沙箱机制,相互之间不会有任何接口。 📕作者简介：热…...
Java Applet基础
Java Applet基础 目录 Java Applet基础 Applet的生命周期 "Hello, World" Applet: Applet 类 Applet的调用 获得applet参数 指定applet参数 应用程序转换成Applet 事件处理 显示图片 播放音频 applet是一种Java程序。它一般运行在支持Java的Web浏览器内。因…...
【记录】IDA｜IDA怎么查看当前二进制文件自动分析出来的内存分布情况（内存范围和读写性）
IDA版本：7.6 背景：我之前一直是直接看Text View里面的地址的首尾地址来判断内存分布情况的，似乎是有点不准确，然后才想到IDA肯定自带查看内存分布情况的功能，而且很简单。 可以通过View-Toolbars-Segments，…...
LIMS实验室信息管理系统源码 基于计算机的数据处理技术、数据存储技术、网络传输技术、自动化仪器分析技术于一体
LIMS 是一个集现代化管理思想与基于计算机的数据处理技术、数据存储技术、网络传输技术、自动化仪器分析技术于一体，以实验室业务和管理工作为核心，遵循实验室管理国际规范，实现对实验室全方位管理的信息管理系统。 LIMS将样品管理、数据管理…...
有效括号相关
相关题目 20. 有效的括号 921. 使括号有效的最少添加 1541. 平衡括号字符串的最少插入次数 32. 最长有效括号 # 20. 有效的括号 class Solution:def isValid(self, s: str) -> bool:stack []for pare in s:if pare in ([{:stack.append(pare)if not stack or (pare ) and…...
浅谈泛型擦除
文章目录 泛型擦除(1)转换泛型表达式(2)转换泛型方法泛型擦除带来的问题 泛型擦除 在编码阶段使用泛型时加上的类型参数，会被编译器在编译阶段去掉，这个过程叫做泛型擦除。 泛型主要用于编译阶段。在编译后生成的Java字节码文件中不包含泛型中的类型信息…...
nodejs+vue校园跑腿系统elementui
购物车品结算,管理个人中心，订单管理，接单处理，商品维护，用户管理，系统管理等功育食5）要求系统运行可靠、性能稳定、界面友好、使用方便。 第三章 系统分析 10 3.1需求分析 10 3.2可行性分析 10 3.2.1技术…...
Redis Cluster Cron调度
返回目录 说明 clusterCron 每秒执行10次clusterCron 内置了一个iteration计数器。每一次运行clusterCron，iteration都加1。当 iteration % 10 0的时候，就会随机选取一个节点，给它发送PING。而由于clusterCron每秒执行10次，所以…...
Redis Cluster Gossip Protocol: Message
返回目录 消息结构 消息头部消息数据（可选）extension（可选） 消息头部 字段定义 Signature: “RCmb” 这4个字符（Redis Cluster message bus 的简称）totalLen: 消息的总字节数version：当前为…...
【JVM】第四篇 垃圾收集器ParNewCMS底层三色标记算法详解
导航 一. 垃圾收集算法详解1. 分代收集算法2. 标记-复制算法3. 标记-清除算法4. 标记-整理算法二. 垃圾收集器详解1. Serial收集器2. Parallel Scavenge收集器3. ParNew收集器4. CMS收集器三. 垃圾收集底层三色标记算法实现原理1. 垃圾收集底层使用三色标记算法的原因?2. 垃圾…...
STM32复习笔记（四）：独立看门狗IWDG
目录 （一）简介 （二）CUBEMX工程配置 （三）相关函数 总结： （一）简介 独立看门狗本质是一种定时器，其作用是监视系统的运行，当系统发生错误&…...
SpringBoot中常用注解的含义
一、方法参数注解 1. PathVariable 通过RequestMapping注解中的 { } 占位符来标识URL中的变量部分 在控制器中的处理方法的形参中使用PathVariable注解去获取RequestMapping中 { } 中传进来的值，并绑定到处理方法定一的形参上。 //请求路径：http://3333…...
在软件开发中正确使用MySQL日期时间类型的深度解析
在日常软件开发场景中，时间信息的存储是底层且核心的需求。从金融交易的精确记账时间、用户操作的行为日志，到供应链系统的物流节点时间戳，时间数据的准确性直接决定业务逻辑的可靠性。MySQL作为主流关系型数据库，其日期时间类型的…...
FFmpeg 低延迟同屏方案
引言 在实时互动需求激增的当下，无论是在线教育中的师生同屏演示、远程办公的屏幕共享协作，还是游戏直播的画面实时传输，低延迟同屏已成为保障用户体验的核心指标。FFmpeg 作为一款功能强大的多媒体框架，凭借其灵活的编解码、数据…...
Swift 协议扩展精进之路：解决 CoreData 托管实体子类的类型不匹配问题（下）
概述 在 Swift 开发语言中，各位秃头小码农们可以充分利用语法本身所带来的便利去劈荆斩棘。我们还可以恣意利用泛型、协议关联类型和协议扩展来进一步简化和优化我们复杂的代码需求。 不过，在涉及到多个子类派生于基类进行多态模拟的场景下，…...
关于nvm与node.js
1 安装nvm 安装过程中手动修改 nvm的安装路径， 以及修改 通过nvm安装node后正在使用的node的存放目录【这句话可能难以理解，但接着往下看你就了然了】 2 修改nvm中settings.txt文件配置 nvm安装成功后，通常在该文件中会出现以下配置&…...
Matlab | matlab常用命令总结
常用命令 一、 基础操作与环境二、 矩阵与数组操作（核心）三、 绘图与可视化四、 编程与控制流五、 符号计算 (Symbolic Math Toolbox)六、 文件与数据 I/O七、 常用函数类别重要提示这是一份 MATLAB 常用命令和功能的总结，涵盖了基础操作、矩阵运算、绘图、编程和文件处理等…...
Spring AI 入门：Java 开发者的生成式 AI 实践之路
一、Spring AI 简介 在人工智能技术快速迭代的今天，Spring AI 作为 Spring 生态系统的新生力量，正在成为 Java 开发者拥抱生成式 AI 的最佳选择。该框架通过模块化设计实现了与主流 AI 服务（如 OpenAI、Anthropic）的无缝对接&…...
06 Deep learning神经网络编程基础 激活函数 --吴恩达
深度学习激活函数详解 一、核心作用 引入非线性：使神经网络可学习复杂模式控制输出范围：如Sigmoid将输出限制在(0,1)梯度传递：影响反向传播的稳定性二、常见类型及数学表达 Sigmoid σ ( x ) = 1 1 +...
招商蛇口 | 执笔CID，启幕低密生活新境
作为中国城市生长的力量，招商蛇口以“美好生活承载者”为使命，深耕全球111座城市，以央企担当匠造时代理想人居。从深圳湾的开拓基因到西安高新CID的战略落子，招商蛇口始终与城市发展同频共振，以建筑诠释对土地与生活的…...
在Mathematica中实现Newton-Raphson迭代的收敛时间算法（一般三次多项式）
考察一般的三次多项式，以r为参数： p[z_, r_] : z^3 (r - 1) z - r; roots[r_] : z /. Solve[p[z, r] 0, z]； 此多项式的根为： 尽管看起来这个多项式是特殊的，其实一般的三次多项式都是可以通过线性变换化为这个形式…...
根目录0xa0属性对应的Ntfs!_SCB中的FileObject是什么时候被建立的----NTFS源代码分析--重要
根目录0xa0属性对应的Ntfs!_SCB中的FileObject是什么时候被建立的 第一部分： 0: kd> g Breakpoint 9 hit Ntfs!ReadIndexBuffer: f7173886 55 push ebp 0: kd> kc # 00 Ntfs!ReadIndexBuffer 01 Ntfs!FindFirstIndexEntry 02 Ntfs!NtfsUpda…...