数据结构与算法（2）

最新推荐文章于 2022-11-07 13:40:05 发布
最新推荐文章于 2022-11-07 13:40:05 发布
阅读量322 收藏 2
点赞数
分类专栏： LINUX
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40632341/article/details/104302833
版权

1 双向线性链表
2 单向线性链表
1 双向线性链表
1.1 问题
双向线性链表是采用链式存储的方式存储的线性表。链式存储结构是由一系列结点（链表中每一个元素称为结点）组成，每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储当前结点的前驱结点和后继结点地址的指针域，结点是在有数据时动态生成的，是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

1.2 方案
双向线性链表的基本操作包括：

  1. 初始化操作，在初始化操作中将双向线性链表的头指针指空。

  2. 求表长，求表长操作是计算出双向线性链表中结点的个数。

  3. 取双向线性链表中指定位置的结点，即给定双向线性链表中的第几个结点，求其值。

  4. 查找结点，在双向线性链表中查找值为x的结点，并返回该结点在双向线性链表中的位置。若双向线性链表中有多个结点的值和x相同，则返回首次找到的结点位；若双向线性链表中没有结点的值为x，则返回一个NULL表示查找失败。

  5. 插入结点，在双向线性链表的第i个结点前插入一个值为x的新结点。

  6. 删除结点，删除双向线性链表的第i个结点。

1.3 步骤
实现此案例需要按照如下步骤进行。

步骤一：定义双向线性链表

在C语言中：

1)定义一个变量来表示双向线性链表中某个结点的数据。

2)定义两个指针来表示该结点的前驱结点和后继结点的地址。

3)这两方面的信息共同描述一个双向线性链表的结点，可将它们封装在一起。

代码如下所示：

typedef int DataType;
struct Node{
DataType data;
struct Node *pre, *next;
};
上述代码中，以下代码：

typedef int DataType;
是将数据类型int起了一个别名叫做DataType，并在后面的程序中只使用DataType，而不使用int。这样做的好处是当双向线性链表中的数据类型发生变化时，只需要修改此句中的int为要改变的数据类型，即可将程序中所有数据变量的数据类型变成指定的类型。

上述代码中，以下代码：

struct Node *pre, *next;

分别定义了当前结点的前驱指针和后继指针。因为当前结点的前驱结点和后继结点都是双向线性链表的结点数据类型，所以前驱指针和后继指针也是struct Node *类型。

步骤二：初始化操作

在主程序中，定义双向线性链表的头指针。

在初始化函数中将头指针初始化为NULL，表示为空表。

代码如下所示：

void init(struct Node** head)
{
*head = NULL;
}
int main()
{

//头指针
struct Node *headList;
init(&headList);

}
步骤三：求表长

求表长即求双向线性链表中结点的个数，结点的个数是通过遍历链表并统计结点个数得到的。

代码如下所示：

int getSize(struct Node* head)
{
struct Node* p = head;
int count = 0;
while§
{
count ++;
p = p->next;
}
return count;
}
步骤四：取链表中指定位置的数据元素

首先，判断要查找的是否为头结点。

然后，遍历链表，确定要查找的结点位置。

代码如下：

struct Node* getptr(struct Node* head, int pos) {
struct Node *p = head;
if (p == 0 || pos == 0) {
return head;
}
for(int i = 0; p && i < pos; i++) {
p = p->next;
}
return p;
}
步骤五：插入结点

首先，判断要插入的结点位置是否正确。

然后，创建结点。

最后，插入结点，插入时分两种情况处理：一种是插入到第一个结点前面，另一种是插入到链表中间。

//指定位置 插入元素
bool insert(struct Node** head, int position, DataType d) {
if (position < 0 || position > getSize(*head)) {
return false;
}
//创建 节点
struct Node node = (struct Node)malloc(sizeof(struct Node));
node->data = d;
node->pre = NULL;
node->next = NULL;

//插入到第一个节点的前面
if (position == 0) {
    node->next = *head;
    if (*head != NULL)
        (*head)->pre = node;
    *head = node;
    return true;
}

//插入到链表的中间
struct Node *p = getptr(*head, position - 1);
struct Node* r = p->next;
node->next = r;
r->pre = node;
p->next = node;
node->pre = p;

return true;

}
上述代码中，以下代码：

    if (*head != NULL)
        (*head)->pre = node;

是判断头指针是否为空，如果不为空，则头指针指向的结点的前驱指针指向新加入的结点。

上述代码中，以下代码：

node->next = r;
r->pre = node;
p->next = node;
node->pre = p;

node为要插入的新结点，插入到p和r指向的结点之间，所以node的后继结点指针指向r，r的前驱结点指针指向node，node的前驱指针指向p，p的后继指针指向node。

步骤六：删除节点

首先，判断要删除的结点位置是否正确。

然后，删除结点，删除时分两种情况处理：一种是删除第一个结点，另一种是删除链表的中间结点。

最后，释放被删除结点所占有的存储空间。

代码如下：

//删除指定位置元素
bool erases(struct Node** head, int pos) {
if (pos < 0 || pos >= getSize(*head))
return false;

//删除第一个结点
struct Node *p = *head;
if (pos == 0) {
    *head = (*head)->next;
    if (*head != NULL)
        (*head)->pre = NULL;
    free(p);
    p = NULL;
    return true;
}

//删除链表的中间结点
p = getptr(*head, pos - 1);
struct Node *q = p->next;
p->next = q->next;
q->next->pre = p;
free(q);
q = NULL;

return true;

}
上述代码中，以下代码：

    if (*head != NULL)
        (*head)->pre = NULL;

是删除链表的头结点后，如果头指针不为空，即链表中还有结点，则让新的头结点的前驱指针为空。

上述代码中，以下代码：

p->next = q->next;
q->next->pre = p;

p指向要删除结点的前一结点，q指向要删除的结点，此时只需要让p由指向q，改为指向q的后继结点；让q的后继结点的前驱指针由指向q，改为指向p，即可将要删除的结点q从链表中断开，从而达到删除的目的。

步骤七：修改结点中数据

首先，判断要修改的结点是否在链表内。

然后，找到要修改的结点的位置。

最后，修改结点的数据。

//修改指定位置 元素
bool set(struct Node* head, int pos, DataType d) {
if (pos < 0 || pos >= getSize(head)) {
return false;
}
struct Node *p = getptr(head, pos);
p->data = d;
return true;
}
步骤八：删除链表

首先，遍历整个链表。

然后，逐个释放链表中每个结点。

void clears(struct Node* head) {
while (head) {
struct Node *p = head->next;
free(head);
head = p;
}
}
1.4 完整代码
本案例的完整代码如下所示：

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
typedef int DataType;
struct Node{
DataType data;
struct Node pre, next;
};
void init(struct Node head)
{
head = NULL;
}
int getSize(struct Node head)
{
struct Node* p = head;
int count = 0;
while§
{
count ++;
p = p->next;
}
return count;
}
//找到指定位置 元素地址
struct Node* getptr(struct Node* head, int pos) {
struct Node p = head;
if (p == 0 || pos == 0) {
return head;
}
for(int i = 0; p && i < pos; i++) {
p = p->next;
}
return p;
}
//指定位置 插入元素
bool insert(struct Node* head, int position, DataType d) {
if (position < 0 || position > getSize(*head)) {
return false;
}
//创建 节点
struct Node node = (struct Node)malloc(sizeof(struct Node));
node->data = d;
node->pre = NULL;
node->next = NULL;

//插入到第一个节点的前面
if (position == 0) {
    node->next = *head;
    if (*head != NULL)
        (*head)->pre = node;
    *head = node;
    return true;
}

//插入到链表的中间
struct Node *p = getptr(*head, position - 1);
struct Node* r = p->next;
node->next = r;
r->pre = node;
p->next = node;
node->pre = p;

return true;

}
//删除指定位置元素
bool erases(struct Node** head, int pos) {
if (pos < 0 || pos >= getSize(*head))
return false;

//删除第一个结点
struct Node *p = *head;
if (pos == 0) {
    *head = (*head)->next;
    if (*head != NULL)
        (*head)->pre = NULL;
    free(p);
    p = NULL;
    return true;
}

//删除链表的中间结点
p = getptr(*head, pos - 1);
struct Node *q = p->next;
p->next = q->next;
q->next->pre = p;
free(q);
q = NULL;

return true;

}
//修改指定位置 元素
bool set(struct Node* head, int pos, DataType d) {
if (pos < 0 || pos >= getSize(head)) {
return false;
}
struct Node p = getptr(head, pos);
p->data = d;
return true;
}
//清理 链表
void clears(struct Node head) {
while (head) {
struct Node p = head->next;
free(head);
head = p;
}
}
//打印
void print(struct Node head) {
struct Node *p = head;
while § {
printf("%d “, p->data);
p = p->next;
}
printf(”\n");
}
int main()
{

//头指针
struct Node *headList;
init(&headList);

insert(&headList, 0, 10);
insert(&headList, 0, 20);
insert(&headList, 0, 30);
insert(&headList, 2, 40);
insert(&headList, 2, 50);
insert(&headList, 0, 60);
insert(&headList, 0, 80);
print(headList);
erases(&headList, 1);
print(headList);
set(headList, 0, 100);
set(headList, 0, 110);
print(headList);

return 0;

}
2 单向线性链表
2.1 问题
单向线性链表是采用链式存储的方式存储的线性表。链式存储结构是由一系列结点（链表中每一个元素称为结点）组成，每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域，结点是在有数据时动态生成的，是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

2.2 方案
链表的基本操作包括：

  1. 初始化操作，在初始化操作中将单向线性链表的头指针指空。

  2. 求表长，求表长操作是计算出单向线性链表中结点的个数。

  3. 取单向线性链表中指定位置的结点，即给定链表中的第几个结点，求其值。

  4. 查找结点，在单向线性链表中查找值为x的结点，并返回该结点在单向线性链表中的位置。若单向线性链表中有多个结点的值和x相同，则返回首次找到的结点位；若单向线性链表中没有结点的值为x，则返回一个NULL表示查找失败。

  5. 插入结点，在单向线性链表的第i个结点前插入一个值为x的新结点。

  6. 删除结点，删除单向线性链表的第i个结点。

2.3 步骤
实现此案例需要按照如下步骤进行。

步骤一：定义单向线性链表

在C语言中：

1)定义一个变量来表示单向线性链表中某个结点的数据。

2)定义一个指针来表示该结点的后继结点的地址。

3)这两方面的信息共同描述一个单向线性链表的结点，可将它们封装在一起。

代码如下所示：

typedef int DataType;
struct Node{
DataType data;
struct Node *next;
};
上述代码中，以下代码：

typedef int DataType;
是将数据类型int起了一个别名叫做DataType，并在后面的程序中只使用DataType，而不使用int。这样做的好处是当链表中的数据类型发生变化时，只需要修改此句中的int为要改变的数据类型，即可将程序中所有数据变量的数据类型变成指定的类型。

步骤二：初始化操作

在主程序中，定义链表的头指针。

在初始化函数中将头指针初始化为NULL，表示为空表。

代码如下所示：

void init(struct Node** head)
{
*head = NULL;
}
int main()
{

//头指针
struct Node *headList;
init(&headList);

}
步骤三：求表长

求表长即求链表中结点的个数，结点的个数是通过遍历链表并统计结点个数得到的。

代码如下所示：

int getSize(struct Node* head)
{
struct Node* p = head;
int count = 0;
while§
{
count ++;
p = p->next;
}
return count;
}
步骤四：取链表中指定位置的数据元素

首先，判断要查找的是否为头结点。

然后，遍历链表，确定要查找的结点位置。

代码如下：

struct Node* getptr(struct Node* head, int pos) {
struct Node *p = head;
if (p == 0 || pos == 0) {
return head;
}
for(int i = 0; p && i < pos; i++) {
p = p->next;
}
return p;
}
步骤五：插入结点

首先，判断要插入的结点位置是否正确。

然后，创建结点。

最后，插入结点，插入时分两种情况处理：一种是插入到第一个结点前面，另一种是插入到链表中间。

bool insert(struct Node** head, int position, DataType d) {
if (position < 0 || position > getSize(*head)) {
return false;
}
//创建 节点
struct Node node = (struct Node)malloc(sizeof(struct Node));
node->data = d;
node->next = NULL;

//插入到第一个节点的前面
if (position == 0) {
    node->next = *head;
    *head = node;
    return true;
}

//插入到链表的中间
struct Node *p = getptr(*head, position - 1);
struct Node* r = p->next;
node->next = r;
p->next = node;

return true;

}
步骤六：删除节点

首先，判断要删除的结点位置是否正确。

然后，删除结点，删除时分两种情况处理：一种是删除第一个结点，另一种是删除链表的中间结点。

最后，释放被删除结点所占有的存储空间。

代码如下：

bool erases(struct Node** head, int pos) {
if (pos < 0 || pos >= getSize(*head))
return false;
struct Node *p = *head;
if (pos == 0) {
*head = (*head)->next;
free§;
p = NULL;
return true;
}
p = getptr(*head, pos - 1);
struct Node *q = p->next;
p->next = q->next;
free(q);
q = NULL;

return true;

}
步骤七：修改结点中数据

首先，判断要修改的结点是否在链表内。

然后，找到要修改的结点的位置。

最后，修改结点的数据。

bool set(struct Node* head, int pos, DataType d) {
if (pos < 0 || pos >= getSize(head)) {
return false;
}
struct Node *p = getptr(head, pos);
p->data = d;
return true;
}
步骤八：删除链表

首先，遍历整个链表。

然后，逐个释放链表中每个结点。

void clears(struct Node* head) {
while (head) {
struct Node *p = head->next;
free(head);
head = p;
}
}
2.4 完整代码
本案例的完整代码如下所示：

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
typedef int DataType;
struct Node{
DataType data;
struct Node next;
};
void init(struct Node* head)
{
head = NULL;
}
int getSize(struct Node head)
{
struct Node* p = head;
int count = 0;
while§
{
count ++;
p = p->next;
}
return count;
}
//找到指定位置 元素地址
struct Node* getptr(struct Node* head, int pos) {
struct Node p = head;
if (p == 0 || pos == 0) {
return head;
}
for(int i = 0; p && i < pos; i++) {
p = p->next;
}
return p;
}
//指定位置 插入元素
bool insert(struct Node* head, int position, DataType d) {
if (position < 0 || position > getSize(*head)) {
return false;
}
//创建 节点
struct Node node = (struct Node)malloc(sizeof(struct Node));
node->data = d;
node->next = NULL;

//插入到第一个节点的前面
if (position == 0) {
    node->next = *head;
    *head = node;
    return true;
}

//插入到链表的中间
struct Node *p = getptr(*head, position - 1);
struct Node* r = p->next;
node->next = r;
p->next = node;

return true;

}
//删除指定位置元素
bool erases(struct Node** head, int pos) {
if (pos < 0 || pos >= getSize(*head))
return false;
struct Node *p = *head;
if (pos == 0) {
*head = (*head)->next;
free§;
p = NULL;
return true;
}
p = getptr(*head, pos - 1);
struct Node *q = p->next;
p->next = q->next;
free(q);
q = NULL;

return true;

}
//修改指定位置 元素
bool set(struct Node* head, int pos, DataType d) {
if (pos < 0 || pos >= getSize(head)) {
return false;
}
struct Node p = getptr(head, pos);
p->data = d;
return true;
}
//清理 链表
void clears(struct Node head) {
while (head) {
struct Node p = head->next;
free(head);
head = p;
}
}
//打印
void print(struct Node head) {
struct Node *p = head;
while § {
printf("%d “, p->data);
p = p->next;
}
printf(”\n");
}
int main()
{

//头指针
struct Node *headList;
init(&headList);

insert(&headList, 0, 10);
insert(&headList, 0, 20);
insert(&headList, 0, 30);
insert(&headList, 2, 40);
insert(&headList, 2, 50);
insert(&headList, 0, 60);
insert(&headList, 0, 80);
print(headList);
erases(&headList, 0);
print(headList);
set(headList, 0, 100);
set(headList, 0, 110);
print(headList);

return 0;

}

蒙宇
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
typedef的用法
Dream_xun的专栏
12-13 966
基本概念 typedef与结构体 typedef与数组 ------------------------------------- typedef是c语言中的关键字，作用是将一个数据类型定义为一个新的数据类型 包括内部类型（int，char，float等），和用户自定义类型（如struct等类型）。 ------------------------------------ 编程中使用
【洋哥带你玩转线性表（一）——顺序表】
weixin_59658448的博客
07-01 646
线性表：线性表是n个具有相同特性的数据元素的有限序列。它是一种在实际中广泛使用的数据结构，在数据结构中常见的线性表有：顺序表、链表、栈、队列、字符串等等。线性表在逻辑上是线性结构的，也就是连续的一条直线，但他的物理结构上并不一定是连续的，它在物理上存储时，通常以数组和链式结构的形式存储。1.顺序表的定义以及代码实现。2.单链表的定义以及代码实现。3.双向链表的定义以及代码实现1概念及其结构 顺序表是用一段物理地址连续的存储单元依次存储数据结构元素的线性结构，一般情况下采用数组存储。在数组上完成
typedef和#define
qq_56999918的博客
08-26 1727
typedef是c语言中一个重要的关键字其作用是为一种数据类型定义了一个新的名字这里的类型包括（int，char,double 等)和自定义数据类型，通俗一点来说就是为一种数据类型起一个别名 举个例子： 定义一个整型变量a并将其初始化为666，在将a的值输出 #include<stdio.h> int main() { int a = 666; printf("%d", a); return 0; } 如果我想要用datatype代表int 了？也就是我想给int起一个别名这时候
顺序表的基本操作
yang_0102的博客
05-08 460
1.顺序表的基本操作： c语言中箭头(->)与间接取址符（.）有什么区别？ 箭头（->）：左边必须为指针； 点号（.）：左边必须为实体。 #include<stdio.h> #define MAXSIZE 10 /*Datatype是数据元素类型，可以自定义，可以使用 SeqList定义数据表类型，使用*PSeqlist定义数据表指针变量 */ typedef int Da...
数据结构线性表操作系统
广西彭于晏的博客
09-25 258
线性表系统
数据结构与算法ch2-综合文档
05-25
数据结构与算法ch2
java数据结构与算法.pdf
01-04
包含了各种数据结构和算法（java）的实现方式和详解（图解），包括单双链表、环形链表（约瑟夫问题）、栈、后缀表达式、中缀表达式转后缀表达式、迷宫问题、八大排序算法、多种查找算法、哈希表、二叉树实现以及操作...
数据结构与算法分析电子书合集
最新发布
01-11
自己搜索的数据结构与算法的一些电子书的合集，总计23本，包括算法导论，编程之美，设计模式等.......
数据结构与算法分析--C语言描述_数据结构与算法_
10-01
数据结构与算法是计算机科学的基础，对于理解和设计高效的软件至关重要。C语言因其高效、底层特性，常被用于实现数据结构和算法，使得程序更接近硬件，性能更优。本资源"数据结构与算法分析--C语言描述"是针对数据...
韩顺平老师尚硅谷Java数据结构与算法194集笔记
10-12
这是我从B站上看韩老师讲的数据结构与算法后整理的笔记 代码经过运行，欢迎批评指正 有些地方我感觉还是挺难的 大都经过我自己的语言进行描述，韩老师中期的表达可能或多或少也影响可阅读性，望先生们见谅
链表的第i个结点后插入结点
04-26
个人编写的在链表的第i个结点后插入结点的C语言源码
数据结构— —优先队列
m0_65635427的博客
11-07 863
数据结构优先队列
校招面试系列------关于typedef的部分问题处理
Oxygennnnnn_的博客
10-30 439
typedef的部分面试问题处理 关于typedef的用法总结利弊 typedef和define的常见区别
来说说datatype
weixin_30716141的博客
05-11 1439
今天敲代码一直卡在一个问题上面好久那就是--datatype的未定义，起初不晓得datatype的含义，遇到这种情况首先想到的就是自己又忘记加上面头文件了。随即写了个stdlib.h上去。可是问题并没有得到解决，还是显示未定义。 怀疑是不是自己拼写的错误导致的，检查一下还是没有。仔细一看才想起来忘了写这样一句话typedef int DataType;在头文件中。写上后便是无问题。现在我就来查...
typedef的真正含意
hjyhh的专栏
02-15 1492
 typedef的真正含意1. 找到你所要申明的通用格式。例如这里申明int a[4], b[4], c[4];只有a,b,c不同，它们有相同的申明模式 int 名字>[4];2. 用你想申明的新类型名代替通用格式中的变化部分。例如这里就是用新类型int_array代替a,b,c所在的位置，再在前面加上typedef符号，即：typedef int int_array[4];3. 以后你想
学习笔记2 —— typedef设置别名
北豼不太皮的博客
01-11 1919
设置类型别名typedef 一、设置类型别名的格式 1.给普通类型设置别名 2.给结构体类型设置别名 3.给数组类型设置别名 4.给指针类型设置别名 5.给数组指针类型设置别名 6.给函数指针类型设置别名 二、设置类型别名的好处 1.简化长类型名 2.便于代码维护(平台无关性) —— 重要 3.扩展类型信息 三、typedef与#define的区别
typedef定义数组用法
janeqi1987的专栏
07-18 2608
每次都记不住，用到的时候上网搜索下，在这里记录下，后续继续补充相关的知识点 /* N1到N4是几个常量，以枚举的形式定义*/ enum{N1 = 2, N2 = 3, N3 = 4, N4 = 5}; /*这个C程序员都知道，就是将DataType定义为int型，便于扩充*/ typedef intDataType; /*定义一个一维数组，数组的元素维整型值...
头插法、尾插法建立单链表（含详细注释C++）
热门推荐
怪&的个人博客
07-26 2万+
一、信息须知： 1：malloc()函数，头文件为cstdlib。 用法：node *p=(node )malloc(sizeof(node))。作用：分配一个node类型大小的内存空间, 并把其赋值给node 型的指针p。" node *p=new node; "也可实现此作用。 2： typedef char datatype; 为char起别名datatype，方便链表data数据类型修改。 二、思路分析： 1、头插法思路图示分析 2、尾插法思路图示分析 三、代码展示： //以" &am
1_数据结构基本算法整理 (自动保存的).docx
12-29
数据结构与算法整理提供了一个集中的学习平台，通过整理和分类的方式，为学习者提供了一种高效的学习路径，帮助他们更好地掌握数据结构与算法的知识。 在数据结构基本算法整理中，经典的排序算法有冒泡排序、选择...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值