C语言数据结构——链表

article/2025/10/5 22:15:24

目录

前言

一、什么是链表

1.1链表的结构和概念

1.2 链表的分类

二、无头单向非循环链表

2.1 创建结构体

2.2 动态申请一个节点

2.3 单链表打印

2.4 单链表尾插/尾删

2.4.1 单链表尾插

 2.4.2 单链表尾删

2.5 单链表头插/头删

2.5.1 头插

2.5.2 头删

2.6 单链表查找

2.7 单链表中间插入/中间删除

2.7.1 中间插入

2.7.2 中间删除

2.8 单链表销毁

三、双向带头循环链表

3.1 结构体的创建

3.2 创造节点

3.3 创建返回链表的头结点(哨兵位)

3.4 双链表打印

3.5 双链表的尾插/尾删

3.5.1 尾插

3.5.2 尾删

3.6 双链表的头插/头删

3.6.1 头插

3.6.2 头删

3.7 双链表的查找

3.8 双链表的中间插入/中间删除

3.8.1 中间插入

3.8.2 中间删除

3.9 双链表的销毁

四、链表和顺序表的区别

五、代码及代码展示

5.1 单向链表

5.1.1 效果展示

 5.1.2 代码

5.2 双向带头循环链表

5.2.1 效果展示

 5.2.2 代码

总结

前言

大家好，本篇文章主要带领大家了解一下什么是链表，链表的两个主要结构，以及链表和顺序表的差别。

一、什么是链表

1.1链表的结构和概念

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

 链表就像是火车，每块空间都独立存在，彼此通过指针相链接。

链表的数据结构如下所示：

 注意：

1.从上图看出，链式结构逻辑上是连续的，但在内存中的存储可能是不连续的。

2.现实中的节点一般都是在堆上面申请的。

3.从堆上面申请空间是有其规律的，两次申请的空间可能连续也可能不连续。

1.2 链表的分类

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

1.单向或者双向

 2.带头(哨兵位)或者不带头

 3.循环或者非循环

 8种链表结构分别是：单向链表，单向带头，单向循环，单向带头循环，双向链表，双向带头，双向循环，双向带头循环

其中最常用的有两个分别是单向链表，双向带头循环链表。

 1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等

2.带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。

接下来我们就带领大家实现这两个最常用的链表结构

ps：建议大家在完成链表时，每完成一个功能都测试一下，以免最后调bug调崩溃

二、无头单向非循环链表

本次链表我们将其分成三个文件SList.c，SList.h，test.c，分别用来实现，声明，测试。

ps：链表的全部代码以及效果展示会在文章末尾贴出

2.1 创建结构体

创建结构体，其中有两个成员，一个用来存储数据，一个用来指向下一个空间，并将其名字定义为SListNode方便后续使用

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

2.2 动态申请一个节点

申请节点我们用malloc函数，申请成功后返回空间地址，需要注意此时未和其他节点链接

// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x)
{SListNode* ptr = (SListNode*)malloc(sizeof(SListNode));if (ptr == NULL){perror("malloc");exit(-1);}SListNode* Phead = ptr;Phead->data = x;Phead->next = NULL;return Phead;}

2.3 单链表打印

先写打印的函数，方便后续测试，将链表遍历一遍即可

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

2.4 单链表尾插/尾删

2.4.1 单链表尾插

先判断链表是否为空，为空则直接为其创建一个节点即可，不为空则需要遍历到最后一个节点进行插入。

 

// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x)
{if (*pplist == NULL){*pplist=BuySListNode(x);}else{SListNode* tail = *pplist;while (tail->next){tail = tail->next;}tail->next = BuySListNode(x);}
}

 2.4.2 单链表尾删

尾删也就是尾插反着来即可，但是需要判断是否为空，为空则无法删除

// 单链表的尾删
void SListPopBack(SListNode** pplist)
{assert(*pplist);SListNode* tail = *pplist;while (tail->next->next){tail = tail->next;}free(tail->next);tail->next = NULL;
}

2.5 单链表头插/头删

2.5.1 头插

 

 

// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x)
{if (*pplist == NULL){*pplist = BuySListNode(x);}else{SListNode* cur = BuySListNode(x);cur->next = *pplist;*pplist = cur;}
}

2.5.2 头删

// 单链表头删
void SListPopFront(SListNode** pplist)
{assert(*pplist);SListNode* cur = *pplist;*pplist = cur->next;free(cur);
}

2.6 单链表查找

单链表查找主要是为了后面的中间插入删除，需要先找到要删的位置，遍历一遍链表就可以

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

2.7 单链表中间插入/中间删除

由于单链表只能从前往后走，而想要从中间位置插入或者删除数据，则需要改变前一个结构体的指针，所以只能插入或者删除指定位置后面的数据。

2.7.1 中间插入

 

// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDateType x)
{assert(pos);SListNode* a=BuySListNode(x);SListNode* cur = pos->next;pos->next = a;a->next = cur;}

2.7.2 中间删除

// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos)
{assert(pos);if (pos->next == NULL){return;}SListNode* cur = pos->next;pos->next = cur->next;free(cur);
}

2.8 单链表销毁

遍历一遍，一个一个释放即可

// 单链表的销毁
void SListDestroy(SListNode** pplist)
{assert(*pplist);while (*pplist){SListNode* cur = (*pplist)->next;free(*pplist);*pplist = cur;}*pplist = NULL;
}

三、双向带头循环链表

本次链表我们将其分成三个文件List.c，List.h，test.c，分别用来实现，声明，测试。

ps：链表的全部代码以及效果展示会在文章末尾贴出

3.1 结构体的创建

创建结构体，其中有三个成员，一个用来存放数据，另外两个指针，分别指向前一个空间和后一个空间

// 带头+双向+循环链表增删查改实现
typedef int LTDataType;
typedef struct ListNode
{LTDataType _data;struct ListNode* _next;struct ListNode* _prev;
}ListNode;

3.2 创造节点

创造节点我们仍用malloc函数

//创造节点
ListNode* BuyLTNode(LTDataType x)
{ListNode* cur = (ListNode*)malloc(sizeof(ListNode));if (cur == NULL){perror("malloc");exit(-1);}cur->_data = x;return cur;}

3.3 创建返回链表的头结点(哨兵位)

当创建哨兵位时，我们一般将其中的数据赋为0，而且创建哨兵位的时候，链表只有哨兵位一个数据，所以其前后指针都指向自己以达到循环的目的。

// 创建返回链表的头结点.
ListNode* ListCreate()
{ListNode* head = BuyLTNode(0);head->_next = head;//循环列表创建头时头的首尾都指向自己head->_prev = head;return head;
}

3.4 双链表打印

从头的下一个节点开始遍历，当重新遍历到头部时，说明遍历完成。

// 双向链表打印
void ListPrint(ListNode* pHead)
{assert(pHead);ListNode* cur = pHead->_next;while (cur!=pHead){printf("%d->", cur->_data);cur = cur->_next;}printf("head\n");
}

3.5 双链表的尾插/尾删

3.5.1 尾插

// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x)
{assert(pHead);ListNode* newnode = BuyLTNode(x);newnode->_prev = pHead->_prev;//要尾插的节点的prev指向原来的尾节点newnode->_next = pHead;//要尾插的节点的next指向头pHead->_prev->_next = newnode;//原来的尾节点的next指向新尾pHead->_prev = newnode;//头的prev指向新尾}

3.5.2 尾删

// 双向链表尾删
void ListPopBack(ListNode* pHead)
{assert(pHead);assert(pHead->_next!=pHead);ListNode* tail = pHead->_prev;//用一个指针保存尾巴tail->_prev->_next = pHead;//将倒数第二个节点的next指向头pHead->_prev = tail->_prev;//头节点的prev指向倒数第二节点free(tail);}

3.6 双链表的头插/头删

3.6.1 头插

// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x)
{assert(pHead);ListNode* newnode = BuyLTNode(x);newnode->_next = pHead->_next;//新空间的next指向原来的第一个数据newnode->_prev = pHead;//新空间的prev指向头pHead->_next->_prev = newnode;//原来的的一个数据的prev指向newnodepHead->_next = newnode;//头的next指向newnode
}

3.6.2 头删

// 双向链表头删
void ListPopFront(ListNode* pHead)
{assert(pHead);assert(pHead->_next != pHead);//先判断链表中除了头有无其他数据ListNode* oldnode = pHead->_next;//将要删除的数据的位置保存起来，以防后面丢失pHead->_next = oldnode->_next;//头的next指向第二个数据oldnode->_next->_prev = pHead;//第二个数据的prev指向头free(oldnode);//释放数据空间即可
}

3.7 双链表的查找

主要是为后面的中间插入删除服务

// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x)
{assert(pHead);ListNode* cur = pHead->_next;while (cur != pHead){if (cur->_data == x){return cur;}cur = cur->_next;}return NULL;
}

3.8 双链表的中间插入/中间删除

3.8.1 中间插入

要插入指定位置，其实就是插入到指定位置的前面即可

// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x)
{assert(pos);//调整pos newnode pos前面的数据这三个空间的prev和next即可ListNode* newnode = BuyLTNode(x);ListNode* prev = pos->_prev;prev->_next = newnode;newnode->_prev = prev;newnode->_next = pos;pos->_prev = newnode;
}

3.8.2 中间删除

// 双向链表删除pos位置的节点
void ListErase(ListNode* pos)
{assert(pos);ListNode* prev = pos->_prev;ListNode* next = pos->_next;free(pos);prev->_next = next;next->_prev = prev;}

3.9 双链表的销毁

// 双向链表销毁
void ListDestory(ListNode* pHead)
{assert(pHead);ListNode* cur = pHead->_next;ListNode* next = cur->_next;while (cur != pHead)//先释放除头以外的所有节点，再释放头{free(cur);cur = next;next = next->_next;}free(cur);
}

四、链表和顺序表的区别

 顺序表：

优点：尾删尾插效率高，访问随机下标快

缺点：空间不够需扩容（扩容代价大）；头插头删及中间插入删除需要挪动数据，效率低

链表

优点：需要扩容时，按需申请小块空间；任意位置插入效率都高（O(1)）

缺点：不支持下标随机访问

五、代码及代码展示

5.1 单向链表

5.1.1 效果展示

 5.1.2 代码

SList.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "SList.h"
// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x)
{SListNode* ptr = (SListNode*)malloc(sizeof(SListNode));if (ptr == NULL){perror("malloc");exit(-1);}SListNode* Phead = ptr;Phead->data = x;Phead->next = NULL;return Phead;}
// 单链表打印
void SListPrint(SListNode* plist)
{SListNode* tail = plist;while (tail){printf("%d->", tail->data);tail = tail->next;}printf("NULL\n");
}
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x)
{if (*pplist == NULL){*pplist=BuySListNode(x);}else{SListNode* tail = *pplist;while (tail->next){tail = tail->next;}tail->next = BuySListNode(x);}
}
// 单链表的尾删
void SListPopBack(SListNode** pplist)
{assert(*pplist);SListNode* tail = *pplist;while (tail->next->next){tail = tail->next;}free(tail->next);tail->next = NULL;
}
// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x)
{if (*pplist == NULL){*pplist = BuySListNode(x);}else{SListNode* cur = BuySListNode(x);cur->next = *pplist;*pplist = cur;}
}
// 单链表头删
void SListPopFront(SListNode** pplist)
{assert(*pplist);SListNode* cur = *pplist;*pplist = cur->next;free(cur);
}
// 单链表查找
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* a=BuySListNode(x);SListNode* cur = pos->next;pos->next = a;a->next = cur;}
// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos)
{assert(pos);if (pos->next == NULL){return;}SListNode* cur = pos->next;pos->next = cur->next;free(cur);
}
// 单链表的销毁
void SListDestroy(SListNode** pplist)
{assert(*pplist);while (*pplist){SListNode* cur = (*pplist)->next;free(*pplist);*pplist = cur;}*pplist = NULL;
}

SList.h

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <assert.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 SListPopBack(SListNode** pplist);
// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x);
// 单链表头删
void SListPopFront(SListNode** pplist);
// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x);
// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDateType x);
// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos);
// 单链表的销毁
void SListDestroy(SListNode** pplist);

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "SList.h"void menu()
{printf("*******************************\n");printf("****1.尾部插入  2.尾部删除 ****\n");printf("****3.头部插入  4.头部删除 ****\n");printf("****5.中间插入  6.中间删除 ****\n");printf("****7.打印      0.退出     ****\n");printf("*******************************\n");}int main()
{menu();SListNode* Phead = NULL;int input;do{printf("请选择:");scanf("%d", &input);switch (input){case 1:printf("请输入要写入的数字：");SLTDateType i;scanf("%d", &i);SListPushBack(&Phead,i);break;case 2:SListPopBack(&Phead);break;case 3:printf("请输入要写入的数字：");SLTDateType a;scanf("%d", &a);SListPushFront(&Phead, a);break;case 4:SListPopFront(&Phead);break;case 5:printf("会将数据插入进输入数字之后的位置\n");printf("请输入要插入位置的数字及要插入的数字：");SLTDateType b, j;scanf("%d %d", &b, &j);SListNode* ret1 = SListFind(Phead, b);if (ret1 != NULL){SListInsertAfter(ret1, j);}else{printf("该数字不存在");}break;case 6:printf("请输入要删除的数字之前的数字:");SLTDateType c;scanf("%d", &c);SListNode* ret2 = SListFind(Phead, c);if (ret2 != NULL){SListEraseAfter(ret2);}else{printf("未找到该数字");}break;case 7:SListPrint(Phead);break;case 0:printf("退出");SListDestroy(&Phead);break;default:printf("输入错误，请重新输入");break;}} while (input);return 0;
}

5.2 双向带头循环链表

5.2.1 效果展示

 5.2.2 代码

List.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "List.h"
// 创建返回链表的头结点.
ListNode* ListCreate()
{ListNode* head = BuyLTNode(0);head->_next = head;//循环列表创建头时头的首尾都指向自己head->_prev = head;return head;
}
//创造节点
ListNode* BuyLTNode(LTDataType x)
{ListNode* cur = (ListNode*)malloc(sizeof(ListNode));if (cur == NULL){perror("malloc");exit(-1);}cur->_data = x;return cur;}
// 双向链表打印
void ListPrint(ListNode* pHead)
{assert(pHead);ListNode* cur = pHead->_next;while (cur!=pHead){printf("%d->", cur->_data);cur = cur->_next;}printf("head\n");
}
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x)
{assert(pHead);ListNode* newnode = BuyLTNode(x);newnode->_prev = pHead->_prev;//要尾插的节点的prev指向原来的尾节点newnode->_next = pHead;//要尾插的节点的next指向头pHead->_prev->_next = newnode;//原来的尾节点的next指向新尾pHead->_prev = newnode;//头的prev指向新尾}
// 双向链表尾删
void ListPopBack(ListNode* pHead)
{assert(pHead);assert(pHead->_next!=pHead);ListNode* tail = pHead->_prev;//用一个指针保存尾巴tail->_prev->_next = pHead;//将倒数第二个节点的next指向头pHead->_prev = tail->_prev;//头节点的prev指向倒数第二节点free(tail);}
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x)
{assert(pHead);ListNode* newnode = BuyLTNode(x);newnode->_next = pHead->_next;//新空间的next指向原来的第一个数据newnode->_prev = pHead;//新空间的prev指向头pHead->_next->_prev = newnode;//原来的的一个数据的prev指向newnodepHead->_next = newnode;//头的next指向newnode
}
// 双向链表头删
void ListPopFront(ListNode* pHead)
{assert(pHead);assert(pHead->_next != pHead);//先判断链表中除了头有无其他数据ListNode* oldnode = pHead->_next;//将要删除的数据的位置保存起来，以防后面丢失pHead->_next = oldnode->_next;//头的next指向第二个数据oldnode->_next->_prev = pHead;//第二个数据的prev指向头free(oldnode);//释放数据空间即可
}
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x)
{assert(pHead);ListNode* cur = pHead->_next;while (cur != pHead){if (cur->_data == x){return cur;}cur = cur->_next;}return NULL;
}
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x)
{assert(pos);//调整pos newnode pos前面的数据这三个空间的prev和next即可ListNode* newnode = BuyLTNode(x);ListNode* prev = pos->_prev;prev->_next = newnode;newnode->_prev = prev;newnode->_next = pos;pos->_prev = newnode;
}
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos)
{assert(pos);ListNode* prev = pos->_prev;ListNode* next = pos->_next;free(pos);prev->_next = next;next->_prev = prev;}
// 双向链表销毁
void ListDestory(ListNode* pHead)
{assert(pHead);ListNode* cur = pHead->_next;ListNode* next = cur->_next;while (cur != pHead)//先释放除头以外的所有节点，再释放头{free(cur);cur = next;next = next->_next;}free(cur);
}

List.h

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
// 带头+双向+循环链表增删查改实现
typedef int LTDataType;
typedef struct ListNode
{LTDataType _data;struct ListNode* _next;struct ListNode* _prev;
}ListNode;
//创造节点
ListNode* BuyLTNode(LTDataType x);
// 创建返回链表的头结点.
ListNode* ListCreate();
// 双向链表销毁
void ListDestory(ListNode* pHead);
// 双向链表打印
void ListPrint(ListNode* pHead);
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x);
// 双向链表尾删
void ListPopBack(ListNode* pHead);
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x);
// 双向链表头删
void ListPopFront(ListNode* pHead);
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x);
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "List.h"
void menu()
{printf("*******************************\n");printf("****1.尾部插入  2.尾部删除 ****\n");printf("****3.头部插入  4.头部删除 ****\n");printf("****5.中间插入  6.中间删除 ****\n");printf("****7.打印      0.退出     ****\n");printf("*******************************\n");}int main()
{menu();ListNode* head = ListCreate();int input;do{printf("请选择:");scanf("%d", &input);switch (input){case 1:printf("请输入要写入的数字：");LTDataType i;scanf("%d", &i);ListPushBack(head, i);break;case 2:ListPopBack(head);break;case 3:printf("请输入要写入的数字：");LTDataType a;scanf("%d", &a);ListPushFront(head, a);break;case 4:ListPopFront(head);break;case 5:printf("会将数据插入进输入数字之前的位置\n");printf("请输入要插入位置的数字及要插入的数字：");LTDataType b,j;scanf("%d %d", &b,&j);ListNode* ret1 = ListFind(head, b);if (ret1 != NULL){ListInsert(ret1, j);}else{printf("该数字不存在");}break;case 6:printf("请输入要删除的数字:");LTDataType c;scanf("%d", &c);ListNode* ret2 = ListFind(head, c);if (ret2 != NULL){ListErase(ret2);}else{printf("未找到该数字");}break;case 7:ListPrint(head);break;case 0:printf("退出");ListDestory(head);break;default:printf("输入错误，请重新输入");break;}} while (input);return 0;
}

总结

以上就是今天文章的内容，希望铁子们可以有所收货。


http://chatgpt.dhexx.cn/article/SGujpHGK.shtml

相关文章

C语言链表详解（通俗易懂）

C语言链表详解（通俗易懂）

文章目录 前言一、什么是线性表&#xff1f;二、顺序表&#xff1a;三、链表&#xff1a;四、顺序表和链表对比&#xff1a;总结 前言 线性表是实际中广泛应用的重要数据结构&#xff0c;本文用通俗易懂的方法讲解它。 一、什么是线性表&#xff1f; 首先&#xff0c;我们了解…
阅读更多...
C语言——链表

C语言——链表

C语言——链表 链表是一种基础的数据结构类型&#xff0c;一种能够动态维护数据的线性数据表。链表的数据以结点形式存储信息&#xff0c;并通过结点之间的指针实现结点之间的衔接。 为什么要用链表&#xff1f; 链表和数组类似&#xff0c;但是功能比数组强大得多&#xff0c…
阅读更多...
在？您的rsyslog日志管理手册到了，请查收

在？您的rsyslog日志管理手册到了，请查收

rsyslog日志管理和logrotate日志存储轮转 前言&#xff1a; 系统日志是记录服务器系统运行和软件运行状况的记录程序&#xff0c;如果系统和软件在运行中出错&#xff0c;我们就可以在日志中获取到问题发生时的记录&#xff0c;并以此寻求解决问题的方法。 一.rsyslog 系统日…
阅读更多...
日志审计与分析实验三（rsyslog服务器端和客户端配置）（Linux日志收集）

日志审计与分析实验三（rsyslog服务器端和客户端配置）（Linux日志收集）

文章目录 Linux日志收集一、实验目的&#xff1a;1、掌握rsyslog配置方法2、配置rsyslog服务收集其他Linux服务器日志: 二、实验步骤&#xff1a;1、前期配置2. rsyslog的三种传输协议1、udp传输方式2、tcp传输方式3、relp传输方式 Linux日志收集 一、实验目的&#xff1a; 1…
阅读更多...
Linux系统之rsyslog配置

Linux系统之rsyslog配置

目录 Rsyslog简介 Linux配置rsyslog 配置实验&#xff1a; 实验环境&#xff1a; 实验步骤&#xff1a; 实验准备&#xff1a; 针对UDP&#xff1a; 针对TCP&#xff1a; 针对RELP&#xff1a; 结果验证&#xff1a; 1、UDP&#xff1a; 2、TCP&#xff1a; 3、RE…
阅读更多...
rSyslog日志

rSyslog日志

日志服务管理 系统日志管理 系统日志介绍 日志的作用&#xff1a; 软件的运行记录软件运行排错运行分析 日志记录的内容包括&#xff1a; 历史事件&#xff1a;时间&#xff0c;地点&#xff0c;人物&#xff0c;事件日志级别&#xff1a;事件的关键性程度&#xff0c;Lo…
阅读更多...
Linux rsyslog详细介绍

Linux rsyslog详细介绍

转自&#xff1a;http://llei623.blog.163.com/blog/static/852075042010111482731766/ 作者&#xff1a;llei WEB服务器多的时候检查日志是一件痛苦的事情&#xff0c;用 perl 脚本登录到服务器上grep一些错误信息两次之后就觉得是纯体力活&#xff0c;想办法偷懒。 准备弄…
阅读更多...
Linux系统日志rsyslogd

Linux系统日志rsyslogd

Linux系统日志rsyslogd Linux系统日志 Linux上使用rsyslogd守护进程接收用户进程输出的日志和接收内核日志。 用户进程是通过syslogd函数生成系统日志。该函数将日志输出到一个UNIX本地域socket类型(AF_UNIX&#xff09;的文件/dev/log中&#xff0c;rsyslogd则监听该文件以…
阅读更多...
Linux之 rsyslog、日志轮转

Linux之 rsyslog、日志轮转

1.rsyslog 1.1rsyslog介绍 Rsyslog的全称是 rocket-fast system for log&#xff0c;它提供了高性能&#xff0c;高安全功能和模块化设计。rsyslog能够接受从各种各样的来源&#xff0c;将其输入&#xff0c;输出的结果到不同的目的地。rsyslog可以提供超过每秒一百万条消息给…
阅读更多...
rsyslog日志服务简介

rsyslog日志服务简介

1、简介 rsyslog是一个linux系统日志服务的工具&#xff0c;主要用来监控收集系统从开机运行之后所发生的所有日志&#xff0c;包括内核日志&#xff0c;服务日志&#xff0c;应用日志等等&#xff1b;记录的日志全部都写到/var/log下面&#xff0c;常用的有dmsg&#xff08;内…
阅读更多...
Linux 日志管理 Rsyslog Loganalyzer

Linux 日志管理 Rsyslog Loganalyzer

Syslog常被称为系统日志或系统记录&#xff0c;是一种用来在互联网协议&#xff08;TCP/IP&#xff09;的网上中传递记录档消息的标准。这个词汇常用来指涉实际的syslog 协议&#xff0c;或者那些提交syslog消息的应用程序或数据库。 syslog协议属于一种主从式协议&#xff1a…
阅读更多...
建立 rsyslog 日志服务器

建立 rsyslog 日志服务器

文章目录 1. rsyslog 介绍2. 实验目的3. 实验环境4. 配置服务端5. 配置客户端6. 在服务端验证效果 1. rsyslog 介绍 rsyslog 是一个快速处理收集系统日志的开源程序&#xff0c;提供了高性能、安全功能和模块化设计。rsyslog 是 syslog 的升级版&#xff0c;它将多种来源输入输…
阅读更多...
rsyslog配置

rsyslog配置

rsyslog配置文件详解&#xff1a; #### MODULES #### #定义日志的模块。 $ModLoad imuxsock #imuxsock为模块名&#xff0c;支持本地系统日志的模块。 $ModLoad imjournal #imjournal为模块名&#xff0c;支持对系统日志的访问。 #$ModLo…
阅读更多...
syslog 和 rsyslog

syslog 和 rsyslog

1. 介绍 rsyslog可以简单的理解为syslog的超集&#xff0c;在老版本的Linux系统中&#xff0c;Red Hat Enterprise Linux 3/4/5默认是使用的syslog作为系统的日志工具&#xff0c;从RHEL 6 开始系统默认使用了rsyslog。 其特性包括&#xff1a; 支持输出日志到各种数据库&…
阅读更多...
rsyslog日志服务详解

rsyslog日志服务详解

rsyslog日志服务详解 原文出处&#xff1a;http://blog.51cto.com/6638225/1862902 内容&#xff1a; 1、rsyslog日志服务简介 2、rsyslog的配置详解 3、实现日志服务器收集日志及last、lastb、dmseg命令的使用 4、实现日志存储在mysql中 一、rsyslog日志服务简介 ​ 日…
阅读更多...
【Linux】rsyslog日志服务（配置，测试、日志转储）

【Linux】rsyslog日志服务（配置，测试、日志转储）

一、rsyslog简介 Rsyslog的全称是 rocket-fast system for log ,可用于接受来自各种来源的输入&#xff0c;转换 它们&#xff0c;并将结果输出到不同的目的地。 它提供了高性能、强大的安全功能和模块化设计。虽然rsyslog最初是一个常规的系 统日志&#xff0c;但它已经发展…
阅读更多...
Linux原生日志系统Rsyslog详解

Linux原生日志系统Rsyslog详解

一、概述 Rsyslog 是一个 syslogd 的多线程增强版&#xff0c;依然基于Syslog协议&#xff08;linux6之前默认使用syslog程序&#xff0c;centos6用rsyslog所取代&#xff09;完成系统日志的处理转发&#xff0c;官方形容它是一个极速&#xff08;如火箭般快速&#xff09;的日…
阅读更多...
N皇后问题-回溯法-C语言

N皇后问题-回溯法-C语言

关于对N皇后问题和回溯法的理解 个人非常推荐下面这个视频&#xff1a;算法与数据结构&#xff0c;回溯法求解八皇后&#xff0c;最经典的递归问题_哔哩哔哩_bilibili八皇后问题是计算机科学中最为经典的问题之一&#xff0c;该问题由国际西洋棋棋手马克斯贝瑟尔于1848年提出。…
阅读更多...
Java——N皇后问题

Java——N皇后问题

题目链接 leetcode在线oj题——N皇后 题目描述 按照国际象棋的规则&#xff0c;皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。 n 皇后问题 研究的是如何将 n 个皇后放置在 nn 的棋盘上&#xff0c;并且使皇后彼此之间不能相互攻击。 给你一个整数 n &#xff…
阅读更多...
N 皇后问题

N 皇后问题

n 皇后问题 研究的是如何将 n 个皇后放置在 nn 的棋盘上&#xff0c;并且使皇后彼此之间不能相互攻击。 给你一个整数 n &#xff0c;返回所有不同的 n 皇后问题 的解决方案。 每一种解法包含一个不同的 n 皇后问题 的棋子放置方案&#xff0c;该方案中 Q 和 . 分别代表了皇后和…
阅读更多...
推荐文章

Copyright @ 2022~2023