2.2链表

原创 已于 2025-10-06 19:06:23 修改 · 215 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构

于 2025-09-25 13:50:26 首次发布

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;
}
直击高频编程考点：链表知识及经典算法题总结
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
10-24 5万+
了解链表结构，并在单链表或双链表中实现遍历、插入和删除以及分析在单链表或双链表中的各种操作的复杂度，同时附上相关面试考点的基本分类试题库（反转链表、链表中环的检测、链表中环的入口点、删除链表中倒数第K个节点、两个链表的第一个公共节点、链表的中间节点、合并两个有序链表、删除链表中的重复元素、排序链表、K 个一组翻转链表、旋转链表、分隔链表、奇偶链表、合并k个排序链表、链表相加、回文链表判定、回文链表重排、交换相邻节点、删除指定元素、反转链表指定部分、存在回文链表、链表最长递增子序列）
2.2 链表
ApolloMonasa的博客
07-11 1019
我做笔记的标准是：简洁有效(在将来会想看)
2.2 链表---设计链表(Leetcode 707)
Amoni的博客
05-22 350
Leetcode 707 class MyLinkedList { public: // 定义链表节点结构体 struct ListNode { int val; ListNode* next; ListNode(): val(0), next(nullptr) {} ListNode(int x): val(x), next(nullptr) {} ListNode(int x, ListNode* next
2.2链表及心得收获
wangjingran03119的博客
03-29 1999
2、尾部插入数据，尾部删除数据，头部插入数据，头部删除数据，任意位置的插入，任意位置的删除，查找数据位置，修改数据的功能。（以上均为搜索所知）的，顺序的，而数据元素的逻辑顺序是通过链表中的指针连接次序实现的。1、它是用于储存数据的一种结构。的存储结构，但链表在。
Go版数据结构 -【2.2 链表】
Swxctx
09-25 1414
链表是一种常见的线性数据结构，与数组不同的是，链表中的元素并不存储在连续的内存空间中，而是通过指针连接在一起。 链表非常适合需要频繁插入、删除操作的场景，因为它不需要像数组那样频繁移动数据。
数据结构与算法【LeetCode-Offer】：2.2链表—203.移除链表元素
qq_40572023的博客
12-08 127
2.2链表—203.移除链表元素
2.2 设计链表
canmakeit的博客
08-05 318
void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。val 是当前节点的值，next 是指向下一个节点的指针/引用。void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。int get(int index) 获取链表中下标为 index 的节点的值。void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
2.2链表 链表中倒数第k个结点
weixin_30379531的博客
07-26 75
1 /* 2 struct ListNode { 3 int val; 4 struct ListNode *next; 5 ListNode(int x) : 6 val(x), next(NULL) { 7 } 8 };*/ 9 class Solution { 10 public: 11 ...
【2.2链表 】链表中倒数第k个结点
小沫_jie的博客
03-08 167
题目描述 输入一个链表，输出该链表中倒数第k个结点。 思路一 使用一个长度为k的尺子，pre先走k-1步，然后nex再开始走，当pre到达最后一个节点时，则nex所指向的就是倒是第k个结点 # -*- coding:utf-8 -*- # class ListNode: # def __init__(self, x): # self.val = x # ...
程序员面试金典 2.2 链表中倒数第k个结点
肆乐雨
02-22 306
题目输入一个链表，输出该链表中倒数第k个结点。我的题解class Solution { public: ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) { ListNode* fast = pListHead; ListNode* slow = pListHead; in
2.2链表中倒数第k个结点
weixin_30808693的博客
02-06 105
题目描述 输入一个链表，输出该链表中倒数第k个结点。 解法：（一）暴力方法，先求出链表长度，倒数第k个，也就是正数第L-K个 class Solution { public: ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) { //思路，获取链表的长度， 用L-k就是当下节点的位置啊...
2.2_约瑟夫环链表.cpp
10-28
开始给定一个正整数 m，从第s个人按顺时针方向自1开始报数，报到m者出列，不再参加报数，这时将出列者的密码作为m，从出列者顺时针方向的下一人开始重新自1开始报数...实验要求: 采用链式存储结构实现，可以用循环链表
2.2 链表管理  内容：编写应用程序，使用链表管理用户信息，实现用户增删  流程示例： 1． 用户 A 输入如下信息登录 userName:testa userID:12345678 userleval:a userOption:login 2． 用户 B 输入如下信息退出 userName:testb userID:87654321 userleval:b userOption:logout 3． 显示当前全部 login 的用户 4． 用户输入 clear all 清除全部用户信息  具体要求： 假设有一个无头单向链表，链表中的每个元素都是一个结构体，结构体包含两个成员， 一个是数据域存储数据，另一个是指针域指向下一个元素。现在需要实现以下功能： 创建链表：能够创建一个空的链表。 打印链表：能够打印链表中的所有元素。 插入元素：能够在链表的指定位置插入一个新元素。 删除元素：能够删除链表的指定位置的元素。 查找元素：能够查找链表中是否存在某个元素，并返回其位置。 清空链表：能够清空链表，释放所有元素的内存。 提示：使用函数实现上述功能，可以使用结构体来表示链表节点，链表节点应包含数据 域和指向下一节点的指针域
08-08
下面是一个完整的 C 语言程序，使用**无头单向链表**实现用户信息管理，包括创建、插入、删除、查找、打印和清空链表等功能，符合你提出的所有需求： --- ### ✅ 功能实现说明： 1. **结构体定义：** - `User`...
2.2 链表管理  内容：编写应用程序，使用链表管理用户信息，实现用户增删  流程示例： 1． 用户 A 输入如下信息登录 userName:testa userID:12345678 userleval:a userOption:login 2． 用户 B 输入如下信息退出 userName:testb userID:87654321 userleval:b userOption:logout 3． 显示当前全部 login 的用户 4． 用户输入 clear all 清除全部用户信息  具体要求： 假设有一个无头单向链表，链表中的每个元素都是一个结构体，结构体包含两个成员， 一个是数据域存储数据，另一个是指针域指向下一个元素。现在需要实现以下功能： 创建链表：能够创建一个空的链表。 打印链表：能够打印链表中的所有元素。 插入元素：能够在链表的指定位置插入一个新元素。 删除元素：能够删除链表的指定位置的元素。 查找元素：能够查找链表中是否存在某个元素，并返回其位置。 清空链表：能够清空链表，释放所有元素的内存。 提示：使用函数实现上述功能，可以使用结构体来表示链表节点，链表节点应包含数据 域和指向下一节点的指针域
08-08
为了实现题目要求的链表管理用户信息功能，我们可以设计一个单向链表结构，每个节点存储用户信息（用户名、用户ID、用户等级、登录状态），并实现链表的基本操作：创建、插入、删除、查找、打印、清空。 下面是完整...
【数据结构】2.2经典的单链表练习题
海的早晨的博客
04-14 806
目录 1. 删除链表中等于给定值 val 的所有节点。 方法一：哨兵结点 方法二：尾插法 2.反转单链表 方法一：指针转方向 方法二：头插法 3.链表的中间结点 方法一：计算链表长度 方法二：快慢指针 4.合并有序单链表 5.链表的分割 6.带环问题（判断链表是否带环） 7.求环的入口点 8.复杂链表的复制 一些命名的介绍 cur：当前结点 prev：前继...
【C语言】数据结构——顺序表超详解!!!（包含顺序表的实现)
zore__的博客
12-11 7687
本文详细介绍了C语言中顺序表这一数据结构的概念与实现。首先解释了数据结构的基本概念，然后重点讲解了顺序表的定义、分类（静态顺序表和动态顺序表）及其区别。文章通过代码示例详细展示了如何创建和实现动态顺序表，包括顺序表的定义、初始化、销毁、打印等基本操作，特别强调了动态顺序表的增容机制。最后指出在实现复杂程序时应采用多文件结构，使代码更加清晰可维护。顺序表作为线性表的一种重要实现方式，在C语言程序设计中具有广泛应用价值。
数据结构04——二叉树搜索树BST
最新发布
moranxiao199的博客
12-16 435
Find查找的效率取决于树的高度，所以我们希望这个树尽量的平衡，不要出现一边倒。支持：查找（Search）、插入（Insert）、删除（Delete）第三种，删除的结点有左、右两颗子树：用另一个结点代替被删除的结点，同一组元素，如果插入顺序不同，二叉搜索树的形态可以完全不同。② 如果 X 大于根结点的关键值，在右子树中进行继续搜索；③ 若两者比较结果相等，搜索完成，返回指向此结点的指针。查找从根结点开始，如果树为空，返回 NULL。：将其父结点的指针指向被删除结点的孩子结点。
数据结构：矩阵
闲余知道
12-16 836
数据结构：矩阵
数据结构基本概念
XinxingZh的博客
12-12 335
数据是信息的载体，是描述客观事物属性的数、字符及所有能输入到计算机中并被计算机程序识别和处理的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值