【数据结构】单链表解析+完整代码（插入、删除、尾插法、头插法、按值和按位查找、前插和后插）带头结点和不带两种实现

news2025/2/28 0:10:59

文章目录

      • 3.1 单链表
        • 3.1.1 单链表的定义
        • 3.1.2 单链表的插入
          • A.按位序插入（带头结点）
          • B.按位序插入（不带头结点）
          • C.指定结点的后插操作
          • D.指定结点的前插操作
        • 3.1.3 单链表的删除
          • A.按位序删除
          • B.删除指定结点
        • 3.1.4 单链表的查找
          • A.按位查找
          • B.按值查找
        • 3.1.5 单链表的建立
          • A.尾插法
          • B.头插法
        • *完整代码 单链表带头结点
        • *完整代码 单链表不带头结点

3.1 单链表

3.1.1 单链表的定义

  • 定义

    线性表的链式存储。

    • 结点结构：data+next（结点自身的数据＋指向后继的指针）

    • 特点：元素分散在内存中，非随机存取的存储结构。

    • 局限性：无法逆向检索，有时不方便。（双链表可双向检索）

//定义单链表节点类型
typedef struct LNode{
    ElemType data; //数据域
    Struct LNode *next; //指针域，指向下一个结点
}LNode,*LinkList;
//注：
//LNode —— 强调返回的是一个结点
//LinkList —— 强调的是一个单链表

  • 初始化——带头结点

    //带头结点初始化
bool InitList(LinkList &L){
    L=(LNode*)malloc(sizeof(LNode)); //为头结点分配内存
    if(L==NULL)return false; //内存不足，分配失败
    L->next=NULL; //头结点后还没有结点
    return true;
}

//带头结点判空
bool Empty(LinkList L){
    if(L->next==NULL)
        return true;
    else
        return false;
}

  • 初始化——不带头结点

    //不带头结点初始化
bool InitList(LinkList &L){
    L=NULL;
    return true;
}

//不带头结点判空
bool Empty(LinkList L){
    if(L==NULL)
        return true;
    else
        return false;
}

  • 带头结点和不带头结点的区别

    • 头结点：不存储数据，只指向链表中第一个结点的位置

    • 不带头结点，写代码麻烦。原因：

      1.带头结点后，链表第一个位置上的结点与其他位置的操作可以一致，不用特殊处理。

      2.空表和非空表的处理得到统一。

3.1.2 单链表的插入
A.按位序插入（带头结点）

  • 将值为e的新结点插入到位置i，步骤：

    1.找到要插入的位置，即第i-1个结点；

    2.在其后插入新结点，插入步骤如图：

bool ListInsert(LinkList &L,int i,ElemType e){
	if(i<1)return false;
    
    LNode *p; //指针p指向当前扫描到的结点
    int j=0; //记录当前p指向第几个结点
    p=L; //初始时，L指向头结点，头结点不存数据
    
    //循环找到第i-1个结点，即要插入的位置
    while(p!=NULL && j<i-1){
        p=p->next;
        j++;
    }
    if(p==NULL)return false;//i值不合法
    
    //插入结点
    LNode *s=(LNode*)malloc(sizeof(LNode)); //为要插入的结点开辟内存
    s->data=e; //将数值复值到新结点数据域
    s->next=p->next; //将新结点和后继结点连接
    p->next=s; //将新结点和前驱连接
    
    return true;
}
  • 时间复杂度： O ( n ) O(n) O(n)
B.按位序插入（不带头结点）

  • 在非第一个插入时，与带头结点相同。但插入第一位时不同，当在第一位插入时要重新赋值头结点。

  • 即在带头结点插入的基础上，插入以下一段即可：

bool ListInsert(LinkList &L,int i,ElemType e){
	if(i<1)return false;
    
    //插入第1个结点的操作与其它结点不同
    if(i==1){
        LNode *s=(LNode*)malloc(sizeof(LNode));
        s->data=e;
        s->next=L;
        L=s; //头指针指向新结点
        return true;
    }
    
    LNode *p; //指针p指向当前扫描到的结点
    int j=0; //记录当前p指向第几个结点
    p=L; //初始时，L指向头结点，头结点不存数据
    
    //循环找到第i-1个结点，即要插入的位置
    while(p!=NULL && j<i-1){
        p=p->next;
        j++;
    }
    if(p==NULL)return false;//i值不合法
    
    //插入结点
    LNode *s=(LNode*)malloc(sizeof(LNode)); //为要插入的结点开辟内存
    s->data=e; //将数值复值到新结点数据域
    s->next=p->next; //将新结点和后继结点连接
    p->next=s; //将新结点和前驱连接
    
    return true;
}
  • 时间复杂度： O ( n ) O(n) O(n)
  • 后续不做特殊说明，则默认为带头结点。
C.指定结点的后插操作

  • 即在指定结点p后，插入元素e。

    相当于在按位序插入的基础上，省去循环查找第i-1个结点的步骤。

bool InsertNextNode(LNode *p,ElemType e){
    if(p==NULL)return false;
    LNode *s=(LNode*)malloc(sizeof(LNode));
    if(s==NULL)return false;
    
    s->data=e;
    s->next=p->next;
    p->next=s;
    return true;
}
  • 时间复杂度： O ( 1 ) O(1) O(1)
D.指定结点的前插操作

  • 方法一：

    传入头结点，遍历链表找到指定节点的前驱结点，再按后插的方式插入。

    • 时间复杂度： O ( n ) O(n) O(n)

  • 方法二： better!

    按后插的方式在指定结点后插入新结点，再交换指定节点和新结点的数值。

    • 时间复杂度： O ( 1 ) O(1) O(1)
    bool InsertPriorNode(LNode *p,ElemType e){
    if(p==NULL)return false;
    LNode *s=(LNode*)malloc(sizeof(LNode));
    if(s==NULL)return false;
    
    s->next=p->next;
    p->next=s; //连接s和p后
    s->data=p->data; //p数据复制到s
    p->data=e; //原s的数据给p
    return true;
}

    或者传入的是新结点，而不是数据时，也同理：

    bool InsertPriorNode(LNode *p,LNode *s){
    if(p==NULL||s==NULL)return false;
    
    s->next=p->next;
    p->next=s; //连接s和p后
    //交换值
    ElemType t=p->data;
    p->data=s->data;
    s->data=t;
    return true;
}
3.1.3 单链表的删除
A.按位序删除

  • 删除第i个结点的步骤

    1.找到要插入位置的前驱结点，即第i-1个结点。（如图，q是要删结点）

    2.将要删除结点从链表中断开，即前驱结点的next指向要删结点的后驱结点。

    3.释放已删除的结点空间。

bool ListDelete(LinkList &L,int i,ElemType &e){
    if(i<1)return false;
    LNode *p;
    p=L; //p从头开始扫描
    int j=0; //当前p指向第几个结点
    while(p!=NULL && j<i-1){
        p=p->next;
        j++;
    }
    if(p==NULL)return false; //i值不合法
    if(p->next==NULL)return false; //i-1后无结点
    
    LNode *q=p->next; //存储要删结点
    e=q->data; //e存储要删结点的值
    p->next=q->next; //将要删结点断开
    free(q);
    return true;
}
  • 时间复杂度： O ( n ) O(n) O(n)
B.删除指定结点

  • 方法：

    与指定结点的前插操作类似。

    1.交换指定结点和其后继结点的数据域；

    2.删除指定结点的后继结点。

    在这里插入图片描述

    • 时间复杂度： O ( 1 ) O(1) O(1)
bool DeleteNode(LNode*p){
    if(p=NULL)return false;
    
    LNode*q=p->next; //q指向指定结点p的后继
    p->data=p->next->data; //与后继结点交换数据
    p->next=q->next; //将q结点断开（q里存的是要删结点的数据）
    free(q);
    return true;
}

  • 注：

    若要删结点是最后一个结点，这样做有空指针的错误，只能用 从表头依次寻找p前驱的方法来删除。

3.1.4 单链表的查找
A.按位查找

  • 查找第i个元素

    从链表第一个开始往后循环查找。

    i是链表中元素下标。

LNode *GetElem(LinkList L,int i){
    if(i<0)return NULL;
    LNode *p=L;
    int j=0;
    while(p!=NULL&&j<i){
        p=p->next;
        j++;
    }
    return p;
}

  • 可以用于按位查找、删除中的封装：

B.按值查找

  • 找到数据域==e的结点

    时间复杂度： O ( n ) O(n) O(n)

LNode* LocateElem(LinkList L,ElemType e){
    LNode *p=L->next;
    while(p!=NULL&&p->data!=e)
        p=p->next;
    return p;
}
3.1.5 单链表的建立
A.尾插法

  • 步骤

    1.建立头结点（初始化）；

    2.定义两个结点：一个指向表头结点s，另一个指向表尾结点r；

    3.循环输入结点值，并为新结点开辟空间；

    4.在表尾结点后插入新结点；

    5.更新表尾结点r，保证r永远指向最后一个结点；

    6.退出循环后，尾结点置空。

LinkList List_TailInsert(LinkList &L){
    int x;
    L=(LNode*)malloc(sizeof(LNode)); //创建头结点
    LNode *s,*r=L; //s始终指向表头结点，r指向表尾结点
    
    scanf("%d",&x);
    while(x!=9999){
        s=(LNode*)malloc(sizeof(LNode)); //创建新结点
        s->data=x;
        r->next=s; //将新结点插入
        r=s; //更新表尾结点的指针，保持r指向最后一个结点
        scanf("%d",&x);
    }
    r->next=NULL; //尾结点指针制空
    return L;
}
B.头插法

  • 注：

    头插法的输入和链表的数据是逆置关系：

LinkList List_HeadInsert(LinkList &L){
    LNode *s;
    int x;
    L=(LNode*)malloc(sizeof(LNode)); //创建头结点
    L->next=NULL; //初始化空链表
    scanf("%d",&x);
    while(x!=9999){
        s=(LNode*)malloc(sizeof(LNode)); //创建新结点
        s->data=x;
        s->next=L->next;
        L->next=s; //更新第一个结点
        scanf("%d",&x);
    }
    return L;
}
*完整代码 单链表带头结点
#include<stdio.h>
#include<stdlib.h>

#define ElemType int

typedef struct LNode {
	ElemType data;
	struct LNode* next;
}LNode,*LinkList;

//初始化
bool InitList(LinkList& L) {
	L = (LNode*)malloc(sizeof(LNode));
	L->next = NULL;
	return true;
}

//求表长
int Length(LinkList L) {
	int len = 0;
	LNode* p = L;
	while (p->next != NULL) {
		len++;
		p = p->next;
	}
	return len;
}

//头插法建立单链表
LinkList List_HeadInsert(LinkList& L) {
	L = (LNode*)malloc(sizeof(LNode));
	L->next = NULL;
	LNode* s;
	int x;
	scanf("%d", &x);
	while (x != 9999) {
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		s->next = L->next;
		L->next = s;
		scanf("%d", &x);
	}
	return L;
}

//尾插法建立单链表
LinkList List_TailInsert(LinkList& L) {
	int x;
	L = (LNode*)malloc(sizeof(LNode)); //创建头结点
	LNode* s, * r = L; //s指向头结点，r指向尾结点
	scanf("%d", &x);
	while (x != 9999) {
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;
		r = s;
		scanf("%d", &x);
	}
	r->next = NULL;
	return L;
}

//按序查找
LNode* GetItem(LinkList& L, int i) {
	LNode* p = L->next; //头结点中没有元素，所以要从next开始算
	int j = 0;
	while (j < i && p != NULL) {
		p = p->next;
		j++;
	}
	return p;
}

//按值查找
int LocateElem(LinkList& L, ElemType e) {
	LNode* p = L;
	int j = 0;
	while (p != NULL && p->data != e) {
		p = p->next;
		j++;
	}
	return j;
}

//按位序插入
bool ListInsert(LinkList& L, int i, ElemType e) {
	if (i < 0)return false;

	LNode* p = L;
	int j = 0;
	while (j < i-1 && p!= NULL) {
		p = p->next;
		j++;
	}
	if (p == NULL)return false;

	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

//指定结点后插操作
bool InsertNextNode(LNode* p, ElemType e) {
	if (p == NULL)return false;

	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

//指定结点前插操作
bool InsertPriorNode(LNode* p, ElemType e) {
	if (p == NULL )return false;

	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->next = p->next;
	p->next = s;
	s->data = p->data;
	p->data = e;
	return true;
}

//按位序删除
bool ListDelete(LinkList& L, int i, ElemType& e) {
	LNode* p = L;
	int j=0;
	while (j < i-1 && p != NULL) {
		p = p->next;
		j++;
	}
	if (p == NULL||p->next==NULL)return false;

	LNode* q = p->next;
	e = q->data;
	p->next = q->next;
	free(q);
	return true;
}

//删除指定结点
bool DeleteNode(LNode* p) {
	if (p == NULL)return false;

	LNode* q = p->next;
	p->data = p->next->data;
	p->next = q->next;
	free(q);
	return true;
}

void PrintList(LinkList& L) {
	LNode* p = L->next;
	while (p != NULL) {
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n\n");
}

void DestroyList(LinkList& L) {
	LNode* p = L;
	while (L) {
		p = L;
		L = L->next;
		free(p);
	}
}

int main() {
	LinkList L;

	printf("头插法建立单链表，输入以9999结束：\n");
	L=List_HeadInsert(L);
	PrintList(L);

	DestroyList(L);
	printf("尾插法建立单链表，输入以9999结束：\n");
	L=List_TailInsert(L);
	PrintList(L);

	printf("求表长：%d\n",Length(L));
	printf("\n");

	printf("按位序插入：\n");
	int pos=1, e=998;
	ListInsert(L, pos, e);
	PrintList(L);

	printf("指定结点的后插操作：\n");
	LNode* p =L->next;
	e = 222;
	InsertNextNode(p, e);
	PrintList(L);

	printf("指定结点的前插操作：\n");
	p = L->next;
	e = 111;
	InsertPriorNode(p, e);
	PrintList(L);

	printf("按值查找：\n");
	printf("查找222的位序是：%d\n", LocateElem(L, 222));
	printf("\n");

	printf("按序查找：\n");
	LNode* q = GetItem(L, 2);
	printf("查找第3个元素值是：%d\n", q->data);
	printf("\n");

	printf("按位序删除：\n");
	int ee;
	ListDelete(L, pos, ee);
	printf("删除的结点值：%d\n", ee);
	PrintList(L);

	printf("按指定结点删除：\n");
	p = L->next;
	DeleteNode(p);
	PrintList(L);
}

在这里插入图片描述

*完整代码 单链表不带头结点
#include<stdio.h>
#include<stdlib.h>

#define ElemType int

typedef struct LNode {
	ElemType data;
	struct LNode* next;
}LNode, * LinkList;

//初始化
bool InitList(LinkList& L) {
	L=NULL;
	return true;
}

//求表长
int Length(LinkList L) {
	int len = 0;
	LNode* p = L;
	while (p!= NULL) {
		len++;
		p = p->next;
	}
	return len;
}

//头插法建立单链表
LinkList List_HeadInsert(LinkList& L) {
	L= NULL;
	LNode* s;
	int x;

	//第一个结点要特殊判断
	scanf("%d", &x);
	L = (LNode*)malloc(sizeof(LNode));
	L->data = x;
	L->next = NULL;

	scanf("%d", &x);
	while (x != 9999) {
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		s->next = L;
		L = s;
		scanf("%d", &x);
	}
	return L;
}

//尾插法建立单链表
LinkList List_TailInsert(LinkList& L) {
	int x;
	L = NULL;

	//第一个结点要特殊判断
	scanf("%d", &x);
	L = (LNode*)malloc(sizeof(LNode));
	L->data = x;
	L->next = NULL;

	LNode* s, * r = L; //s指向头结点，r指向尾结点
	scanf("%d", &x);
	while (x != 9999) {
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;
		r = s;
		scanf("%d", &x);
	}
	r->next = NULL;
	return L;
}

//按序查找
LNode* GetItem(LinkList& L, int i) {
	LNode* p = L;
	int j = 0;
	while (j < i && p != NULL) {
		p = p->next;
		j++;
	}
	return p;
}

//按值查找
int LocateElem(LinkList& L, ElemType e) {
	LNode* p = L;
	int i = 0;
	while (p != NULL && p->data != e) {
		p = p->next;
		i++;
	}
	return i+1;
}

//按位序插入
bool ListInsert(LinkList& L, int i, ElemType e) {
	if (i < 0)return false;

	//插入第1个结点的操作与其它结点不同
	if (i == 1) {
		LNode* s = (LNode*)malloc(sizeof(LNode));
		s->data = e;
		s->next = L;
		L = s; //头指针指向新结点
		return true;
	}

	LNode* p = L;
	int j = 0;
	while (j < i - 1 && p != NULL) {
		p = p->next;
		j++;
	}
	if (p == NULL)return false;

	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

//指定结点后插操作
bool InsertNextNode(LNode* p, ElemType e) {
	if (p == NULL)return false;

	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

//指定结点前插操作
bool InsertPriorNode(LNode* p, ElemType e) {
	if (p == NULL)return false;

	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->next = p->next;
	p->next = s;
	s->data = p->data;
	p->data = e;
	return true;
}

//按位序删除
bool ListDelete(LinkList& L, int i, ElemType& e) {
	if (i < 1)return false;

	//删除第1个结点的操作与其它结点不同
	if (i == 1) {
		e = L->data;
		LNode* s = L;
		L = L->next;
		free(s);
		return true;
	}

	LNode* p = L;
	int j = 0;
	while (j < i - 1 && p != NULL) {
		p = p->next;
		j++;
	}
	if (p == NULL || p->next == NULL)return false;

	LNode* q = p->next;
	e = q->data;
	p->next = q->next;
	free(q);
	return true;
}

//删除指定结点
bool DeleteNode(LNode* p) {
	if (p == NULL)return false;

	LNode* q = p->next;
	p->data = p->next->data;
	p->next = q->next;
	free(q);
	return true;
}

void PrintList(LinkList& L) {
	LNode* p = L;
	while (p != NULL) {
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n\n");
}

void DestroyList(LinkList& L) {
	LNode* p = L;
	while (L) {
		p = L;
		L = L->next;
		free(p);
	}
}

int main() {
	LinkList L;

	printf("头插法建立单链表，输入以9999结束：\n");
	L = List_HeadInsert(L);
	PrintList(L);

	DestroyList(L);
	printf("尾插法建立单链表，输入以9999结束：\n");
	L = List_TailInsert(L);
	PrintList(L);

	printf("求表长：%d\n", Length(L));
	printf("\n");

	printf("按位序插入：\n");
	int pos = 1, e = 998;
	ListInsert(L, pos, e);
	PrintList(L);

	printf("指定结点的后插操作：\n");
	LNode* p = L;
	e = 222;
	InsertNextNode(p, e);
	PrintList(L);

	printf("指定结点的前插操作：\n");
	p = L;
	e = 111;
	InsertPriorNode(p, e);
	PrintList(L);

	printf("按值查找：\n");
	printf("查找222的位序是：%d\n", LocateElem(L, 222));
	printf("\n");

	printf("按序查找：\n");
	LNode* q = GetItem(L, 2);
	printf("查找第3个元素值是：%d\n", q->data);
	printf("\n");


	printf("按位序删除：\n");
	int ee;
	ListDelete(L, pos, ee);
	printf("删除的结点值：%d\n", ee);
	PrintList(L);

	printf("按指定结点删除：\n");
	p = L;
	DeleteNode(p);
	PrintList(L);
}

在这里插入图片描述

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

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

相关文章

jetson nano——编译安装opencv-python==4.3.0.38

jetson nano——编译安装opencv-python==4.3.0.38

目录 1.下载源码&#xff0c;我提供的链接如下&#xff1a;2.解压文件3.安装依赖scikit4.安装opencv-python5.查看opencv-python版本 系统&#xff1a;jetson-nano-jp451-sd-card-image ubuntu 18.04 1.下载源码&#xff0c;我提供的链接如下&#xff1a; 链接&#xff1a;http…
阅读更多...
使用 OpenCV 通过 SIFT 算法进行对象跟踪

使用 OpenCV 通过 SIFT 算法进行对象跟踪

本文介绍如何使用 SIFT 算法跟踪对象 在当今世界&#xff0c;当涉及到对象检测和跟踪时&#xff0c;深度学习模型是最常用的&#xff0c;但有时传统的计算机视觉技术也可能有效。在本文中&#xff0c;我将尝试使用 SIFT 算法创建一个对象跟踪器。 为什么人们会选择使用传统的计…
阅读更多...
如何对比 MySQL 主备数据的一致性？

如何对比 MySQL 主备数据的一致性？

随着业务范围的扩大&#xff0c;很多企业为了保障核心业务的高可用性&#xff0c;选择了 MySQL 主从架构&#xff0c;这一套方案通常具备主备数据同步、数据备份与恢复、读写分离、高可用切换等特性&#xff0c;是一种相当成熟可靠的数据库架构方案。然而这套方案在特定情况下可…
阅读更多...
数电学习笔记——逻辑代数的基本定理

数电学习笔记——逻辑代数的基本定理

目录 一、带入定理 二、反演定理 三、对偶定理 一、带入定理 在任何一个包含变量A的逻辑等式中&#xff0c;若以另外一个逻辑式代入式中所有A的位置&#xff0c;则等式仍然成立。 例1&#xff1a;&#xff08;AB&#xff09;AB 将&#xff08;BC&#xff09;带入等式中所…
阅读更多...
阿里云2024年服务器2核4G配置评测_CPU内存带宽_优惠价格

阿里云2024年服务器2核4G配置评测_CPU内存带宽_优惠价格

阿里云2核4G服务器多少钱一年&#xff1f;2核4G服务器1个月费用多少&#xff1f;2核4G服务器30元3个月、85元一年&#xff0c;轻量应用服务器2核4G4M带宽165元一年&#xff0c;企业用户2核4G5M带宽199元一年。本文阿里云服务器网整理的2核4G参加活动的主机是ECS经济型e实例和u1…
阅读更多...
Python实现时间序列分析进行平稳性检验(ADF和KPSS)和差分去趋势(adfuller和kpss算法)项目实战

Python实现时间序列分析进行平稳性检验(ADF和KPSS)和差分去趋势(adfuller和kpss算法)项目实战

说明&#xff1a;这是一个机器学习实战项目&#xff08;附带数据代码文档视频讲解&#xff09;&#xff0c;如需数据代码文档视频讲解可以直接到文章最后获取。 1.项目背景 时间序列分析中的平稳性检验是评估一个时间序列是否具有稳定的均值和方差。在经济学、金融学以及其他诸…
阅读更多...
计算机专业电影推荐

计算机专业电影推荐

1、《盗梦空间》 上映时间&#xff1a;2010-09-01 故事讲述了一群专业盗梦人的冒险旅程&#xff0c;他们试图在梦境中窃取最珍贵的秘密。但是&#xff0c;在这个精心设计的梦境中&#xff0c;他们面临着越来越多的挑战和危险。 这部电影不仅有令人难以置信的故事情节&#xf…
阅读更多...
nvm安装和使用保姆级教程（详细）

nvm安装和使用保姆级教程（详细）

一、 nvm是什么 &#xff1a; nvm全英文也叫node.js version management&#xff0c;是一个nodejs的版本管理工具。nvm和npm都是node.js版本管理工具&#xff0c;为了解决node.js各种版本存在不兼容现象可以通过它可以安装和切换不同版本的node.js。 二、卸载之前安装的node: …
阅读更多...
Linux的gdb调试

Linux的gdb调试

文章目录 一、编译有调试信息的目标文件二、启动gdb调试文件1、查看内容list/l&#xff1a;l 文件名:行号/函数名&#xff0c;l 行号/函数名2、打断点b&#xff1a;b文件名:行号/函数名&#xff0c;b 行号/函数名 与 查看断点info/i&#xff1a;info b3、删除断点d&#xff1a;…
阅读更多...
字节面试问题

字节面试问题

实现三列布局的方法 第一种&#xff1a;可以使用浮动margin 第二种&#xff1a;浮动BFC <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><meta name"viewport" content"widthdevice-width, in…
阅读更多...
每日OJ题_牛客DD1 连续最大和（IO型OJ）

每日OJ题_牛客DD1 连续最大和（IO型OJ）

目录 牛客DD1 连续最大和 解析代码 牛客DD1 连续最大和 连续最大和_牛客题霸_牛客网 解析代码 #include <climits> #include <iostream> #include <vector> using namespace std; int main() {int n 0;cin >> n;vector<int> arr(n);for (in…
阅读更多...
通过大语言模型理解运维故障：评估和总结

通过大语言模型理解运维故障：评估和总结

张圣林 南开大学软件学院副教授、博士生导师 第六届CCF国际AIOps挑战赛程序委员会主席 在ATC、WWW、VLDB、KDD、SIGMETRICS等国际会议和JSAC、TC、TSC等国际期刊发表高水平论文50余篇。主持国家自然科学基金项目2项&#xff0c;横向项目13项&#xff08;与华为、字节跳动、腾讯…
阅读更多...
【C++11】C++11新特性（上）

【C++11】C++11新特性（上）

1、C11简介 在2003年C标准委员会曾经提交了一份技术勘误表(简称TC1)&#xff0c;使得C03这个名字已经取代了C98称为C11之前的最新C标准名称。不过由于C03(TC1)主要是对C98标准中的漏洞进行修复&#xff0c;语言的核心部分则没有改动&#xff0c;因此人们习惯性的把两个标准合并…
阅读更多...
基于MQTT协议实现微服务架构事件总线

基于MQTT协议实现微服务架构事件总线

一、场景描述 昨天在博客《客户端订阅服务端事件的实现方法》中提出了利用websocket、服务端EventEmitter和客户端mitt实现客户端订阅服务端事件&#xff0c;大大简化了客户端对服务端数据实时响应的逻辑。上述方案适用于单服务节点的情形。 对于由服务集群支撑的微服务架构&…
阅读更多...
前端-DOM树

前端-DOM树

dom树描述网页元素关系的一个专有名词&#xff0c;如html内包含了head、body&#xff0c;而head内包含meta、title、script等&#xff0c;body内包含div等元素&#xff1b;网页所有内容都在document里面&#xff0c;网页内容以树状形式排列&#xff0c;所以称之为dom树 dom树内…
阅读更多...
进制转换md5绕过 [安洵杯 2019]easy_web1

进制转换md5绕过 [安洵杯 2019]easy_web1

打开题目 在查看url的时候得到了一串类似编码的东西&#xff0c;源码那里也是一堆base64&#xff0c;但是转换成图片就是网页上我们看见的那个表情包 ?imgTXpVek5UTTFNbVUzTURabE5qYz0&cmd 我们可以先试把前面的img那串解码了 解码的时候发现长度不够&#xff0c;那我们…
阅读更多...
【Prometheus】基于Altertmanager发送告警到多个接收方、监控各种服务、pushgateway

【Prometheus】基于Altertmanager发送告警到多个接收方、监控各种服务、pushgateway

基于Altertmanager发送报警到多个接收方 一、配置alertmanager-发送告警到qq邮箱1.1、告警流程1.2、告警设置【1】邮箱配置【2】告警规则配置【3】 部署prometheus【4】部署service 二、配置alertmanager-发送告警到钉钉三、配置alertmanager-发送告警到企业微信3.1、注册企业微…
阅读更多...
DTD、XML阐述、XML的两种文档类型约束和DTD的使用

DTD、XML阐述、XML的两种文档类型约束和DTD的使用

目录 ​编辑 一、DTD 什么是DTD&#xff1f; 为什么要使用 DTD&#xff1f; 内部 DTD 声明 具有内部 DTD 的 XML 文档 外部 DTD 声明 引用外部 DTD 的 XML 文档 二、XML 什么是XML&#xff1f; XML 不执行任何操作 XML 和 HTML 之间的区别 XML 不使用预定义的标记…
阅读更多...
AI大预言模型——ChatGPT在地学、GIS、气象、农业、生态、环境等应用

AI大预言模型——ChatGPT在地学、GIS、气象、农业、生态、环境等应用

原文链接&#xff1a;AI大预言模型——ChatGPT在地学、GIS、气象、农业、生态、环境等应用 一开启大模型 1 开启大模型 1)大模型的发展历程与最新功能 2)大模型的强大功能与应用场景 3)国内外经典大模型&#xff08;ChatGPT、LLaMA、Gemini、DALLE、Midjourney、Stable Di…
阅读更多...
Java Web(十一）--JSON Ajax

Java Web(十一）--JSON Ajax

JSON JSon在线文档&#xff1a; JSON 简介 JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式。轻量级指的是跟xml做比较。数据交换指的是客户端和服务器之间业务数据的传递格式。 它基于 ECMAScript (W3C制定的JS规范)的一个子集&#xff0c;采…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023