2.2链表

银河麒麟v10-arm SEALOS离线部署k8s集群(v1.22.8) 示例 如果你想保存一个名为 "my_snapshot" 的 etcd 快照到指定的对象路径你可以使用以下命令: sealos etcd save --backupPath /root --name my_snapshot 如果文件名带时间戳:my_snapshot$(date +"%Y%m%d_%H%M%S") 会生成一个形如 20230913_143045 的时间戳。--restorePath string:指定快照恢复目录(默认为 "/opt/sealos/etcd-restore")。 阅读详情

1.定义单链表

#include<stdio.h>
 struct LNode {//定义单链表类型

	int data;//每个节点存放一个数据元素
	struct LNode* next;//指针指向下一个节点

}Lnode, * LinkList;

int main() {
	//起别名
	typedef struct LNode Lode;
	typedef struct LinkList *LinkList;

	Lode* L;//声明一个指向单链表第一个节点的指针
	LinkList L;//声明一个指向单链表第一个节点的指针
	return 0;
}

2.初始化单链表

/*
不带头结点的单链表
*/
#include <stdio.h>
#include <stdbool.h>  // 添加bool头文件

typedef struct LNode {
    int data;              // 数据域
    struct LNode* next;    // 指针域 指向下一个节点(修正为LNode)
} Lnode, * LinkList;

// 初始化一个空链表
bool InitList(LinkList* L) {  // 使用二级指针
    *L = NULL;  // 空表,通过解引用修改外部指针
    return true;  // 返回true
}

//判断单链表是否为空
bool Empty(LinkList L) {
    if (L==NULL)
    {
        return true;
    }
    else
    {
        return false;
    }

}

int main() {
    LinkList L;  // 声明一个指向单链表的指针
    // 初始化空链表(传入指针的地址)
    InitList(&L);

    return 0;
}

/*
带头节点的单链表
*/
#include <stdio.h>
#include <stdbool.h>  // bool头文件
#include <stdlib.h>   // malloc头文件

typedef struct LNode {
    int data;              // 数据域
    struct LNode* next;    // 指针域
} Lnode, * LinkList;

// 初始化一个空链表(带头节点)
bool InitList(LinkList* L) {  // 使用二级指针
    *L = (Lnode*)malloc(sizeof(Lnode));  // 分配一个头结点

    if (*L == NULL) {  // 内存不足,分配失败
        return false;
    }

    (*L)->next = NULL;  // 头结点之后暂时没有节点
    return true;        // 初始化成功
}

int main() {
    LinkList L;  // 声明一个指向单链表的指针
    // 初始化空链表(传入指针的地址)
    if (InitList(&L)) {
        printf("链表初始化成功\n");
    }
    else {
        printf("链表初始化失败\n");
    }

    return 0;
}

3.判断是否为空

#include<stdio.h>
//定义链表
typedef struct LNode{
	int data;//数据域
	struct LNode *next;//指针域

}Lnode,*LinkList;//节点,和 指针

//判断链表是否为空
int ListEmpty(LinkList L) {//或者Lnode *L
	if (L->next)//非空
	{
		return 0;
	}
	else {
		return 1;
	}
	
}
int main() {
	Lnode head;
	head.next = NULL;//初始化指针
	int isEmpty=ListEmpty(&head);

	printf("判断是否为空:%d\n",isEmpty);

	return 0;
}

4.单链表销毁

/*
单链表的销毁:链表销毁后不存在

思路:从头指针开始,依次释放所有节点
*/

#include<stdio.h>
#include<stdlib.h>
typedef struct LNode {
    int data;//数据域
    struct LNode* next;//指针域
}Lnode, * LinkList;//节点 和指针

//销毁单链表L
int DestroyList_L(LinkList* L) {
    Lnode* p;
    Lnode* current = *L;//解引用得到头指针

    while (current != NULL) {
        p = current;//p =L
        current = current->next;  // 正确更新遍历指针 L=L->next
        free(p);//释放当前节点
    }

    *L = NULL;//将原始头指针置为NULL
    return 0;  // 添加返回值
}

int main() {
    //初始化链表
    LinkList L = (LinkList)malloc(sizeof(Lnode));
    if (L == NULL) {
        printf("内存分配失败\n");
        return -1;
    }
    L->next = NULL;//制空链表

    DestroyList_L(&L);

    //销毁后L应该为NULL
    if (L == NULL) {
        printf("链表已经成功销毁\n");
    }
    return 0;
}

5.清空链表

/*
清空链表:
链表仍存在,但链表中无元素,成为空链表(头指针和头节点仍然存在)

思路:依次释放所有节点,并将头节点指针域设置为空
*/

#include<stdio.h>
#include<stdlib.h>
typedef struct LNode {
	int data;//数据域
	struct LNode* next;//指针域



}*LinkList,Lnode;//链表,和节点

//清空链表L
int ClearList(LinkList L) {
	Lnode* p, * q;
	p = L->next;


	while (p) {
		q = p->next;

		free(p);

		p = q;
	
	}

	L->next = NULL;

	return 0;
}
int main() {
	//初始链表
	LinkList L = (LinkList)malloc(sizeof(Lnode));

	if (L==NULL)
	{
		printf("内存分配失败!!!\n");
		
		return L;

	}
	L->next = NULL;//制空表
	ClearList(L);

	printf("链表清空成功\n");

	free(L);
	L = NULL;
	return 0;
}

6.求链表的表长

/*
* 求链表的表长
* 
* 思路:从首元节点开始,依次计数所有节点
*/

#include <stdio.h>
#include <stdlib.h>

typedef struct LNode {
    int data;              // 数据域
    struct LNode* next;    // 指针域
} LNode, * LinkList;        // 链表节点类型,链表指针类型

int ListLength_L(LinkList L) {
    LinkList p = L->next;  // p指向第一个数据节点(跳过头节点)
    int i = 0;

    // 遍历单链表,统计节点数
    while (p != NULL) {
        i++;
        p = p->next;
    }
    return i;
}

int main() {
    // 初始化链表头节点(分配动态存储)
    LinkList L = (LinkList)malloc(sizeof(LNode));
    if (L == NULL) {
        printf("内存分配失败");
        return 1;
    }

    // 置空链表(头节点的next为NULL)
    L->next = NULL;

    // 添加测试节点
    // 创建第一个节点
    LinkList node1 = (LinkList)malloc(sizeof(LNode));
    node1->data = 10;
    node1->next = NULL;
    L->next = node1;

    // 创建第二个节点
    LinkList node2 = (LinkList)malloc(sizeof(LNode));
    node2->data = 20;
    node2->next = NULL;
    node1->next = node2;

    // 创建第三个节点
    LinkList node3 = (LinkList)malloc(sizeof(LNode));
    node3->data = 30;
    node3->next = NULL;
    node2->next = node3;

    // 测试:调用ListLength_L函数获取链表长度
    printf("链表长度: %d\n", ListLength_L(L));

    // 释放所有节点
    free(node3);
    free(node2);
    free(node1);
    free(L);
    return 0;
}

7.单链表取值

#include<stdio.h>
#include<stdlib.h>

typedef struct LNode {
    int data;              // 数据域
    struct LNode* next;    // 指针域
} LNode, * LinkList;        // LNode是结构体类型,LinkList是指针类型

// 取值:获取单链表L中的某个数据元素的内容,通过变量e返回
int GetElem_L(LinkList L, int i, int *e) {  // 修改为指针参数
    LinkList p;
    p = L->next;
    int j = 1; // 初始化

    // 向后扫描,直到p指向第i个元素或p为空
    while (p != NULL && j < i) {
        p = p->next;
        ++j;
    }

    // 判断第i个元素是否存在
    if (!p || j > i) {  // 第i个元素不存在
        return 0;  // 返回失败
    } else {
        *e = p->data;  // 取第i个元素的值
        return 1;     // 返回成功
    }
}

int main() {
    // 初始化链表动态分配存储
    LinkList L = (LinkList)malloc(sizeof(LNode));

    // 检查内存分配是否成功
    if (L == NULL) {
        printf("内存分配失败\n");
        return 1;
    }

    // 初始化头节点
    L->data = 0;
    L->next = NULL;

    printf("链表初始化成功\n");

    int e;  // 定义用于接收数据的变量
    int result = GetElem_L(L, 10, &e);  // 传递变量地址

    if (result) {
        printf("获取元素成功,值为: %d\n", e);
    } else {
        printf("获取元素失败\n");
    }

    // 释放内存
    free(L);
    return 0;
}

8.1单链表查找——按值查找(地址)

/*
* 按值查找————根据指定数据获取该数据所在的位置(地址)
* 
* 【算法步骤】
	1.从第一个结点起,依次和e相比较。
	2.如果找到一个其值与e相等的数据元素,则返回其在链表中的
	"位置"或地址
	3.如果查遍整个链表都没有找到其值和e相等的元素,则返回0或
	"NULL"
*/

#include<stdio.h>
#include<stdlib.h>

typedef struct LNode {
	int data;              // 数据域
	struct LNode* next;    // 指针域
} LNode, *LinkList;        // 链表节点类型,链表指针类型

// 按值查找函数:在链表L中查找值为e的节点,找到则返回节点地址,否则返回NULL
LinkList LocateElem_L(LinkList L, int e) {
	LinkList p = L->next;  // 从第一个数据节点开始查找
	
	// 遍历链表查找值为e的节点
	while (p != NULL && p->data != e) {
		p = p->next;
	}
	
	// 如果找到则返回节点地址,否则返回NULL
	return p;
}

// 辅助函数:在链表头部插入新节点
void InsertNode(LinkList L, int data) {
	LinkList newNode = (LinkList)malloc(sizeof(LNode));
	newNode->data = data;
	newNode->next = L->next;
	L->next = newNode;
}

int main() {
	// 初始化动态分配内存
	LinkList L = (LinkList)malloc(sizeof(LNode));

	// 检查内存分配是否成功
	if (L == NULL) {
		printf("内存分配失败\n");
		return 1;
	}
	
	// 初始化头节点
	L->data = 0;
	L->next = NULL;

	// 添加测试数据
	InsertNode(L, 30);  // 第1个数据节点
	InsertNode(L, 20);  // 第2个数据节点
	InsertNode(L, 10);  // 第3个数据节点

	// 测试按值查找
	int searchValue = 20;
	LinkList result = LocateElem_L(L, searchValue);
	
	if (result != NULL) {
		printf("找到值为 %d 的节点,地址为: %p\n", searchValue, result);
	} else {
		printf("未找到值为 %d 的节点\n", searchValue);
	}

	// 测试查找不存在的值
	searchValue = 50;
	result = LocateElem_L(L, searchValue);
	
	if (result != NULL) {
		printf("找到值为 %d 的节点,地址为: %p\n", searchValue, result);
	} else {
		printf("未找到值为 %d 的节点\n", searchValue);
	}

	// 释放内存
	LinkList current = L;
	while (current != NULL) {
		LinkList temp = current;
		current = current->next;
		free(temp);
	}

	return 0;
}

8.2单链表查找——按序查找(位序)

/*
* 按值查找————根据指定数据获取该数据位置序号
*
*/

#include<stdio.h>
#include<stdlib.h>

typedef struct LNode {
    int data;              // 数据域
    struct LNode* next;    // 指针域
} LNode, *LinkList;        // 链表节点类型,链表指针类型

// 按值查找函数:在链表L中查找值为e的节点,找到则返回位置序号,否则返回0
int LocateElem_L(LinkList L, int e) {
    LinkList p = L->next;  // 从第一个数据节点开始查找(首元结点)
    int position = 1;      // 位置序号从1开始
    
    // 遍历链表查找值为e的节点
    while (p != NULL && p->data != e) {
        p = p->next;
        position++;
    }
    
    // 如果找到则返回位置序号,否则返回0
    if (p != NULL) {
        return position;
    } else {
        return 0;
    }
}

// 辅助函数:在链表尾部插入新节点
void AppendNode(LinkList L, int data) {
  
// 分配内存空间用于存储新节点
LinkList newNode = (LinkList)malloc(sizeof(LNode));
// 设置节点数据域
newNode->data = data;
// 初始化节点指针域为空
newNode->next = NULL;
    
    // 找到链表尾部
    LinkList p = L;
    while (p->next != NULL) {
        p = p->next;
    }
    
    // 在尾部插入新节点
    p->next = newNode;
}

int main() {
    // 初始化链表头节点
    LinkList L = (LinkList)malloc(sizeof(LNode));
    
    // 检查内存分配是否成功
    if (L == NULL) {
        printf("内存分配失败\n");
        return 1;
    }
    
    // 初始化头节点
    L->data = 0;
    L->next = NULL;

    // 添加测试数据
    AppendNode(L, 10);  // 第1个数据节点,值为10
    AppendNode(L, 20);  // 第2个数据节点,值为20
    AppendNode(L, 30);  // 第3个数据节点,值为30
    AppendNode(L, 40);  // 第4个数据节点,值为40

    // 测试按值查找
    int searchValue = 30;
    int position = LocateElem_L(L, searchValue);
    
    if (position != 0) {
        printf("找到值为 %d 的节点,位置序号为: %d\n", searchValue, position);
    } else {
        printf("未找到值为 %d 的节点\n", searchValue);
    }

    // 测试查找不存在的值
    searchValue = 50;
    position = LocateElem_L(L, searchValue);
    
    if (position != 0) {
        printf("找到值为 %d 的节点,位置序号为: %d\n", searchValue, position);
    } else {
        printf("未找到值为 %d 的节点\n", searchValue);
    }

    // 释放内存
    LinkList current = L;
    while (current != NULL) {
        LinkList temp = current;
        current = current->next;
        free(temp);
    }

    return 0;
}

9.单链表插入

/*
* 插入在第i个结点前插入值为e的新结点

1、首先找到
a i-1的存储位置p。
2、生成一个数据域为e的新结点s。
3、插入新结点:
 1.新结点的指针域指向结点ai;
 2.结点a;-的指针域指向新结点
*/
#include<stdio.h>
#include<stdlib.h>

typedef struct LNode {
    int data;              // 数据域
    struct LNode* next;    // 指针域
} LNode, *LinkList;        // 链表节点类型

// 在链表L的第i个位置前插入值为e的新节点
int ListInsert_L(LinkList L, int i, int e) {
    LinkList p = L;        // 从头节点开始
    int j = 0;             // 计数器初始化为0
    
    // 查找第i-1个节点,p指向i-1节点
    while (p && j < i - 1) {
        p = p->next;
        ++j;
    }
    
    // i大于表长+1或小于1,插入位置非法
    if (!p || j > i - 1) {
        return 0;  // 插入失败
    }
    
    // 生成新节点s
    LinkList s = (LinkList)malloc(sizeof(LNode));
    if (!s) {
        printf("内存分配失败\n");
        return 0;
    }
    
    s->data = e;           // 设置新节点数据,将s的数据域置为e
    s->next = p->next;     // 新节点指向原第i个节点
    p->next = s;           // 原第i-1个节点指向新节点
    
    return 1;  // 插入成功
}

// 辅助函数:在链表尾部添加节点(用于测试)
void AppendNode(LinkList L, int data) {
    LinkList newNode = (LinkList)malloc(sizeof(LNode));
    newNode->data = data;
    newNode->next = NULL;
    
    // 找到链表尾部
    LinkList p = L;
    while (p->next != NULL) {
        p = p->next;
    }
    
    // 在尾部插入新节点
    p->next = newNode;
}

// 辅助函数:打印链表
void PrintList(LinkList L) {
    LinkList p = L->next;  // 从第一个数据节点开始
    printf("链表内容: ");
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

int main() {
    // 初始化动态分配存储空间
    LinkList L = (LinkList)malloc(sizeof(LNode));
    // 检查分配内存是否成功
    if (L == NULL) {
        printf("内存分配失败");
        return 1;
    }

    // 初始化头节点
    L->data = 0;
    L->next = NULL;

    // 添加测试数据
    AppendNode(L, 10);
    AppendNode(L, 20);
    AppendNode(L, 30);
    
    printf("插入前:\n");
    PrintList(L);
    
    // 在第2个位置插入值为15的新节点
    if (ListInsert_L(L, 2, 15)) {
        printf("在第2个位置插入15成功\n");
    } else {
        printf("插入失败\n");
    }
    
    printf("插入后:\n");
    PrintList(L);
    
    // 释放内存
    LinkList current = L;
    while (current != NULL) {
        LinkList temp = current;
        current = current->next;
        free(temp);
    }

    return 0;
}

10.单链表删除

#include<stdio.h>
#include<stdlib.h>

typedef struct LNode {
    int data;              // 数据域
    struct LNode* next;    // 指针域
} LNode, *LinkList;        // 链表节点类型

// 删除链表L的第i个节点,并将删除的值保存在e中
int ListDelete_L(LinkList L, int i, int *e) {
    LinkList p = L;        // 从头节点开始
    int j = 0;             // 计数器初始化为0
    
    // 查找第i-1个节点
    while (p && j < i - 1) {
        p = p->next;
        ++j;
    }
    
    // 如果p为空或位置不合理,返回错误
    if (!p || !p->next || j > i - 1) {
        return 0;  // 删除失败
    }
    
    // 找到要删除的节点
    LinkList q = p->next;     // q指向要删除的节点
    *e = q->data;             // 保存要删除节点的数据
    p->next = q->next;        // 让前一个节点指向后一个节点
    free(q);                  // 释放要删除节点的内存
    
    return 1;  // 删除成功
}

// 辅助函数:在链表尾部添加节点(用于测试)
void AppendNode(LinkList L, int data) {
    LinkList newNode = (LinkList)malloc(sizeof(LNode));
    newNode->data = data;
    newNode->next = NULL;
    
    // 找到链表尾部
    LinkList p = L;
    while (p->next != NULL) {
        p = p->next;
    }
    
    // 在尾部插入新节点
    p->next = newNode;
}

// 辅助函数:打印链表
void PrintList(LinkList L) {
    LinkList p = L->next;  // 从第一个数据节点开始(首元节点)
    printf("链表内容: ");
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

int main() {
    // 初始化链表头节点
    LinkList L = (LinkList)malloc(sizeof(LNode));
    if (L == NULL) {
        printf("内存分配失败\n");
        return 1;
    }

    // 初始化头节点
    L->data = 0;
    L->next = NULL;

    // 添加测试数据
    AppendNode(L, 10);
    AppendNode(L, 20);
    AppendNode(L, 30);
    AppendNode(L, 40);
    
    printf("删除前:\n");
    PrintList(L);
    
    // 删除第3个节点
    int deletedValue;
    if (ListDelete_L(L, 3, &deletedValue)) {
        printf("删除第3个节点成功,删除的值为: %d\n", deletedValue);
    } else {
        printf("删除失败\n");
    }
    
    printf("删除后:\n");
    PrintList(L);
    
    // 释放内存
    LinkList current = L;
    while (current != NULL) {
        LinkList temp = current;
        current = current->next;
        free(temp);
    }

    return 0;
}

11.1单链表建立——头插法

/*
建立单链表:头插法———元素插入链表头部,也叫前插法

1.从一个空表开始,重复读入数据;
2.生成新结点,将读入数据存放到新结点的数据域中
3.从最后一个结点开始,依次将各结点插入到链表的前端
*/

#include<stdio.h>
#include<stdlib.h>
//#define _CRT_SECURE_NO_WARNINGS         //预处理

typedef struct LNode {
    int data;              // 数据域
    struct LNode* next;    // 指针域
} LNode, * LinkList;       // 节点,链表

// 创建链表头插法
void CreateList_Head(LinkList L, int n) {
    // 不需要重新分配L的内存,使用传入的头节点
    
    for (int i = n; i > 0; i--) {
        LinkList p = (LinkList)malloc(sizeof(LNode)); // 生成新节点
        
        printf("请输入第%d个元素的值: ", n - i + 1);
        scanf("%d", &p->data); // 输入元素值
        
        /* 
         * 将节点p插入到链表L的头部位置
         */
        p->next = L->next;  // 保存当前链表的第一个有效节点(L->next)到p->next中
        L->next = p;        // 将新节点p设置为链表的第一个有效节点
    }
}

// 辅助函数:打印链表
void PrintList(LinkList L) {
    LinkList p = L->next;  // 从第一个数据节点开始
    printf("链表内容: ");
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

int main() {
    // 初始化并动态开辟存储空间
    LinkList L = (LinkList)malloc(sizeof(LNode));

    // 判断分配内存是否成功
    if (L == NULL) { 
        printf("分配内存失败");
        return 1;
    }

    // 置空数据域,指针域
    L->data = 0;
    L->next = NULL;

    CreateList_Head(L,5);  // 创建5个节点的链表
    
    PrintList(L);  // 打印链表内容

    // 释放内存
    LinkList current = L;
    while (current != NULL) {
        LinkList temp = current;
        current = current->next;
        free(temp);
    }
    
    return 0;  
}

11.2链表建立——尾插法

/*
建立单链表:尾插法元素插入在链表尾部,也叫后插法
1.从一个空表L开始,将新结点逐个插入到链表的尾部,尾指针r指向链表
的尾结点。
2.初始时,r同L均指向头结点。每读入一个数据元素则申请一个新结点,
将新结点插入到尾结点后,r指向新结点。
*/
#include<stdio.h>
#include<stdlib.h>
typedef struct LNode {
	int data;//数据域
	struct LNode* next;//指针域
}LNode,*LinkList;//节点,链表


//尾插法 正序
void CreateList_tail(LinkList L,int n) {
	LinkList r = (LinkList)malloc(sizeof(LNode));

	r = L;//尾指针指向头节点

	for (int i = 1; i <= n; i++)
	{
		LinkList p = (LinkList)malloc(sizeof(LNode));//生成新节点,输入元素值

		scanf("%d",&p->data);

		p->next = NULL;

		r->next = p;//插入到表尾
		r = p;//指向新的尾节点
	}

}

//打印链表
void PrintList(LinkList L) {
	LinkList p = L->next;  // 从第一个数据节点开始

	printf("链表内容:");
	while (p!=NULL) {
		printf("%d ",p->data);
		
		p = p->next;
	}

	printf("\n");
}
int main() {
	//初始化并动态分配内存
	LinkList L = (LinkList)malloc(sizeof(LNode));

	//判断分配内存是否成功
	if (L==NULL)
	{
		printf("内存分配失败");

		return 1;
	}

	//初始化指针域,数据域
	L->data = 0;
	L->next = NULL;

	CreateList_tail(L,5);//创建5个节点

	//打印链表内容
	PrintList(L);

	//释放内存
	free(L);
	return 0;
}

12.循环链表

/*
* 循环链表:表中最后一个元素的指针域指向头节点,整个链表形成一个环。
* 
带尾指针循环链表的合并
*/

#include<stdio.h>
#include<stdlib.h>

typedef struct LNode {
    int data;              // 数据域
    struct LNode* next;    // 指针域
} LNode, *LinkList;

// 合并两个循环链表
LinkList Connect(LinkList Ta, LinkList Tb) {
    // 假设Ta、Tb都是非空的单循环链表
    
    LinkList p; // 不需要分配内存
    
    p = Ta->next;              // p保存Ta的头节点
    Ta->next = Tb->next->next; // Tb的尾节点指向Ta的头节点
    Tb->next->next = p;        // Tb的头节点指向Ta原来的头节点
    free(Tb);                  // 释放Tb的尾指针节点
    
    return Ta; // 返回合并后的链表
}

// 初始化循环链表
void InitCircularList(LinkList L) {
    L->next = L; // 头节点指向自己,形成循环
    L->data = 0;
}

// 在循环链表尾部插入节点
void AppendNode(LinkList rear, int data) {
    LinkList newNode = (LinkList)malloc(sizeof(LNode));
    newNode->data = data;
    
    // 新节点插入到尾节点和头节点之间
    newNode->next = rear->next; // 新节点指向头节点
    rear->next = newNode;       // 尾节点指向新节点
}

// 打印循环链表
void PrintCircularList(LinkList rear) {
    if (rear == NULL) return;
    
    LinkList head = rear->next; // 头节点
    LinkList p = head->next;    // 第一个数据节点
    
    printf("循环链表内容: ");
    while (p != head) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

int main() {
    // 动态分配存储空间
    LinkList Ta = (LinkList)malloc(sizeof(LNode));
    LinkList Tb = (LinkList)malloc(sizeof(LNode));

    // 判断内存分配是否成功
    if (Ta == NULL || Tb == NULL) {
        printf("内存分配失败");
        return 1;
    }

    // 初始化循环链表
    InitCircularList(Ta);
    InitCircularList(Tb);
    
    // 为Ta添加测试数据
    AppendNode(Ta, 10);
    AppendNode(Ta, 20);
    AppendNode(Ta, 30);
    
    // 为Tb添加测试数据
    AppendNode(Tb, 40);
    AppendNode(Tb, 50);
    AppendNode(Tb, 60);
    
    printf("合并前:\n");
    printf("Ta: ");
    PrintCircularList(Ta);
    printf("Tb: ");
    PrintCircularList(Tb);

    // 合并循环链表
    LinkList result = Connect(Ta, Tb);
    
    printf("合并后:\n");
    PrintCircularList(result);

    // 释放内存
    // 需要遍历整个循环链表释放所有节点
    LinkList current = result->next; // 从第一个数据节点开始
    LinkList head = result->next;    // 记录头节点位置
    LinkList temp;
    
    do {
        temp = current;
        current = current->next;
        free(temp);
    } while (current != head);
    
    return 0;
}

13.双向链表

/*
双向链表:节点有两个指针域,一个指向直接后继,另一个指向直接前驱
*/

typedef struct DuLNode {
	int data;//数据域
	struct DuLNode* prior;//指向直接前驱
	struct DuLNode* next;//指向直接后继

}DuLNode,*DuLinkList;
#include<stdio.h>
int main() {


	return 0;
}
vue 获取el-table多选的选中行 <el-table :data='tableData' ref="multipleTable" v-loading='loading' border max-height='700' style='width: 100%' size="mini"> <el-table-column type="selection" width="55"></el-table-column> <el-table-column label 阅读详情

相关推荐

Pixhawk固定翼飞行控制实战:L1与TECS算法详解(附代码解析)

本文深入解析了Pixhawk飞控在固定翼无人机中的核心控制算法:L1导航与TECS总能量控制。通过剖析算法原理、代码实现与实战调参,帮助开发者解决航线跟踪振荡、高度速度不稳定等常见问题,实现精准稳定的自主飞行。

wine的专栏 744

edk2 中链表操作

链表是构建复杂系统的基石,学习时要注意结合代码画图edk2中链表操作和 linux内核参数是相反的edk2中不提供遍历接口,需要手动 for 循环edk2中使用 CR宏和 container_of一样的效果。

专注嵌入式开发,IC 设计、验证及软件联合调试 391

自动驾驶仿真:基于Carsim开发的加速度请求模型

1、自动驾驶行业中,算法端对于纵向控制的功能预留接口基本都是加速度,我们需要给控制器仿真加速度的信号,控制器才会实现对纵向功能的控制。2、Carsim或者其他动力学软件,主要提供者节气门开度和主缸压力进行控制。我们在进行联合仿真时,往往都要通过PID的方式将请求加速度转换成对应的节气门开度与主缸压力传给动力学软件进行闭环控制。

zataji的博客 6918

Chaos 链表2.0 简单单链表操作的一站式实现

链表2.0 #include<stdio.h> #include<stdlib.h> struct node { // int sign; int value; struct node *next; }; //头插法 struct node *head_add(struct node *p) { int n_value; scanf("%d",&n_value); struct node *t_node; t_node=(struct node*)malloc

weixin_44570253的博客 179

stm32学习笔记-启动文件

1、配置栈 Stack_Size EQU 0x00000400 AREA STACK, NOINIT, READWRITE, ALIGN=3 Stack_Mem SPACE Stack_Size __initial_sp EQU:相当于C中的define,定义Stack_Size = 0x00000400。 AREA: 指...

某风吾起的博客 4533

PCL点云DBSCAN聚类算法:基于密度的点云聚类

核心点是在给定半径内拥有足够多邻居点的点,边界点是在给定半径内没有足够多邻居点但是位于核心点的邻域内的点,噪声点是既不是核心点也不是边界点的点。本文将介绍PCL中的DBSCAN(基于密度的空间聚类应用噪声)算法,用于点云数据的聚类。上述示例代码首先从PCD文件中读取点云数据,并设置了DBSCAN聚类的参数,包括邻域搜索半径(epsilon)和邻域内最小点数(min_points)。需要注意的是,示例代码中的点云数据格式为pcl::PointXYZ,如果使用其他类型的点云数据,需要相应地修改代码。

LpmShell的博客 1242

ns2中宏定义实现的链表LIST

-----------------------------------------------------------链表的定义----------------------------------------------------------- List的定义: #define LIST_HEAD(name, type) \ struct name { \ ty

ceci zhou 1586

激光打标轴坐标计算分析

‌:基于坐标差的平方和开方运算,勾股定理将几何关系转化为代数计算,从而实现了从坐标到距离的精确转换‌12。直角三角形的应用从上图可以看到A,B,P三个点连起来就是一个直角三角形了。用勾股定理计算距离 C#有相关的方法直接传参数就可以了。很方便。

StevenChen的博客 313

PTA——L2-022 重排链表(链表)

每个输入包含1个测试用例。每个测试用例第1行给出第1个结点的地址和结点总个数,即正整数N (≤10^5)。结点的地址是5位非负整数,NULL地址用−1表示。对每个测试用例,顺序输出重排后的结果链表,其上每个结点占一行,格式与输入相同。例如:给定L为1→2→3→4→5→6,则输出应该为6→1→5→2→4→3。Next是下一结点的地址。题目保证给出的链表上至少有两个结点。其中Address是结点地址;Data是该结点保存的数据,为不超过10。L2-022 重排链表。

2301_77012063的博客 996

【教程4>第6章>第15节】 基于I+jQ复数信号的LS信道估计和均衡实现1——matlab仿真分析,QPSK为例

在基于QPSK调制的通信系统中,LS信道估计和均衡是用于补偿信道失真、提高信号传输质量的重要技术。以下将详细介绍基于I+jQ复数信号的 LS 信道估计和均衡的实现原理与过程。可以看到,通过线性插值之后,QPSK信号的星座图可以模糊的看到四个星座点(图2),通过非线性插值之后,可以清晰的看到QPSK的四个星座点(图3)。可以看到,信道均衡显著提高了通信系统的可靠性和有效性。

FPGA/MATLAB学习教程/源码/项目合作开发 657

Python爬虫零基础入门【第九章:实战项目教学·第17节】内容指纹去重:URL 变体/重复正文的识别!

我长期专注 Python 爬虫工程化实战,主理专栏 👉 《Python爬虫实战》:从采集策略到反爬对抗,从数据清洗到分布式调度,持续输出可复用的方法论与可落地案例。内容主打一个“能跑、能用、能扩展”,让数据价值真正做到——抓得到、洗得净、用得上。

喵手的博客 827

用单链表结构实现算法2.2的程序

// algo2-13.cpp 采用单链表结构实现算法2.2的程序,仅有4句与algo2-2.cpp不同 #include"c1.h" typedef int ElemType; #include"c2-2.h" // 此句与algo2-2.cpp不同 #include"bo2-2.cpp" // 此句与algo2-2.cpp不同 #include"func2-3.cpp" // 包括equal(

7urin9'Blog 723

selenium绕过检测,规避检测

现在不少大网站有对selenium采取了监测机制。比如正常情况下我们用浏览器访问淘宝等网站的 window.navigator.webdriver的值为 undefined或者为false。而使用selenium访问则该值为true。那么如何解决这个问题呢?我们正常浏览器登录查看,window.navigator.webdriver的值为false我们通过selenium打开的网页,测试,可见window.navigator.webdriver的值为true。

景天科技苑 1万+

L2-022 重排链表

L2-022 重排链表 C语言实现 详细注释

QMonsoon 331

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

剑指offer第2版:链表系列

链表的OJ其实是最简单的!!

weixin_51142926的博客 3535

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

NS2自身的LIST链表

 NS2 LIST 链表本人在看NS2源代码的时候发现有LIST_HEAD,LIST_ENTRY,LIST_INIT,LIST_REMOVE等等,经过查看源代码和上网翻阅资料,发现NS2有其自身定义的链表结构,定义在bsd-list.h中,于是写了个简短的说明,方便他人使用.由于是自己看源代码后自己理解的,如有错误,请告知 本文档分三部分 1.源码解释2.源码3.应

lyplyz的专栏 4184

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

NC2 重排链表

描述 给定head链表1->2->3->4, 重新排列为 1->4->2->3 要求使用原地算法,不能只改变节点内部的值,需要对实际的节点进行交换。 方法1:利用线性表存储该链表,然后利用线性表可以下标访问的特点,直接按顺序访问指定元素,重建该链表即可。 时间复杂度O(N):N是链表的结点数量,遍历链表、数组构建新链表 空间复杂度O(N):使用额外的数组空间 方法2;寻找链表中点 + 链表逆序 + 合并链表 1、找中点的话,可以使用快慢指针。快指针一次走两步,慢指

香蕉的博客 1120

NS2中的链表笔记

NS2中的链表采用了bsd-list.h头文件,内容如下: #define LIST_HEAD(name, type) \ struct name { \ type *lh_first; /* first element */ \ } #define LIST_ENTRY(type) \ struct { \ type *le_nex

yanhc519的专栏 1192

23 环形链表2

23.2 举例说明 假设链表如下: 链表节点值为 [3, 2, 0, -4]。 环的起点是值为 2 的节点(第 2 个节点,pos = 1)。 运行过程: 快慢指针移动:让快指针移动两步,慢指针移动一步。 第一步: 第二步: 第三步: 第四步: 快慢指针在值为 2 的节点相遇,说明链表中有环。 确定环的起点:相遇后,重新调整慢指针 slow 的位置,将其移回链表头(值为 3),而快指针 fast 留在相遇点(值为 2)。 同时移动快慢指针 第二步: 此时,快慢指针再次相遇

weixin_47521269的博客 460

LeetCode 143 重排链表 NC2 重排链表

给定一个单链表L:L0→L1→…→Ln-1→Ln , 将其重新排列后变为: L0→Ln→L1→Ln-1→L2→Ln-2→… 你不能只是单纯的改变节点内部的值,而是需要实际的进行节点交换。 示例1: 给定链表 1->2->3->4, 重新排列为 1->4->2->3. 示例 2: 给定链表 1->2->3->4->5, 重新排列为 1->5->2->4->3. 解题思路: 因为链表不支持下标.....

麦格芬230的博客 175

L2-2-链表 重排链表 (25 分)

这个思路是真的好,比别人的思路都好太多了,用一个l索引和r索引,一个arr1数组和arr2数组,巧妙地化解了这个问题。 #include <iostream> using namespace std; typedef struct Node{ int a; int nt; }Node; int main(){ Node p[100001]; int ad,n,address,m,next,cnt,l,r,x; int arr1[100001

weixin_45564209的博客 1122

将循环单链表h2链接到循环单链表h1之后

题目: 有两个循环单链表,链表头指针分别为h1和h2,编写一函数,将链表h2链接到链表h1之后,要求链接后的链表仍保持循环链表的形式。 分析:把链表h1的尾指针,改为指向h2即可;将h2的尾指针指向h1的第一个结点; LinkList Link(LinkList &h1,LinkList &h2){//假设两个链表都带有头结点; if(h2->next == h2) return; //链表h2为空表,不需要链接; //查找尾指针; r1 = Sear

打字员blog 583

leetcode 92反转链表2

反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。 说明: 1 ≤ m ≤ n ≤ 链表长度。 示例: 输入: 1->2->3->4->5->NULL, m = 2, n = 4 输出: 1->4->3->2->5->NULL 来源:力扣(LeetCode) 链接:https://leetcode-cn.com/problems/r...

janyoo的博客 163

【GPLT】L2-022 重排链表

题目描述: 给定一个单链表L​1​​→L​2​​→⋯→L​n−1​​→L​n​​,请编写程序将链表重新排列为L​n​​→L​1​​→L​n−1​​→L​2​​→⋯。例如:给定L为1→2→3→4→5→6,则输出应该为6→1→5→2→4→3。 输入描述: 每个输入包含1个测试用例。每个测试用例第1行给出第1个结点的地址和结点总个数,即正整数N(≤10​5​​)。结点的地址是5位非负整数,N...

麦芽雪冷萃 1767

NS2 LIST 链表

NS2 LIST 链表 转载自 http://209.85.173.132/search?q=cache:qoLJuqxelc0J:www.zxbc.cn/html/20070621/23075.html+ns2+LIST_ENTRY&hl=zh-CN&ct=clnk&cd=1作者:佚名  出处:中国自学编程网收集整理   发布日期:2007-06

zjnig711的信息仓库 669

L2-2 重排链表

我们的思路是,首先我们要将给出的各个随机的链表先组成一个正确的链表,二同样用来表示一个节点有三个值,本身的地址,所在节点的值,以及链接下一个节点的地址。每个测试用例第1行给出第1个结点的地址和结点总个数,即正整数N (≤10 5)。1→L2→⋯→Ln−1→Ln,请编写程序将链表重新排列为 Ln→L 1→L n−1→L 2→⋯。例如:给定L为1→2→3→4→5→6,则输出应该为6→1→5→2→4→3。Next是下一结点的地址。对每个测试用例,顺序输出重排后的结果链表,其上每个结点占一行,格式与输入相同。

qq_74276498的博客 497
下一篇: C#第一次上机作业
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值