C语言数据结构 2.2&2.3：单链表与双向链表

StazSans

已于 2022-05-02 22:34:39 修改

阅读量1.4k

点赞数 2

分类专栏： c语言数据结构学习笔记文章标签：数据结构

于 2022-04-28 17:20:00 首次发布

本文链接：https://blog.csdn.net/m0_61960789/article/details/124478454

版权

c语言数据结构学习笔记专栏收录该内容

8 篇文章 0 订阅

订阅专栏

概念：

链表是以链式结构存储数据的，其中的元素在存储器上的位置是任意的，既逻辑上的相邻在物理位置上不一定相邻。

图示：

结点：

链表：

头指针是指向头结点的指针。

代码演示：

定义链表结点：

/**
 * 定义链表结构体
 */
typedef struct LinkNode {
    char data;
    struct LinkNode *next;
} LNode, *LinkList, *NodePtr;

创建一个只含有一个节点且没有数据的链表:

/**
 * 创建一个只含有一个节点且没有数据的链表
 * @return 指向头节点的指针
 */
LinkList initLinkList() {
    NodePtr tempHeader = (NodePtr)calloc(1, sizeof(LNode));
    tempHeader->next = NULL;
    return tempHeader;

打印链表:

/**
 * 打印链表
 * @param paraHeader 链表的头节点
 */
void printList(NodePtr paraHeader) {
    NodePtr p = paraHeader->next;
    while (p != NULL) {
        printf("%c", p->data);
        p = p->next;
    }
    printf("\r\n");
}

尾插法添加链表元素:

/**
 * 尾插法添加链表元素
 * @param paraHeader 指向链表的头节点的指针
 * @param paraChar 待添加的元素
 */
void appendElement(NodePtr paraHeader, char paraChar) {
    NodePtr p, q;

    //1.创造一个新的节点并把paraChar赋给该节点
    q = (NodePtr)malloc(sizeof(LNode));
    q->data = paraChar;
    q->next = NULL;

    //2.使p指向该链表当前的尾结点
    p = paraHeader;
    while (p->next != NULL) {
        p = p->next;
    }

    //3.插入节点
    p->next = q;
}

原理图：

将元素插入到给定位置:

/**
 * 将元素插入到给定位置
 * @param paraHeader 链表的头节点
 * @param paraChar 待添加的元素
 * @param paraPOsition 插入的位置
 */
void insertElement(NodePtr paraHeader, char paraChar, int paraPosition) {
    NodePtr p, q;

    //1.使p指向待插入位置的上一个节点
    p = paraHeader;
    for (int i = 0; i < paraPosition; i++) {
        p = p->next;
        if (p == NULL) {
            printf("此位置：%d 在链表中不存在", paraPosition);
            return ;
        }
    }

    //2.创造一个新的节点
    q = (NodePtr)malloc(sizeof(LNode));
    q->data = paraChar;

    //3.插入
    printf("linking\r\n");
    q->next = p->next;
    p->next = q;
}

原理图：

从链表中删除数据(给定元素)：

/**
 * 从链表中删除数据
 * @param paraHeader 链表的头节点
 * @param paraChar 待删除的数据
 */
void deleteElement(NodePtr paraHeader, char paraChar) {
    NodePtr p, q;

    //寻找该元素
    p = paraHeader;
    while ((p->next != NULL) && (p->next->data != paraChar)) {
        p = p->next;
    }

    //判断该元素是否存在
    if (p->next == NULL) {
        printf("该元素不存在\r\n");
        return;
    }

    //删除操作
    q = p->next;
    p->next = p->next->next;
    free(q);
}

原理图：

完整代码：

#include <stdio.h>
#include <malloc.h>

/**
 * 定义链表结构体
 */
typedef struct LinkNode {
    char data;
    struct LinkNode *next;
} LNode, *LinkList, *NodePtr;

/**
 * 创建一个只含有一个节点且没有数据的链表
 * @return 指向头节点的指针
 */
LinkList initLinkList() {
    NodePtr tempHeader = (NodePtr)calloc(1, sizeof(LNode));
    tempHeader->next = NULL;
    return tempHeader;
}

/**
 * 打印链表
 * @param paraHeader 链表的头节点
 */
void printList(NodePtr paraHeader) {
    NodePtr p = paraHeader->next;
    while (p != NULL) {
        printf("%c", p->data);
        p = p->next;
    }
    printf("\r\n");
}

/**
 * 尾插法添加链表元素
 * @param paraHeader 指向链表的头节点的指针
 * @param paraChar 待添加的元素
 */
void appendElement(NodePtr paraHeader, char paraChar) {
    NodePtr p, q;

    //1.创造一个新的节点并把paraChar赋给该节点
    q = (NodePtr)malloc(sizeof(LNode));
    q->data = paraChar;
    q->next = NULL;

    //2.使p指向该链表当前的尾结点
    p = paraHeader;
    while (p->next != NULL) {
        p = p->next;
    }

    //3.插入节点
    p->next = q;
}

/**
 * 将元素插入到给定位置
 * @param paraHeader 链表的头节点
 * @param paraChar 待添加的元素
 * @param paraPOsition 插入的位置
 */
void insertElement(NodePtr paraHeader, char paraChar, int paraPosition) {
    NodePtr p, q;

    //1.使p指向待插入位置的上一个节点
    p = paraHeader;
    for (int i = 0; i < paraPosition; i++) {
        p = p->next;
        if (p == NULL) {
            printf("此位置：%d 在链表中不存在", paraPosition);
            return ;
        }
    }

    //2.创造一个新的节点
    q = (NodePtr)malloc(sizeof(LNode));
    q->data = paraChar;

    //3.插入
    printf("linking\r\n");
    q->next = p->next;
    p->next = q;
}

/**
 * 从链表中删除数据
 * @param paraHeader 链表的头节点
 * @param paraChar 待删除的数据
 */
void deleteElement(NodePtr paraHeader, char paraChar) {
    NodePtr p, q;

    //寻找该元素
    p = paraHeader;
    while ((p->next != NULL) && (p->next->data != paraChar)) {
        p = p->next;
    }

    //判断该元素是否存在
    if (p->next == NULL) {
        printf("该元素不存在\r\n");
        return;
    }

    //删除操作
    q = p->next;
    p->next = p->next->next;
    free(q);
}

/**
 *单元测试
 */
void appendInsertDeleteTest() {
    LinkList tempList = initLinkList();
    printList(tempList);

    appendElement(tempList, 'H');
    appendElement(tempList, 'e');
    appendElement(tempList, 'l');
    appendElement(tempList, 'l');
    appendElement(tempList, 'o');
    appendElement(tempList, '!');
    printList(tempList);

    deleteElement(tempList, 'e');
    deleteElement(tempList, 'a');
    deleteElement(tempList, 'H');
    printList(tempList);

    insertElement(tempList, 'o', 1);
    insertElement(tempList, 'a', 0);
    printList(tempList);
}

void basicAddressTest() {
    LNode tempNode1, tempNode2;

    tempNode1.data = 4;
    tempNode1.next = NULL;

    tempNode2.data = 6;
    tempNode2.next = NULL;

    printf("The first node: %p, %p, %p\r\n",
           &tempNode1, &tempNode1.data, &tempNode1.next);
    printf("The second node: %p, %p, %p\r\n",
           &tempNode2, &tempNode2.data, &tempNode2.next);

    tempNode1.next = &tempNode2;
}

int main() {
    appendInsertDeleteTest();
    basicAddressTest();
}

单链表总结与反思：

在编写代码的过程中我发现了一个问题：在删除和在指定位置插入元素的操作中删除第一个元素或者插入到第一元素之前会发生什么呢，我之前一直觉得该链表的头指针会发生变化，包括我在上这门课之前自己写一些链表的时候遇到这些操作也的确如此，那么这两个函数的返回值老师却设置的是void，既不改变头指针，那么问题来了，这样编写程序在遇到上述两个问题时应该会出错，但是实际上运行测试代码的时候并没有发生任何错误，那么老师时怎么做到的呢，经过仔细观察我发现，老师在创建链表的时候给第一个链表结点赋成了’/0'，这样就导致了第一个结点实际上是没有意义的一个结点，只是用来让我们抓住这整个链表用的，后面加入的第一个结点如‘H’在物理意义上已经属于第二个结点了，于是该链表的头指针永远不会发生变化，这样大大减少了一些复杂的操作，例如上学期编写的项目学生管理系统中增删函数中某些的操作，所以思路的改变可以使代码更加的简单，这是一个写程序的人所必须铭记的。

双向链表：

2022.5.2

双向链表和单向链表的区别并不大，无非就是在结点中新定义了一个指向上一个结点的指针而已，这使得该链表可以完成反向遍历的操作，从而在实际应用中获得一些便利。

自然的，双向链表的头结点里指向上一个结点的指针应该指向null，就像单链表的尾结点一样。

双链表完整代码：

#include <stdio.h>
#include <malloc.h>

/**
 * 定义一个双向链表的结点，该结点中包含两个指向该类型结点的指针，用于完成双向链表的相关操作
 */
typedef struct DoubleLinkedNode {
	//数据域
	char data;

	//指向上一个结点的指针
	struct DoubleLinkedNode *previous;

	//指向下一个结点的指针
	struct DoubleLinkedNode *next;
} DLNode, *DLNodePtr;


/**
 * @brief 创建一个链表并返回它的头指针
 *
 * @return tempHeader 指向该链表的头指针
 */
DLNodePtr initLinkList() {
	//为结点申请动态内存
	DLNodePtr tempHeader = (DLNodePtr)malloc(sizeof(DLNode));

	//初始化
	tempHeader->data = '\0';
	tempHeader->previous = NULL;
	tempHeader->next = NULL;

	return tempHeader;
}

/**
 * @brief 打印链表
 *
 * @param paraHeader
 */
void printList(DLNodePtr paraHeader) {
	DLNodePtr p = paraHeader->next;

	//循环遍历打印
	while (p != NULL) {
		printf("%c", p->data);
		p = p->next;
		//TODO
	}

	printf("\r\n");
}

/**
 * @brief 在指定位置插入元素
 *
 * @param paraChar 待插入的元素
 * @param paraHeader 待插入链表的头结点
 * @param paraPosition 待插入的位置
 */
void insertElement(DLNodePtr paraHeader, char paraChar, int paraPosition) {
	DLNodePtr p, q, r;

	//1.找到需要插入的位置,并判断位置是否合法
	p = paraHeader;
	for (int i = 0; i < paraPosition; i ++) {
		p = p->next;
		if (p == NULL || i < 0) {
			printf("此位置：%d 超出了链表的长度或者是一个负数", paraPosition);
			return;
		}
	}

	//2.创造一个新的结点
	q = (DLNodePtr)malloc (sizeof(DLNode));
	q->data = paraChar;

	//3.连接结点
	r = p->next;
	q->next = p->next;
	q->previous = p;
	p->next = q;
	if (r != NULL) {//判断当前插入的位置是否为最后一个结点
		r->previous = q;
	}
}

void deleteElement(DLNodePtr paraHeader, char paraChar) {
	DLNodePtr p, q, r;

	//1.找到待删除的元素
	p = paraHeader;
	while ((p->next != NULL) && (p->next->data != paraChar)) {
		p =p->next;
	}
	
	//2.判断该元素是否存在
	if (p->next == NULL) {
		printf("该元素：%c 不存在。\r\n", paraChar);
		return;
	}
	
	//3.存在就删去
	q = p->next;
	r = q->next;
	p->next = r;
	if (r != NULL) {
		r->previous = p;
	}
	
	//释放内存
	free(q);

}

/**
 * 单元测试
 */
void addInsertDeleteTest(){
	// 1.创建一个空的链表
	DLNodePtr tempList = initLinkList();
	printList(tempList);
	
	// 2.加入数据
	insertElement(tempList, 'H', 0);
	insertElement(tempList, 'e', 1);
	insertElement(tempList, 'l', 2);
	insertElement(tempList, 'l', 3);
	insertElement(tempList, 'o', 4);
	insertElement(tempList, '!', 5);
	printList(tempList);
	
	// 3.删除数据
	deleteElement(tempList, 'e');
	deleteElement(tempList, 'a');
	deleteElement(tempList, 'o');
	printList(tempList);
	
	// 插入数据
	insertElement(tempList, 'o', 1);
	printList(tempList);
}

/**
 * 地址测试
 */
void basicAddressTest(){
	DLNode tempNode1, tempNode2;
	
	tempNode1.data = 4;
	tempNode1.next = NULL;
	
	tempNode2.data = 6;
	tempNode2.next = NULL;
	
	printf("The first node: %p, %p, %p\r\n",
		&tempNode1, &tempNode1.data, &tempNode1.next);
	printf("The second node: %p, %p, %p\r\n",
		&tempNode2, &tempNode2.data, &tempNode2.next);
	
	tempNode1.next = &tempNode2;
}

int main(){
	addInsertDeleteTest();
	basicAddressTest();
}

运行结果：


Hello!
该元素：a 不存在。
Hll!
Holl!
The first node: 000000e3985ff770, 000000e3985ff770, 000000e3985ff780
The second node: 000000e3985ff750, 000000e3985ff750, 000000e3985ff760

StazSans

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
C语言数据结构 2.2&2.3：单链表与双向链表

概念：链表是以链式结构存储数据的，其中的元素在存储器上的位置是任意的，既逻辑上的相邻在屋里位置上不一定相邻。图示：结点：链表：头指针是指向头结点的指针。代码演示：定义链表结点：/** * 定义链表结构体 */typedef struct LinkNode { char data; struct LinkNode *next;} LNode, *LinkList, *NodePtr;创建一个只含有一个节点且没有数据的链表:/*..
复制链接

扫一扫