数据结构第三天——双向链表、静态链表

已于 2022-07-23 11:51:41 修改
阅读量590 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 链表 数据结构 散列表 c语言
于 2022-05-02 12:58:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65406049/article/details/124537723
版权

首先是双向链表

1.创建

typedef struct DoubleLinkedNode{
	char data;
	struct DoubleLinkedNode *previous;
	struct DoubleLinkedNode *next;
} DLNode, *DLNodePtr;

2.初始化

DLNodePtr initLinkList(){
	DLNodePtr tempHeader = (DLNodePtr)malloc(sizeof(DLNode));
	tempHeader->data = '\0';
	tempHeader->next = NULL;
	tempHeader->previous = NULL;
	return tempHeader;
}

3.插入

void insertElement(DLNodePtr paraHeader, char paraChar, int paraPosition){
	DLNodePtr p, q, r;
	
	p = paraHeader;
	int i;
	for (i = 0; i < paraPosition; i ++) {
		p = p->next;
		if (p == NULL) {
			printf("The position %d is beyond the scope of the list.", paraPosition);
			return;
		}
	}
	
	q = (DLNodePtr)malloc(sizeof(DLNode));
	q->data = paraChar;
	
	r = p->next;
	q->next = r;
	q->previous = p;
	p->next = q;
	if (r != NULL) {
		r->previous = q;
	}
}

4.删除

void deleteElement(DLNodePtr paraHeader, char paraChar){
	DLNodePtr p, q, r;
	p = paraHeader;
	
	while ((p->next != NULL) && (p->next->data != paraChar)){
		p = p->next;
	}
	
	if (p->next == NULL) {
		printf("The char '%c' doer not exist.\n", paraChar);
		return;
	}
	
	q = p->next;
	r = q->next;
	p->next = r;
	if (r != NULL) {
		r->previous = p;
	}
	
	free(q);
}

 

5.查找

DLNodePtr locateElement(DLNodePtr paraHeader, char paraChar){
	DLNodePtr p = paraHeader;
	
	while ((p->next != NULL) && (p->next->data != paraChar)) {
		p = p->next;
	}
	
	if (p->next == NULL) {
		printf("The char '%c' does not exist\n", paraChar);
		return;
	}
	
	return p;
}

 6.总代码

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

typedef struct DoubleLinkedNode{
	char data;
	struct DoubleLinkedNode *previous;
	struct DoubleLinkedNode *next;
} DLNode, *DLNodePtr;

/**
 *创建头结点
 */
 
DLNodePtr initLinkList(){
	DLNodePtr tempHeader = (DLNodePtr)malloc(sizeof(DLNode));
	tempHeader->data = '\0';
	tempHeader->next = NULL;
	tempHeader->previous = NULL;
	return tempHeader;
}

/**
 *输出
 */
 
void printList(DLNodePtr paraHeader){
	DLNodePtr p = paraHeader->next;
	while (p != NULL) {
		printf("%c", p->data);
		p = p->next;
	}
	printf("\n");
} 

/**
 *插入元素
 */
 
void insertElement(DLNodePtr paraHeader, char paraChar, int paraPosition){
	DLNodePtr p, q, r;
	
	p = paraHeader;
	int i;
	for (i = 0; i < paraPosition; i ++) {
		p = p->next;
		if (p == NULL) {
			printf("The position %d is beyond the scope of the list.", paraPosition);
			return;
		}
	}
	
	q = (DLNodePtr)malloc(sizeof(DLNode));
	q->data = paraChar;
	
	r = p->next;
	q->next = r;
	q->previous = p;
	p->next = q;
	if (r != NULL) {
		r->previous = q;
	}
} 

/**
 *删除
 */
 
void deleteElement(DLNodePtr paraHeader, char paraChar){
	DLNodePtr p, q, r;
	p = paraHeader;
	
	while ((p->next != NULL) && (p->next->data != paraChar)){
		p = p->next;
	}
	
	if (p->next == NULL) {
		printf("The char '%c' doer not exist.\n", paraChar);
		return;
	}
	
	q = p->next;
	r = q->next;
	p->next = r;
	if (r != NULL) {
		r->previous = p;
	}
	
	free(q);
} 

/**
 *查找
 */
 
DLNodePtr locateElement(DLNodePtr paraHeader, char paraChar){
	DLNodePtr p = paraHeader;
	
	while ((p->next != NULL) && (p->next->data != paraChar)) {
		p = p->next;
	}
	
	if (p->next == NULL) {
		printf("The char '%c' does not exist\n", paraChar);
		return NULL;
	}
	
	return p;
}

/**
 *测试
 */
 
void insertDeleteTest(){
	DLNodePtr tempList = initLinkList();
	printList(tempList);
	
	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);
	
	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\n", &tempNode1, &tempNode1.data, &tempNode1.next);
	printf("The second node: %p, %p, %p\n", &tempNode2, &tempNode2.data, &tempNode2.next);
} 

void locateElementTest(){
	DLNodePtr tempList = initLinkList();
	
	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);
	
	DLNodePtr newList = locateElement(tempList, 'e');
	if (newList != NULL) {
		printList(newList);
	}
	newList = locateElement(tempList, 'a');
	if (newList != NULL) {
		printList(newList);
	}
	newList = locateElement(tempList, 'o');
	if (newList != NULL) {
		printList(newList);
	}
}

int main(){
	insertDeleteTest();
	basicAddressTest();
	locateElementTest();
	
	return 0;
}

运行结果

静态链表

1.创建

typedef struct StaticLinkedNode{
	char data;
	
	int next;
} *NodePtr;

typedef struct StaticLinkedList{
	NodePtr nodes;
	int* used;
} *ListPtr;

 2.带头

结点的链表

ListPtr initLinkedList(){
	ListPtr tempPtr = (ListPtr)malloc(sizeof(struct StaticLinkedList));
	
	tempPtr->nodes = (NodePtr)malloc(sizeof(struct StaticLinkedNode) * DEFAUL_SIZE);
	tempPtr->used = (int*)malloc(sizeof(int) * DEFAUL_SIZE);
	
	tempPtr->nodes[0].data = '\0';
	tempPtr->nodes[0].next = -1;
	
	tempPtr->used[0] = 1;
	int i;
	for (i = 1; i < DEFAUL_SIZE; i ++){
		tempPtr->used[i] = 0;
	}
	
	return tempPtr;
}

3.输出

void printList(ListPtr paraListPtr){
	int p=0;
	while (p != -1) {
		printf("%c", paraListPtr->nodes[p].data);
		p = paraListPtr->nodes[p].next;
	}
	printf("\n");
}

4.插入

void insertElement(ListPtr paraListPtr, char paraChar, int paraPosition){
	int p, q, i;
	
	p = 0;
	for (i = 0; i < paraPosition; i ++){
		p = paraListPtr->nodes[p].next;
		if (p == -1) {
			printf("The position %d is beyond the scope of the list.\n", paraPosition);
			return;
		}
	}
	
	for (i = 1; i < DEFAUL_SIZE; i ++){
		if (paraListPtr->used[i] == 0){
			printf("Space at %d allocated.\n", i);
			paraListPtr->used[i] = 1;
			q = i;
			break;
		}
	}
	
	if (i == DEFAUL_SIZE){
		printf("No space.\n");
		return;
	}
	
	paraListPtr->nodes[q].data = paraChar;
	
	printf("linking\n");
	paraListPtr->nodes[q].next = paraListPtr->nodes[p].next;
	paraListPtr->nodes[p].next = q;
}

5.删除

void deleteElement(ListPtr paraListPtr, char paraChar){
	int p, q;
	p = 0;
	while ((paraListPtr->nodes[p].next != -1) && (paraListPtr->nodes[paraListPtr->nodes[p].next].data != paraChar)){
		p = paraListPtr->nodes[p].next;
	}
	
	if (paraListPtr->nodes[p].next == -1) {
		printf("Cannot delete %c\n", paraChar);
		return;
	}
	
	q = paraListPtr->nodes[p].next;
	paraListPtr->nodes[p].next = paraListPtr->nodes[paraListPtr->nodes[p].next].next;
	
	paraListPtr->used[q] = 0;
}

 

总代码

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

#define DEFAUL_SIZE 5

typedef struct StaticLinkedNode{
	char data;
	
	int next;
} *NodePtr;

typedef struct StaticLinkedList{
	NodePtr nodes;
	int* used;
} *ListPtr;

/**
 *带头结点的链表
 */
 
ListPtr initLinkedList(){
	ListPtr tempPtr = (ListPtr)malloc(sizeof(struct StaticLinkedList));
	
	tempPtr->nodes = (NodePtr)malloc(sizeof(struct StaticLinkedNode) * DEFAUL_SIZE);
	tempPtr->used = (int*)malloc(sizeof(int) * DEFAUL_SIZE);
	
	tempPtr->nodes[0].data = '\0';
	tempPtr->nodes[0].next = -1;
	
	tempPtr->used[0] = 1;
	int i;
	for (i = 1; i < DEFAUL_SIZE; i ++){
		tempPtr->used[i] = 0;
	}
	
	return tempPtr;
} 

/**
 *输出
 */
 
void printList(ListPtr paraListPtr){
	int p=0;
	while (p != -1) {
		printf("%c", paraListPtr->nodes[p].data);
		p = paraListPtr->nodes[p].next;
	}
	printf("\n");
} 

/**
 *插入
 */
 
void insertElement(ListPtr paraListPtr, char paraChar, int paraPosition){
	int p, q, i;
	
	p = 0;
	for (i = 0; i < paraPosition; i ++){
		p = paraListPtr->nodes[p].next;
		if (p == -1) {
			printf("The position %d is beyond the scope of the list.\n", paraPosition);
			return;
		}
	}
	
	for (i = 1; i < DEFAUL_SIZE; i ++){
		if (paraListPtr->used[i] == 0){
			printf("Space at %d allocated.\n", i);
			paraListPtr->used[i] = 1;
			q = i;
			break;
		}
	}
	
	if (i == DEFAUL_SIZE){
		printf("No space.\n");
		return;
	}
	
	paraListPtr->nodes[q].data = paraChar;
	
	printf("linking\n");
	paraListPtr->nodes[q].next = paraListPtr->nodes[p].next;
	paraListPtr->nodes[p].next = q;
} 

/**
 *删除
 */
 
void deleteElement(ListPtr paraListPtr, char paraChar){
	int p, q;
	p = 0;
	while ((paraListPtr->nodes[p].next != -1) && (paraListPtr->nodes[paraListPtr->nodes[p].next].data != paraChar)){
		p = paraListPtr->nodes[p].next;
	}
	
	if (paraListPtr->nodes[p].next == -1) {
		printf("Cannot delete %c\n", paraChar);
		return;
	}
	
	q = paraListPtr->nodes[p].next;
	paraListPtr->nodes[p].next = paraListPtr->nodes[paraListPtr->nodes[p].next].next;
	
	paraListPtr->used[q] = 0;
}

/**
 *测试
 */
 
void appendInsertDeleteTest(){
	ListPtr tempList = initLinkedList();
	printList(tempList);
	
	insertElement(tempList, 'H', 0);
	insertElement(tempList, 'e', 1);
	insertElement(tempList, 'l', 2);
	insertElement(tempList, 'l', 3);
	insertElement(tempList, 'o', 4);
	printList(tempList);
	
	printf("Deleting 'e'.\n");
	deleteElement(tempList, 'e');
	printf("Deleting 'a'.\n");
	deleteElement(tempList, 'a');
	printf("Deleting 'o'.\n");
	deleteElement(tempList, 'o');
	printList(tempList);
	
	insertElement(tempList, 'x', 1);
	printList(tempList);
} 

int main(){
	appendInsertDeleteTest();
	
	return 0;
}

 运行结果

总结

1.双向链表使用时，部分操作和单链表一致，差异处在于插入和删除，注意前驱和后继需要改变

2.静态链表用数组的序号来表示内存中的地址，可以直观的看到储存，插入和删除的思路和单链表是一致的，只是在操作上还要将存储空间（也就是used数组）的值修改

3.在测试locateElement函数时，出现了一个问题，那就是在输出的时候，没有考虑到NULL的情况，导致如果有一个查找返回的是NULL，那么之后的查找就不能运行，所以我在打印的时候加了一个判断条件就可以了

想了半天也不知道取什么名字
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
特殊的链表——双向、循环、静态
01-20
双向链表 定义 ：每个节点有两个指针域，分别知道直接前驱和直接后继节点 ， 特点是可以重任意节点出发，从两个方向遍历链表 数据结构 typedef struct node { int data; struct node *font ; struct node *next; } NODE, *LinkList; 插入 // p 为链中节点 s 为待插入节点 把s 放在p前 s->font = p->font ; // s 的前驱在是 p 的前驱节点 p->font->next = s ; // p 前驱节点的 后继节点是 s s->n
数据结构——用C描述
12-15
这里有三种链表实现：单链表、双链表和静态链表。单链表的每个节点包含数据域和一个指向下一个节点的指针。双链表在单链表的基础上增加了指向前一个节点的指针，使得双向遍历成为可能。静态链表则是在数组中模拟链表...
数据结构作业三：双向链表与静态链表
greatwaves11的博客
05-02 698
双向链表： 双向链表也叫双链表，是链表的一种，它的每个数据 结点 中都有两个 指针 ，分别指向直接后继和直接前驱。 所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。 一，结构体定义及宏 #include <stdio.h> #include <malloc.h> /** * 定义字符双向链表。 */ typedef struct DoubleLinkNode{ char data; struct...
数据结构3：双向链表
qq_61635925的博客
05-02 368
双向链表定义 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。双向链表比单链表稍复杂, 也更不常用. 主要是为了练习链表的变种, 寻找更多设计的感觉. 这样在面对实际问题的时候, 就具有一定的建模能力。 双向链表操作 1.定义 typedef struct DoubleLinkedNode { char data; struct DoubleLinked...
【链表的学习】实现链表的几种方法
cchengjie007的博客
01-01 980
1.静态链表 const int N = 10000; //按需要定义静态链表的空间大小 struct node{ //单向链表 int id; //这个结点的id int data; //数据 int nextid; //指向下一个结点的id }n
【UVA 12657】Boxes in a Line 题解（静态双向链表）
HEX9CF的技术博客
02-10 88
您在编号为1的表格上有n个方框。n从左到右。您的任务是模拟4命令类型：•1 X Y：将框X向左移动到Y（如果X已经是Y的左侧，则忽略此项）•2 X Y：将框X向右移动到Y（如果X已经是Y的右侧，则忽略此项）•3 X Y：交换盒X和Y•4：反转整条线路。命令保证有效，即X不等于Y。例如，如果n＝6，在执行1 1 4之后，该行变为2 3 1 4 5 6。然后在执行之后2 3 5，直线变为2 1 4 5 3 6。然后在执行3 1 6之后，该行变为2 6 4 5 3 1。
c语言数组指定位置插入和删除-玩转C语言链表，单链表双向链表的建立遍历插入删除... 数组和链表.pdf
04-18
三、双向链表的概念 双向链表是一种特殊的链表，每个结点不仅有指向下一个结点的指针，还有指向上一个结点的指针。这样可以从任意一个结点开始遍历整个链表。 四、循环链表的概念 循环链表是一种特殊的链表，其中...
数据结构用C语言——唐策善
02-25
第三章 栈和队列：栈是一种后进先出（LIFO）的数据结构，常用于表达式求值、递归等问题；队列则是先进先出（FIFO）的数据结构，常应用于任务调度和缓冲区管理。本章会涵盖这两种数据结构的实现及应用。 第四章 串：...
清华大学数据结构计划20071
08-08
教材方面，推荐使用殷人昆、邓俊辉、舒继武等人编写的《数据结构（用面向对象方法与C++语言描述）（第二版）》作为主教材，以及《数据结构习题解析（用面向对象方法与C++语言描述）》作为习题集，以辅助学习。...
数据结构(含实训)——C语言版(习题案例库).docx
04-01
本文将围绕《数据结构(含实训)——C语言版》中的知识点进行详细阐述。 1. **双链表**：双链表是一种线性数据结构，每个节点包含指向前后节点的指针，因此在双链表中删除已知结点*s*的时间复杂度为O(1)，因为只需要...
静态双链表
最新发布
wsywsyyy的博客
09-14 61
双链表的话，这里不定义指针，而是定义左右两个节点。l[ ]和r[ ]数组的意思是：l[k]表示的意思是k左边的节点，存的值是左节点的地址，r[ ]也一样。还有也要注意一下add操作，倒数第二个和倒数第三个不要写反。刚开始要初始化一下。这里就不需要add_to_head函数了，因为我们有左节点。
学习笔记：2.3 静态链表 循环链表 双向链表
张小憨憨的博客
10-08 509
2.3 静态链表 循环链表 双向链表 （注意：所有代码均已成功测试。编译环境：devC++） 1. 静态链表 用数组描述的链表叫做静态链表，又称游标实现法。 首先，让数组的元素都是由两个数据域组成,data和cur。即为,数组的每一个下标都对应一个data和一个cur。数据域data，用来存放数据元素，而cur相当于单链表中的next指针，存放该元素的后继在数组中的下标，我们通常把cur叫做下标。 注意：为了方便插入数据，通常会把数据建立得大一些，以便可以有一些空闲空间便于插入时不至于溢出。 //线性表的静
3.双向链表&静态链表
DoZhangQiang的博客
05-03 1003
一 双向链表 1.1 双向链表概述 双向链表就是在单链表的基础上，在定义结构体的时候做了一些手脚，在单链表中结构体的内容为数据以及指向下一个结点的指针，在双向链表中，增加了指向前一个结点元素的指针，即实现了对指定元素前驱和后继的查询。代价就是增加了1/3的空间储存。 内存分配图如下: 1.2 双向链表的优势 双向链表实现了一个十分重要的功能是自我删除。即: p->previous->next=p->ne...
静态双向链表的单数组实现
乘风破浪会有时
08-28 821
静态双向链表的单数组实现方式
数据结构-双向链表和静态链表
qq_62682123的博客
05-03 511
一，双向链表 定义 typedef struct DoubleLinkedNode { char data; struct DoubleLinkedNode* previous; struct DoubleLinkedNode* next; }DLNode,*DLNodePtr; 初始化 DLNodePtr initLinkList() { DLNodePtr tempHeader = (DLNodePtr)malloc(sizeof(struct DoubleLinkedNode))
考研复习之数据结构笔记（四）线性表（下）（线性表的链式表示：单链表、循环链表、静态链表、双向链表以及顺序表与链表的比较）
欢迎交流！
07-01 755
目录一、线性表的链式表示1.1 单链表（1）相关概念及特点（2）头结点（哨兵位）（3）单链表的相关实现（以下代码实现默认无哨兵位，无哨兵位更具有普适性）1.2 双向链表1.3 循环链表1.4 静态链表二、顺序表与链表的比较2.1 顺序存储和链式存储典型特点2.2 顺序表和链表的具体区别单链表指结点中只含一个指针域的链表，也称线性链表。单链表结点结构下所示，其中data为数据域，存放数据元素；next 为指针域，存放其后继结点的地址。 相关特点：1.利用单链表可以解决顺序表需要大量连续存储单元的缺点。2.
双链表与循环链表和静态链表
liyulin90的博客
04-22 1319
删除指定结点的后结点
顺序表与链表
didiao7566的专栏
09-11 280
顺序表与链表是非常基本的数据结构，它们可以被统称为线性表。 线性表（Linear List）是由 n（n≥0）个数据元素（结点）a[0]，a[1]，a[2]…，a[n-1] 组成的有限序列。 顺序表和链表，是线性表的不同存储结构。它们各自有不同的特点和适用范围。针对它们各自的缺点，也有很多改进的措施。 一、顺序表 顺序表一般表现为数组，使用一组地址连续的存储单元依次存储数据元素，...
C语言自动预订飞机票问题
程序设计
07-06 513
2．自动预订飞机票问题（难度2) 设民航公司有一个自动预订飞机票的系统。该系统中有一张用单向链表表示的乘客表，下表中的结点按乘客姓氏的字母顺序相链。例如，下面是张某个时刻的乘客表。设计程序完成以下功能。序号 data link rlink 1 lu 6 5 2 chan 4 9 3 wang 5 7 4 bao 0 2 5 mai 1 3 6 dong 8 1 7 xi 3 0 8 deng 9 6 9 cuang 2 81)建立一个静态双向链表L; 2)输入表中记录; 3)输出表中所有记录; 4)任一乘客
数据结构基础：链表与双向链表解析
"本文主要介绍了数据结构中的基础概念，包括数组、链表、栈和队列，并特别关注了链表中的单链表和双向链表。此外，还提到了字符串在不同编程环境下的使用方式。" 在计算机科学中，数据结构是组织和存储数据的方式，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值