链表OJ

GDUFE 

在期末前再刷一次链表题  ~

203. 移除链表元素 - 力扣(LeetCode)

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
struct ListNode* removeElements(struct ListNode* head, int val) {struct ListNode* cur = head;struct ListNode*prev = NULL;while(cur){if(cur->val == val){if(cur==head){//头删cur=head->next;free(head);head= cur;}else{prev->next = cur->next;free(cur);cur = prev->next;}}else{//找到val值对应的地址(遍历链表)prev = cur;cur=cur->next;}}return head;
}

206. 反转链表 - 力扣(LeetCode)

struct ListNode* reverseList(struct ListNode* head) {//记录前中后三个位置struct ListNode*prev = NULL;struct ListNode*cur = head;while(cur != NULL){struct Listndoe*nextnode = cur->next;cur->next = prev;prev = cur;cur= nextnode;}head = prev;return head;
}

876. 链表的中间结点 - 力扣(LeetCode)

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
struct ListNode* middleNode(struct ListNode* head) {struct ListNode* cur = head;struct ListNdoe* mid = NULL;int count = 0;while(cur){cur = cur->next;count++;}int n = (count/2);//n为几就需要头删几个while(n-->0){mid = head->next;free(head);head = mid;}return head;
}

19. 删除链表的倒数第 N 个结点 - 力扣(LeetCode)

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {struct ListNode*phead = head;//这个变量用于求出链表结点个数struct ListNode* m = head;struct ListNode* prev = NULL;int count = 1,i = 0;while(phead!=NULL){phead = phead->next;count++;}while(i++<count-n-1){//找到倒数第n个节点prev = m;m = m->next;}if(m==head){//头删head = m->next;free(m);m = NULL;}else{//中间删除prev->next = m->next;free(m);m=NULL;}return head;
}

21. 合并两个有序链表 - 力扣(LeetCode)

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {//若这个地方不判断list是否为空指针,后面部分对tail解引用会报错为空指针解引用if(list1==NULL){return list2;}if(list2==NULL){return list1;}struct ListNode*n1 = list1;struct ListNode*n2 = list2;struct ListNode*head = NULL;struct ListNode*tail = NULL;//tail随时跟随新链表变动while(n1&&n2){if(n1->val >= n2->val){if(head==NULL){//head最开始为NULL,要先赋值head = n2;tail = n2;}else{tail->next = n2;tail = n2;//tail不断往前走,这样就可以不用每次都遍历链表找到尾再插入}n2 = n2->next;}else if(n1->val < n2->val){if(head==NULL){head = n1;tail = n1;}else{tail->next = n1;tail = n1;}n1 = n1->next;}}if(n2){//当n1或者n2其中一空就会跳出来判断tail->next = n2;}else if(n1){tail->next = n1;}return head;
}

现在有一链表的头指针ListNode* pHead,给一定值x,编写一段代码将所有小于x的节点都排在其余点之前,且不改变原来的数据顺序,返回重新排列后的链表头指针

面试题 02.04. 分割链表 - 力扣(LeetCode)

创建两个带哨兵的链表 然后一大放比x大的 一个放比x小的  

/*** Definition for singly-linked list.* public class ListNode {*     int val;*     ListNode next;*     ListNode(int x) { val = x; }* }*/
class Solution {public ListNode partition(ListNode head, int x) {ListNode smlDummy = new ListNode(0),bigDummy = new ListNode(0);ListNode sml = smlDummy,big = bigDummy;while(head!=null){if(head.val<x){sml.next = head;sml = sml.next;}else{big.next = head;big = big.next;}head = head.next;}sml.next = bigDummy.next;big.next = null;return smlDummy.next;}
}

234. 回文链表 - 力扣(LeetCode)

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
bool isPalindrome(struct ListNode* head) {struct ListNode*n = head;struct ListNode*m = head;while(m && m->next){//找到中间的节点的新方法,这个地方循环后中间节点为n,可以自己画图验证n = n->next;m = m->next->next;}//n为中间结点struct ListNode*cur = n;struct ListNode*prev =NULL;struct ListNode*next = n->next;while(cur){//反转链表cur->next = prev;prev = cur;cur = next;if(next){next = next->next;}}//prev 为反转后的头struct ListNode*phead = head;while(phead&&prev){//比较两个链表,当一个链表为NULL的时候就停止if(phead->val!=prev->val){return false;}else{phead= phead->next;prev = prev->next;}}return true;
}

160. 相交链表 - 力扣(LeetCode)

public class Solution {public ListNode getIntersectionNode(ListNode headA, ListNode headB) {ListNode A =headA,B = headB;while(A!=B){A = A!=null?A.next:headB;B =B!=null?B.next:headA;}return A;}
}

将两个递增的有序链表合并为一个递增的有序链表.要求结果链表仍使用原来两个链表的存储空间
不另外占用其他的存储空间.表中不允许有重复的数据. 

/* run this program using the console pauser or add your own getch, system("pause") or input loop *//*思路:La,Lb是工作指针 当La和Lb所指向的元素值不同的时候,较小的值链接到Lc上
La和Lb所指向的元素值相同的时候,将La的值链接到Lc上,Lb上的删掉
*/
#include <iostream>
using namespace std;
// 定义链表结点结构
struct ListNode {int data;ListNode *next;
};// 定义链表头指针类型
typedef ListNode* LinkList;// 合并两个有序链表
void MergeList(LinkList &La, LinkList &Lb, LinkList &Lc) 
{ListNode *pa = La->next; // La 的工作指针,初始化为第一个结点ListNode *pb = Lb->next; // Lb 的工作指针,初始化为第一个结点Lc = La; // 用 La 的头结点作为 Lc 的头结点ListNode *pc = Lc; // Lc 的工作指针while (pa && pb) {if (pa->data < pb->data) {pc->next = pa; // 将 pa 链接在 pc 的后面pc = pa; // pc 指针后移pa = pa->next; // pa 指针后移} else if (pa->data > pb->data) {pc->next = pb; // 将 pb 链接在 pc 的后面pc = pb; // pc 指针后移pb = pb->next; // pb 指针后移} else { // 相等时取 La 中的元素,删除 Lb 中的元素pc->next = pa; // 将 pa 链接在 pc 的后面pc = pa; // pc 指针后移pa = pa->next; // pa 指针后移ListNode *q = pb->next; // 保存 pb 的下一个结点delete pb; // 删除 pb 结点pb = q; // pb 指针后移}}// 插入剩余段pc->next = pa ? pa : pb;// 释放 Lb 的头结点delete Lb;
}int main() {// 测试代码// 创建两个链表 La 和 Lb,并初始化它们LinkList La = new ListNode();La->next = NULL;LinkList Lb = new ListNode();Lb->next = NULL;// 填充链表 LaListNode *p = La;for (int i = 1; i <= 5; i += 2) {ListNode *node = new ListNode();node->data = i;node->next = NULL;p->next = node;p = node;}// 填充链表 Lbp = Lb;for (int i = 2; i <= 6; i += 2) {ListNode *node = new ListNode();node->data = i;node->next = NULL;p->next = node;p = node;}// 打印合并前的链表std::cout << "La: ";for (p = La->next; p != NULL; p = p->next)std::cout << p->data << " ";std::cout << "\nLb: ";for (p = Lb->next; p != NULL; p = p->next)std::cout << p->data << " ";std::cout << "\n";// 合并链表LinkList Lc;MergeList(La, Lb, Lc);// 打印合并后的链表std::cout << "Lc: ";for (p = Lc->next; p != NULL; p = p->next)std::cout << p->data << " ";std::cout << "\n";// 释放链表p = Lc;while (p != NULL) {ListNode *q = p->next;delete p;p = q;}return 0;
}

//3)已知两个链表 A 和 B 分别表示两个集合,其元素递增排列。请设计算法求出 A 与 B
//的交集,并存放于 A 链表中。
//[题目分析]
//只有同时出现在两集合中的元素才出现在结果表中, 合并后的新表使用头指针 Lc 指向。
//pa 和 pb 分别是链表 La 和 Lb 的工作指针, 初始化为相应链表的第一个结点, 从第一个结点开
//始进行比较,当两个链表 La 和 Lb 均为到达表尾结点时,如果两个表中相等的元素时,摘取
//La 表中的元素,删除 Lb 表中的元素;如果其中一个表中的元素较小时,删除此表中较小的
//元素,此表的工作指针后移。当链表 La 和 Lb 有一个到达表尾结点,为空时,依次删除另一
//个非空表中的所有元素。
//

#include <iostream>struct Node {int data;      // 数据Node* next;    // 指向下一个节点的指针// 构造函数Node(int val) : data(val), next(nullptr) {}
};typedef Node* LinkList; // 定义链表类型void Mix(LinkList& La, LinkList& Lb, LinkList& Lc) {Node* pa = La->next;  // 指向链表 La 的当前节点Node* pb = Lb->next;  // 指向链表 Lb 的当前节点Node* pc = La;        // Lc 的工作指针,初始化为 La 的头结点Node* u;              // 用于暂存要删除的节点Lc = La;while (pa && pb) {if (pa->data == pb->data) { // 如果两个节点数据相等(交集部分)pc->next = pa;         // 将当前节点接入结果链表pc = pa;               // pc 指向新接入的节点pa = pa->next;         // pa 向后移动u = pb;                // 暂存要删除的节点 pbpb = pb->next;         // pb 向后移动delete u;              // 删除节点 pb}else if (pa->data < pb->data) {u = pa;                // 暂存要删除的节点 papa = pa->next;         // pa 向后移动delete u;              // 删除节点 pa}else {u = pb;                // 暂存要删除的节点 pbpb = pb->next;         // pb 向后移动delete u;              // 删除节点 pb}}// 处理剩余的节点while (pa) {u = pa;                    // 暂存要删除的节点 papa = pa->next;             // pa 向后移动delete u;                  // 删除节点 pa}while (pb) {u = pb;                    // 暂存要删除的节点 pbpb = pb->next;             // pb 向后移动delete u;                  // 删除节点 pb}pc->next = NULL;            // 置链表尾标记delete Lb;                     // 释放 Lb 的头结点
}

( 4)已知两个链表 A 和 B 分别表示两个集合,其元素递增排列。请设计算法求出两个集
合 A 和 B 的差集(即仅由在 A 中出现而不在 B 中出现的元素所构成的集合) ,并以同样的形
式存储,同时返回该集合的元素个数。
[ 题目分析 ]
求两个集合 A 和 B 的差集是指在 A 中删除 A 和 B 中共有的元素,即删除链表中的相应结
点 , 所以要保存待删除结点的前驱,使用指针 pre 指向前驱结点。 pa 和 pb 分别是链表 La 和
Lb 的工作指针 , 初始化为相应链表的第一个结点,从第一个结点开始进行比较,当两个链表
La 和 Lb 均为到达表尾结点时,如果 La 表中的元素小于 Lb 表中的元素, pre 置为 La 表的工
作指针 pa 删除 Lb 表中的元素;如果其中一个表中的元素较小时,删除此表中较小的元素,
此表的工作指针后移。 当链表 La 和 Lb 有一个为空时, 依次删除另一个非空表中的所有元素.

*
将两个非递减的有序链表合并为一个非递增的有序链表。 要求结果链表仍使用原来
两个链表的存储空间 , 不另外占用其它的存储空间。表中允许有重复的数据。[ 题目分析 ]
合并后的新表使用头指针 Lc 指向, pa 和 pb 分别是链表 La 和 Lb 的工作指针 , 初始化为
相应链表的第一个结点,从第一个结点开始进行比较,当两个链表 La 和 Lb 均为到达表尾结
点时,依次摘取其中较小者重新链接在 Lc 表的表头结点之后,如果两个表中的元素相等,只
摘取 La 表中的元素,保留 Lb 表中的元素。当一个表到达表尾结点,为空时,将非空表的剩
余元素依次摘取,链接在 Lc 表的表头结点之后。*/
#include <iostream>
using namespace std;
void Difference(LinkList& La, LinkList& Lb, int *n) {Node *pa = La->next;  // 指向链表 La 的当前节点Node *pb = Lb->next;  // 指向链表 Lb 的当前节点Node *pre = La;       // pre 为 La 中 pa 所指结点的前驱结点的指针Node *u;              // 用于暂存要删除的节点*n = 0;  // 初始化结果集合中元素个数为 0while (pa && pb) {if (pa->data < pb->data) {pre = pa;     // A 链表中当前结点指针后移pa = pa->next;(*n)++;       // 计数器加一,表示找到一个差集元素} else if (pa->data > pb->data) {pb = pb->next; // B 链表中当前结点指针后移} else { // pa->data == pb->data,即 A 和 B 中当前结点数据相同pre->next = pa->next;  // 删除 A 中当前结点u = pa;pa = pa->next;delete u;  // 释放结点空间}}// 处理 A 中剩余的节点,这些节点都是 A 中独有的元素while (pa) {u = pa;         // 暂存要删除的节点 papa = pa->next;  // pa 向后移动delete u;       // 删除节点 pa(*n)++;         // 计数器加一,表示找到一个差集元素}// 由于 B 中剩余的节点都是不会出现在 A 中的元素,无需处理pre->next = nullptr;  // 置链表尾标记// 释放 Lb 的头结点delete Lb;
}

5)设计算法将一个带头结点的单链表 A 分解为两个具有相同结构的链表 B、C,其中 B
表的结点为 A 表中值小于零的结点,而 C 表的结点为 A 表中值大于零的结点(链表 A 中的元素为非零整数,要求 B、 C 表利用 A 表的结点) 。

[ 题目分析 ]
B 表的头结点使用原来 A 表的头结点,为 C 表新申请一个头结点。从 A 表的第一个结点
开始,依次取其每个结点 p,判断结点 p 的值是否小于 0,利用前插法,将小于 0 的结点插入B 表 , 大于等于 0 的结点插入 C 表。

#include <stdio.h>
#include <stdlib.h>// 定义链表结点结构
typedef struct Node {int data;struct Node *next;
} Node;// 创建新结点
Node* createNode(int data) {Node *newNode = (Node *)malloc(sizeof(Node));if (!newNode) {printf("内存分配失败\n");exit(1);}newNode->data = data;newNode->next = NULL;return newNode;
}// 打印链表
void printList(Node *head) {Node *current = head->next;  // 跳过头结点while (current != NULL) {printf("%d -> ", current->data);current = current->next;}printf("NULL\n");
}// 释放链表内存
void freeList(Node *head) {Node *current = head;Node *next;while (current != NULL) {next = current->next;free(current);current = next;}
}// 分解链表
void splitList(Node *A, Node *B, Node *C) {Node *current = A->next;  // 跳过头结点Node *tailB = B;  // B 表的尾指针Node *tailC = C;  // C 表的尾指针while (current != NULL) {if (current->data < 0) {tailB->next = current;tailB = current;} else if (current->data > 0) {tailC->next = current;tailC = current;}current = current->next;}// 断开 B 和 C 表的最后一个结点tailB->next = NULL;tailC->next = NULL;
}int main() {// 初始化链表 ANode *A = createNode(0);  // 带头结点Node *current = A;int values[] = {3, -1, 5, -2, 8, -6, 7};  // 示例数据for (int i = 0; i < sizeof(values)/sizeof(values[0]); i++) {current->next = createNode(values[i]);current = current->next;}printf("链表 A: ");printList(A);// 初始化链表 B 和 C 的头结点Node *B = createNode(0);  // 带头结点Node *C = createNode(0);  // 带头结点// 分解链表splitList(A, B, C);printf("链表 B: ");printList(B);printf("链表 C: ");printList(C);// 释放链表内存freeList(A);freeList(B);freeList(C);return 0;
}

( 6)设计一个算法,通过一趟遍历在单链表中确定值最大的结点。

//( 6)设计一个算法,通过一趟遍历在单链表中确定值最大的结点。#include <iostream>
#include <climits>struct ListNode {int value;ListNode* next;ListNode(int x) : value(x), next(NULL) {}
};ListNode* findMaxNode(ListNode* head) {if (!head) {return NULL;}ListNode* max_value_node = head;ListNode* current = head->next;while (current) {if (current->value > max_value_node->value) {max_value_node = current;}current = current->next;}return max_value_node;
}int main() {// 创建一个链表用于测试ListNode* node5 = new ListNode(3);ListNode* node4 = new ListNode(1);node4->next = node5;ListNode* node3 = new ListNode(4);node3->next = node4;ListNode* node2 = new ListNode(2);node2->next = node3;ListNode* head = new ListNode(5);head->next = node2;// 调用函数并输出结果ListNode* max_node = findMaxNode(head);if (max_node) {std::cout << "最大值节点的值是: " << max_node->value << std::endl;} else {std::cout << "链表为空" << std::endl;}// 释放分配的内存delete node5;delete node4;delete node3;delete node2;delete head;return 0;
}

( 7)设计一个算法,通过遍历一趟,将链表中所有结点的链接方向逆转,仍利用原表的
存储空间。

// 逆转链表
#include<iostream>
using namespace std;
struct ListNode{int value;ListNode* next;ListNode(int x=0):value(x),next(NULL){}
}; ListNode*reverseList(ListNode*head) {ListNode*prev = NULL;ListNode* current = head;while(current){ListNode*next = current->next;//保存当前节点的下一个节点current->next = prev;//反转当前节点指针;prev = current;//更新prev为当前节点current = next;//移动到下一个节点 }return prev;//prev现在是新的头结点 
}int main()
{//创建一个链表用于测试ListNode*node5 = new ListNode(5);ListNode*node4 = new ListNode(4);node4->next = node5;ListNode*node3 = new ListNode(3);node3->next = node4;ListNode* node2 = new ListNode(2);node2->next = node3;ListNode*head = new ListNode(1);head->next = node2;//打印原链表cout<<"原链表:";ListNode*temp = head;while(temp){cout<<temp->value<<" ";temp = temp->next; } cout<<endl;///调用函数反转链表ListNode*new_head = reverseList(head);//打印反转后的链表cout<<"反转后的链表:";temp = new_head;while(temp){cout<<temp->value<<" ";temp = temp->next;} cout<<endl;//释放分配的内存delete node5;delete node4;delete node3;delete node2;delete head;return 0; } 

 ( 8)设计一个算法,删除递增有序链表中值大于 mink 且小于 maxk 的所有元素( mink
和 maxk 是给定的两个参数,其值可以和表中的元素相同,也可以不同 )。

#include <iostream>struct ListNode {int value;ListNode* next;ListNode(int x) : value(x), next(nullptr) {}
};ListNode* removeElementsInRange(ListNode* head, int mink, int maxk) {// 创建哨兵节点ListNode* dummy = new ListNode(0);dummy->next = head;ListNode* prev = dummy;ListNode* current = head;while (current) {if (current->value > mink && current->value < maxk) {prev->next = current->next; // 跳过当前节点} else {prev = current; // 继续遍历}current = current->next; // 移动到下一个节点}// 更新头节点ListNode* new_head = dummy->next;delete dummy; // 释放哨兵节点的内存return new_head;
}int main() {// 创建一个递增有序链表用于测试ListNode* node5 = new ListNode(6);ListNode* node4 = new ListNode(5);node4->next = node5;ListNode* node3 = new ListNode(4);node3->next = node4;ListNode* node2 = new ListNode(3);node2->next = node3;ListNode* head = new ListNode(1);head->next = node2;int mink = 2;int maxk = 5;// 打印原链表std::cout << "原链表: ";ListNode* temp = head;while (temp) {std::cout << temp->value << " ";temp = temp->next;}std::cout << std::endl;// 调用函数删除指定范围的元素ListNode* new_head = removeElementsInRange(head, mink, maxk);// 打印删除后的链表std::cout << "删除后的链表: ";temp = new_head;while (temp) {std::cout << temp->value << " ";temp = temp->next;}std::cout << std::endl;// 释放分配的内存delete node5;delete node4;delete node3;delete node2;delete head;return 0;
}

( 9)已知 p 指向双向循环链表中的一个结点, 其结点结构为 data 、prior 、next 三个域,
写出算法 change, 交换 p 所指向的结点和它的前缀结点的顺序。

#include <iostream>struct ListNode {int data;ListNode* prior;ListNode* next;ListNode(int x) : data(x), prior(nullptr), next(nullptr) {}
};void change(ListNode* p) {if (p == nullptr || p->prior == nullptr) {return; // 无法交换}ListNode* Q = p->prior; // Q 是 p 的前驱节点ListNode* Q_prior = Q->prior; // Q 的前驱节点ListNode* P_next = p->next; // P 的后继节点// 交换 P 和 Q 的指针if (Q_prior != nullptr) {Q_prior->next = p;}if (P_next != nullptr) {P_next->prior = Q;}p->prior = Q_prior;p->next = Q;Q->prior = p;Q->next = P_next;
}void printList(ListNode* head) {ListNode* temp = head;do {std::cout << temp->data << " ";temp = temp->next;} while (temp != head);std::cout << std::endl;
}int main() {// 创建一个双向循环链表用于测试ListNode* node1 = new ListNode(1);ListNode* node2 = new ListNode(2);ListNode* node3 = new ListNode(3);ListNode* node4 = new ListNode(4);node1->next = node2; node1->prior = node4;node2->next = node3; node2->prior = node1;node3->next = node4; node3->prior = node2;node4->next = node1; node4->prior = node3;ListNode* head = node1;// 打印原链表std::cout << "原链表: ";printList(head);// 调用函数交换 node3 和 node2change(node3);// 打印交换后的链表std::cout << "交换后的链表: ";printList(head);// 释放分配的内存delete node1;delete node2;delete node3;delete node4;return 0;
}

( 10)已知长度为 n 的线性表 A 采用顺序存储结构,请写一时间复杂度为 O(n) 、空间复
杂度为 O(1) 的算法,该算法删除线性表中所有值为 item 的数据元素。

#include <iostream>void removeItem(int* A, int& n, int item) {int j = 0; // j 指向下一个保留的位置for (int i = 0; i < n; ++i) {if (A[i] != item) {A[j] = A[i];++j;}}// 更新数组长度n = j;
}int main() {// 测试数据int A[] = {1, 2, 3, 2, 4, 2, 5};int n = sizeof(A) / sizeof(A[0]);int item = 2;std::cout << "原数组: ";for (int i = 0; i < n; ++i) {std::cout << A[i] << " ";}std::cout << std::endl;// 删除所有值为 item 的元素removeItem(A, n, item);std::cout << "删除后的数组: ";for (int i = 0; i < n; ++i) {std::cout << A[i] << " ";}std::cout << std::endl;return 0;
}

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

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

相关文章

学习笔记——网络管理与运维——SNMP(SNMP版本)

二、SNMP版本 1、SNMP版本 SNMP共有三个版本&#xff1a;SNMPv1、SNMPv2c和SNMPv3。 (1)SNMPv1 1990年5月&#xff0c;RFC1157定义了SNMP的第一个版本SNMPv1。RFC1157提供了一种监口控和管理计算机网络的系统方法。SNMPv1基于团体名认证&#xff0c;安全性较差&#xff0c;…

快速编译安装tensorrt_yolo

快速编译安装 安装 tensorrt_yolo 通过 PyPI 安装 tensorrt_yolo 模块&#xff0c;您只需执行以下命令即可&#xff1a; pip install -U tensorrt_yolo 如果您希望获取最新的开发版本或者为项目做出贡献&#xff0c;可以按照以下步骤从 GitHub 克隆代码库并安装&#xff1a; …

手机天线都去哪里了?

在手机的演变历程中&#xff0c;天线的设计和位置一直是工程师们不断探索和创新的领域。你是否好奇&#xff0c;现在的手机为什么看不到那些曾经显眼的天线了呢&#xff1f; 让我们一起揭开这个谜题。 首先&#xff0c;让我们从基础开始&#xff1a;手机是如何发出电磁波的&…

WDF驱动开发-中断处理(三)

使用中断唤醒设备 当设备转换为低功耗状态时&#xff0c;框架会断开连接 (或报告为非活动) 用于 I/O 处理的中断。 从在 Windows 8.1 上运行的 KMDF 1.13 和 UMDF 2.0 开始&#xff0c;WDF 驱动程序可以创建一个框架中断对象&#xff0c;该对象在设备转换为低功耗状态时保持活…

【QT】实现无边框窗口+可拖动+可调整大小

QT无边框 // 在widget构造中添加如下即可实现无边框 setWindowFlags(Qt::FramelessWindowHint); //设置无边框可拖动 当实现无边框之后&#xff0c;你会发现无法拖动了。 或许我们需要了解下窗口是怎么被拖动的 通过标题栏拖动窗口move窗口位置 因此有两种方案可以解决无法…

Redis—String数据类型及其常用命令详解

文章目录 Redis概述1.Redis-String数据类型概述2.常用命令2.1 SET&#xff1a;添加或者修改已经存在的一个String类型的键值对2.2 GET&#xff1a;根据key获取String类型的value2.3 MSET&#xff1a;批量添加多个String类型的键值对2.4 MGET&#xff1a;根据多个key获取多个Str…

CDN缓存命中率较低可能的原因

背景&#xff1a; 网站使用CDN加速以后&#xff0c;大部分静态文件都将会被离用户较近的CDN边缘节点缓存&#xff0c;由此起到访问加速效果。如果用户访问的文件由CDN节点直接响应&#xff0c;无需回源&#xff0c;则称之为缓存命中。CDN缓存命中率越高&#xff0c;也就意味着…

腾讯云开端口

轻量服务器 由于开发者计划&#xff0c;这些腾讯云 阿里云什么的小vps&#xff0c;是非常之便宜&#xff0c;甚至到了白送的地步&#xff08;小阿&#xff09;&#xff0c;但是作为一个web安全学习者必要的vps操作还是要会的 开启端口 腾讯云的轻量服务器是没有安全组的&…

【服务器02】之阿里云平台

百度一下阿里云官网 点击注册直接使用支付宝注册可以跳过认证 成功登录后&#xff0c;点击产品 点击免费试用 点击勾选 选一个距离最近的 点满GB 注意&#xff1a;一般试用的时用的是【阿里云】&#xff0c;真正做项目时用的是【腾讯云】 现在开始学习使用&#xff1a; 首先…

排序方法——《归并排序》

P. S.&#xff1a;以下代码均在VS2019环境下测试&#xff0c;不代表所有编译器均可通过。 P. S.&#xff1a;测试代码均未展示头文件stdio.h的声明&#xff0c;使用时请自行添加。 博主主页&#xff1a;Yan. yan.                        …

如何使用LangChain自定义agent的制作(1) - 自定义一个可以执行 SQL 查询的 Agent

文章目录 前言一、准备工作梳理一、 安装依赖包二、 设置数据库连接三、 自定义 Agent四、 运行示例五、 完整代码六、使用agent的好处1. **模块化和可重用性**2. **扩展性**3. **简化复杂性**4. **增强可维护性**5. **集成大语言模型的能力**6. **易于扩展到其他任务** 继续思…

Web前端期末项目报告:探索、实践与反思

Web前端期末项目报告&#xff1a;探索、实践与反思 随着Web技术的不断发展&#xff0c;前端开发在软件开发中扮演着越来越重要的角色。本次期末项目&#xff0c;我们致力于构建一个功能完善、用户体验优良的Web应用&#xff0c;以实践所学知识&#xff0c;提升技能水平。接下来…

算法体系-23 第二十三节:暴力递归到动态规划(五)

一 求K次打击之后&#xff0c;英雄把怪兽砍死的概率 1.1 描述 给定3个参数&#xff0c;N&#xff0c;M&#xff0c;K 怪兽有N滴血&#xff0c;等着英雄来砍自己 英雄每一次打击&#xff0c;都会让怪兽流失[0~M]的血量 到底流失多少&#xff1f;每一次在[0~M]上等概率的获得一个…

搭建预约咨询小程序,高效便捷新选择

一、预约咨询小程序是什么&#xff1f; 预约咨询小程序是一款适用于各种生活场景包括医疗、保洁、宠物护理、法律等方面的预约咨询类小程序。 二、这款小程序有什么亮点优势&#xff1f; 预约咨询小程序适用场景广泛&#xff0c;无论是心理咨询、法律咨询&#xff0c;还是宠物…

让图片开口说话的模型Hallo: 基于音频驱动的肖像图像动画,精准唇形同步,支持多种语言和风格

前言 让静态的图片“开口说话”&#xff0c;一直是人们对人工智能的期待。近年来&#xff0c;随着深度学习技术的发展&#xff0c;音频驱动的肖像图像动画技术取得了长足的进步。各种模型涌现&#xff0c;但如何实现精准的唇形同步、保持视频的真实感和流畅性&#xff0c;以及…

变长的时间戳设计

以前的时间戳有32位&#xff0c;以秒为单位&#xff0c;231秒≈68年&#xff0c;从1970年开始&#xff0c;到2038年会出问题。 后来出现的时间戳有64位&#xff0c;以纳秒为单位&#xff0c;263纳秒≈292年。 本次设计的变长时间戳&#xff0c;以32比特为单位&#xff0c;总共…

mysql8.0找不到my.ini

报错问题解释&#xff1a; MySQL 8.0 在Windows系统中通常不需要 my.ini 文件&#xff0c;因为安装程序会在 %PROGRAMDATA%\MySQL\MySQL Server 8.0\ &#xff08;通常是 C:\ProgramData\MySQL\MySQL Server 8.0\&#xff09;创建默认的配置文件。如果你的系统中找不到 my.ini…

Qt中利用QTextBrowser控件设计日志窗口

我们一般使用Qt开发应用程序时&#xff0c;都有将控制台窗口去掉。但是&#xff0c;有时候又需要查看一些调试信息&#xff0c;一般的处理方式是把log写到一个文件中。本文介绍一下日志窗口&#xff0c;可以更方便的查看日志信息。 UI设计 推拽UI控件&#xff0c;修改默认背景…

FFmpeg+SDL2实现音视频播放器项目

一、FFmpeg视频解码器 1.视频解码知识 1).纯净的视频解码流程 压缩编码数据->像素数据。 例如解码H.264&#xff0c;就是“H.264码流->YUV”。 2).一般的视频解码流程 视频码流一般存储在一定的封装格式&#xff08;例如MP4、AVI等&#xff09;中。封装格式中通常还…

反转链表(java精简版)

反转一个单向链表。 public class ReversingLinkedList {static class Node {int val;Node next;public Node(int val) {this.val val;}public boolean hasNext() {return next ! null;}}public static void main(String[] args) {//构造Node head null;Node shift null;for…