《数据结构与算法分析》学习笔记（三）——链表ADT

最新推荐文章于 2022-03-25 23:02:34 发布
最新推荐文章于 2022-03-25 23:02:34 发布
阅读量325 收藏 3
点赞数
文章标签： 数据结构与算法

今天简单学习了下链表，待后续，会附上一些简单经典的题目的解析作为学习的巩固

首先要了解链表，链表其实就是由一个个结点构成的，然后每一个结点含有一个数据域和一个指针域，数据域用来存放数据，而指针域则用来存放下一个结点的地址。

一、链表的基本知识

1、先给出结点的定义。

typedef struct Node *PtrToNode;
typedef PtrToNode List;
typedef PtrToNode Position;struct Node
{
ElementType Element;
Position next;
};

 

2、下面就是一些常见的链表的操作

List init(List L);
int IsEmpty(List L);
int IsLast(Position P,List L);
Position Find(ElementType X,List L);
void Delete(ElementType X,List L);
Position FindPrevious(ElementType X,List L);
void Insert(ElementType X,List L,Position P);
void DeleteList(List L);
Position Header(List L);
Position First(List L);
void Print(List L);

 

 

3、具体每个的分析啦

 

List init(List L)
{
L=new struct Node;
L->next =nullptr;return L;
}

 

这个是初始化链表，链表默认有一个空的头指针，不用来存放数据，只是用来处理一些特殊的情况，个人认为一个结点的代接换取代码的简洁是很好的选择，

 

 

int IsEmpty(List L)
{
return L->next==nullptr;
}

这个是判断链表是否为空。

 

 

 

 

Position Find(ElementType X,List L)

{

Position p;

p=L->next;

while (p!=nullptr&&p->Element!=X )

{

p=p->next;

}

  

return p;

}

由于链表跟指针不同，没有下标可以直接访问，所以我们需要一个个的遍历。

 

 

int IsLast(Position P,List L)
{
Position p;
p=L->next;
if (p->next!=nullptr)
{
p=p->next;
}

return p==P;
}

 

判断是否是最后一个。

 

 

 

 

void Delete(ElementType X,List L)
{
Position p,tempCell;
p=FindPrevious(X,L);
if(!IsLast(p,L))
{
tempCell=p->next;
p->next=tempCell->next;
delete tempCell;
}
}

删除的话重点是别忘记释放内存

 

 

 

 

 

Position FindPrevious(ElementType X,List L)
{
Position p;
p=L;
while (p->next!=nullptr&&p->next->Element!=X)
{
p=p->next;
}return p;
}

与查找相关

 

 

//Insert(after legal Position P)
void Insert(ElementType X,List L,Position P)
{
Position tempCell;
tempCell = new struct Node;


if (tempCell==nullptr)
{
cout<<("Out of space!!")<<endl;
}

tempCell->Element=X;
tempCell->next = P->next;
P->next=tempCell;
}

默认插入在结点的后面

 

 

 

 

void DeleteList(List L)
{
Position p;
p=L->next;
L->next=nullptr;
while (p!=nullptr)
{


Position pTemp=p->next;
delete p;
p=pTemp;
}

}

清空链表

 

 

 

 

 

void Print(List L)
{
Position p;
p=L->next;
while(p!=nullptr)
{
cout << p->Element.coe << p->Element.index <<" “;
p=p->next

}
cout<<endl;
}

 

打印链表

 

 

 

 

二、多项式的加法（减法是类似的）

1、首先应该确定Elementtype是什么，在此我定义了一个结构体，其中包括系数coe和指数index。

 

typedef struct
{
float coe;
float index;}ElementType;

2、然后便是多项式加法的算法，首先默认多项式的系数是从小到大递增的。然后进行加法的时候，就用两个指针同时对两个链表进行遍历，碰到相同系数的就相加，不同的就直接加入到新链表中，然后记得相加为0的时候要进行删除。

 

代码如下：

 

typedef struct Node *PtrToNode;
typedef PtrToNode List;
typedef PtrToNode Position;
typedef struct
{
float coe;
float index;
}ElementType;
struct Node
{
ElementType Element;
Position next;

};

 

//实现相应的函数的功能
List init(List L);
void Print(List L);
void initPolynomial(List L);
void hebing(List L);
void polyAdd(List L1,List L2,List L3);
void polySub(List L1,List L2,List L3);

void select(List L);



List init(List L)
{
L->next =nullptr;


return L;
}
void Print(List L)
{
Position p;
p=L->next;


while(p!=nullptr)
{
cout << p->Element.coe <<"X^"<< p->Element.index;
if(p->next!=nullptr&&p->Element.coe>0)
{
cout<<"+";
}
p=p->next;
}
cout<<endl;
}
void initPolynomial(List L)
{
DeleteList(L);


Position p,pre;
pre=L;
int coe,index;



while (1)
{
cout<<"Please scanf coe and index(以0 0退出）:";
cin>>coe>>index;


if(coe==0 && index==0)
{
break;
}
else
{
p=new struct Node;
p->Element.coe=coe;
p->Element.index=index;
p->next=nullptr;
pre->next=p;
pre=p;
}
}
hebing(L);


}


void hebing(List L)
{
Position pi,pj,pk2,pk1;
pi=L->next;
if(pi==nullptr||pi->next==nullptr)
{
return ;
}
for(pk1=L,pi=L->next;pi!=nullptr&&pi->next!=nullptr;pi=pi->next)
{
for(pj=pi->next,pk2=pi;pj!=nullptr;pj=pj->next)
{
if(pi->Element.index==pj->Element.index)
{
pi->Element.coe+=pj->Element.coe;
pk2->next=pj->next;
Position pTemp=pj;
delete pTemp;
pj=pk2;
}
pk2=pj;
}
if(pi->Element.coe==0)
{
pk1->next=pi->next;
Position pTemp=pi;
free(pTemp);
pi=pk1;
}
pk1=pi;
}
select(L);
}


void select(List L)
{
Position pi,pj;
pi=L->next;
if(pi==nullptr||pi->next==nullptr)
{
return ;
}


for(pi=L->next;pi->next!=nullptr;pi=pi->next)
{
Position ptemp=pi;
for(pj=pi->next;pj!=nullptr;pj=pj->next)
{
if(pj->Element.index<pi->Element.index)
{
ptemp=pj;
}
}


ElementType temp=ptemp->Element;
ptemp->Element=pi->Element;
pi->Element=temp;
}


}



void polySub(List L1,List L2,List L3)
{
Position p1=L1->next;
Position p2=L2->next;


Position p3=L3;


while (p1!=nullptr&&p2!=nullptr)
{
if(p1!=nullptr&&p2!=nullptr&&p1->Element.index==p2->Element.index)
{
Position p=new struct Node;
p->Element.index=p2->Element.index;
p->Element.coe=-p2->Element.coe+p1->Element.coe;
p->next=p3->next;
p3->next=p;
p3=p;


p1=p1->next;
p2=p2->next;


}



while(p1!=nullptr&&p2!=nullptr&&p1->Element.index>p2->Element.index)
{
Position p = new struct Node;
p->Element.index=p2->Element.index;
p->Element.coe=p2->Element.coe;
p->next=p3->next;
p3->next=p;
p3=p;


p2=p2->next;
}



while (p1!=nullptr&&p2!=nullptr&&p1->Element.index<p2->Element.index)
{
Position p = new struct Node;
p->Element.index=p1->Element.index;
p->Element.coe=p1->Element.coe;
p->next=p3->next;
p3->next=p;
p3=p;


p1=p1->next;
}


}
if(p1!=nullptr)
{
while(p1!=nullptr)
{
Position p = new struct Node;
p->Element.index=p1->Element.index;
p->Element.coe=p1->Element.coe;
p->next=p3->next;
p3->next=p;
p3=p;
p1=p1->next;
}
}
if(p2!=nullptr)
{
while(p2!=nullptr)
{
Position p = new struct Node;
p->Element.index=p2->Element.index;
p->Element.coe=-p2->Element.coe;
p->next=p3->next;
p3->next=p;
p3=p;


p2=p2->next;
}
}
hebing(L3);
}


void polyAdd(List L1,List L2,List L3)
{
Position p1=L1->next;
Position p2=L2->next;


Position p3=L3;


while (p1!=nullptr&&p2!=nullptr)
{
if(p1!=nullptr&&p2!=nullptr&&p1->Element.index==p2->Element.index)
{
Position p=new struct Node;
p->Element.index=p2->Element.index;
p->Element.coe=p2->Element.coe+p1->Element.coe;
p->next=p3->next;
p3->next=p;
p3=p;


p1=p1->next;
p2=p2->next;


}



while(p1!=nullptr&&p2!=nullptr&&p1->Element.index>p2->Element.index)
{
Position p = new struct Node;
p->Element.index=p2->Element.index;
p->Element.coe=p2->Element.coe;
p->next=p3->next;
p3->next=p;
p3=p;


p2=p2->next;
}



while (p1!=nullptr&&p2!=nullptr&&p1->Element.index<p2->Element.index)
{
Position p = new struct Node;
p->Element.index=p1->Element.index;
p->Element.coe=p1->Element.coe;
p->next=p3->next;
p3->next=p;
p3=p;


p1=p1->next;
}



}
if(p1!=nullptr)
{
while(p1!=nullptr)
{
Position p = new struct Node;
p->Element.index=p1->Element.index;
p->Element.coe=p1->Element.coe;
p->next=p3->next;
p3->next=p;
p3=p;
p1=p1->next;
}
}
if(p2!=nullptr)
{
while(p2!=nullptr)
{
Position p = new struct Node;
p->Element.index=p2->Element.index;
p->Element.coe=p2->Element.coe;
p->next=p3->next;
p3->next=p;
p3=p;


p2=p2->next;
}
}

}

3、桶式排序与基数排序

（1）桶式排序：假如有N哥整数，范围从1到M，我们可以创建一个数组Count，大小为M并初始化为0，于是，Count有M个桶，开始他们是空的，当i被读入的时候Count[i]增加1，在所有的输入都被读完以后，扫一遍数组Count，然后便可以打印出来排好序的表。

 

 

 

    int A[1001];
memset((void *)A, 0, 1001*sizeof(int));      //初始化0；
int temp;
cout<<"Please scanf the numbers(数字在【1，1000】，以0退出）;"<<endl;
while(1)
{


cin>>temp;


if(temp<0||temp>1000)
{
cout<<"temp输入有误，该数已排除"<<endl;            //排除超限的数
cin>>temp;
}


if(temp==0)
{
break;                             //循环出口
}



A[temp]++;
}
for(int i=1;i<1001;i++)
{
if (A[i]!=0)
{
cout<<i<<"  ";             //打印处结果
}
}
cout<<endl;

return 0;

(2)基数排序

基数排序是对桶式排序的一种推广，由于桶式排序对空间的需求太高，所以我们考虑可以多次桶排序，降低M的值，就可以达到降低空间的需求，例如正整数的排序，我们可以把每一位都拆分出来，这样M的范围只有从0到9，也就是说我们一下子省去N多不必要的空间，碰到，有相同数的我们考虑接到这个i值下的链表即可。然后我COPY书上的图，让我们更好的理解

IMAG0174.jpg

 

最后贴出代码。

 

typedef struct Node
{
    int element;
    Node *next;
}Node;

typedef Node* pNode;


int main(int argc, const char * argv[])
{
    Node A[10];
    for(int i=0;i<10;i++)
    {
        A[i].next=nullptr;
    }
    int temp,Max=0;
    cout<<"请输入要进行排序的数(范围≥0,以-1退出)"<<endl;
    
    while(1)
    {
        cin>>temp;
        if(temp<-1)
        {
            cout<<temp<<"Scanf Error!"<<endl;
            cin>>temp;
        }
        if(temp==-1)
        {
            break;
        }
        
        if(temp>Max)
        {
            Max=temp;
        }
        
        int i=temp%10;
        auto node = new Node;
        node->element=temp;
        node->next=nullptr;
        
        pNode p= A+i;
        
        while (p->next!=nullptr)
        {
            p=p->next;
        }
        p->next=node;
    }
    
    int N=0;
    while (Max)
    {
        N++;
        Max/=10;
    }
    int n=1;
    int XX=1;
    while (n!=N+1)
    {
        XX*=10;
        for (int i=0; i<10; i++)
        {
            pNode p = (A+i)->next;
            pNode q = (A+i);
            while (p!=nullptr)
            {
                int temp=p->element/(XX)%10;
                if(temp==i)
                {
                    q=p;
                    p=p->next;
                    continue;
                }
                else
                {
                    q->next=p->next;
                    pNode ptemp=A+temp;
                    while(ptemp->next!=nullptr)
                    {
                        ptemp=ptemp->next;
                    }
                    p->next=nullptr;
                    ptemp->next=p;
                    p=q->next;
                    
                }
                
            }
            
        }
        n++;
    }
    
    
    
    
    
    
    for(int i=0;i<10;i++)
    {
        pNode p=A+i;
        p=p->next;
        while (p!=nullptr)
        {
            cout<<p->element<<"  ";
            p=p->next;
        }
        cout<<endl;
    }
    
    
    
    
    
    
    
    
    return 0;
}

 

 

 

 

 

 

C语言链表ADT
BL_huongzhong的博客
03-13 660
一个C语言的链表ADT 在我的Github：https://github.com/ZhangShaoyi2021/C-repository 这是一个以LISTDATA结构体为数据域的链表，如需使用，请在list.h中修改对它的定义。 代码 list.h文件 //list.h:链表ADT头文件 #ifndef __LIST_H #define __LIST_H //使用时自行修改LISTDATA结构 typedef struct dataField{ char c; }LISTDATA; typed
《数据结构与算法分析c++描述》读书笔记一——表
u011085626的博客
06-30 1722
学习数据结构与算法的参考书是《数据结构与算法分析c++描述》一书。         首先看的是最基本的ADT(抽象数据结构)表、栈、队列。         1、表：是一种有限且有序的序列。实现的方式有两种：数组（所有操作都可以用数组来实现，查找功能、在表尾插入数据删除数据很方便）；链表（每个数据不必存在连续存储，插入、删除数据很方便）。        2、栈： 限制数据插入和删除只能在一个位
4 单链表ADT模板简单应用算法设计：单链表中前 m 个元素和后 n 个元素的互换
m0_51727949的博客
03-11 1244
问题描述： 目的：使用C++模板设计单链表的抽象数据类型（ADT）。并在此基础上，使用单链表ADT的基本操作，设计并实现单链表的简单算法设计。 内容：（1）请使用模板设计单链表的抽象数据类型。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。参考网盘中的ADT原型文件。） （2）ADT的简单应用：使用该ADT设计并实现单链表应用场合的一些简单算法设计。 应用1：假设有一个带头结点的单链表A，现要求设计一个算法，实现单链表
数据结构(Data Structure)——链表ADT(C/C++语言)
HarvestWu的博客
04-25 439
#include&lt;stdlib.h&gt; #include&lt;stdio.h&gt; #define OK 1 #define ERROR 0 #define OVERFLOW -1 #define TRUE 1 #define FALSE 0 typedef int ElemType;//指定链表中数据类型 typedef int Status; typedef struct ...
数据结构与算法分析 - 1 - 链表ADT
weixin_30885111的博客
12-29 139
1.描述：不连续存储的表，可以把链表看成一个数组，数组元素是一个个结构体，这些结构体之间通过指针连接 2.优点： 　　利用不连续的存储空间，提高内存使用效率 　　避免删除和插入的线性开销　 　　对比数组，大小不固定，可以扩展　　　 3. 缺点：查找效率低 4. 定义一个单向链表 1 struct Node 2 { 3 ElementType ...
《数据结构与算法分析》学习笔记（四）——栈ADT
weixin_33704234的博客
01-08 234
一、栈ADT是what？ 1、定义         栈，是限制插入和删除都只能在一个位置上进行的表。 2、图示                                         3、栈的基本功能 （1）是否为空 （2）进栈 （3）出栈 （4）清空 （5）取栈顶 二、栈的链表实现   #ifndef Exercise_Stack_h #define Ex...
《数据结构和算法 python语言描述》学习笔记（三）————线性表
qq_42056492的博客
10-19 1330
第一部分：内容概述 线性表的概念和表的抽象数据类型 顺序表的实现 链接表 链表的变形和操作 表的应用 第二部分：学习笔记 线性表的概念和表的抽象数据类型    1. 在一个非空的线性表里，存在着唯一的一个首元素和唯一的一个尾元素（末元素）。除首元素之外，表的每个元素e都有且仅有一个前驱元素；除了尾元素之外的每个元素都有且仅有一个后继元素。    2. 线性表的操作     ① 首先，作为抽象...
408学习笔记——表解数据结构
wzixuan1的博客
08-05 700
涵盖了《王道论坛-2022年数据结构考研复习指导》里的几乎全部内容！ 目录 1 绪论 2 线性表 2.1 线性表基本概念 2.2 线性表分类 3栈和队列 3.1 栈和队列 3.2 特殊矩阵的压缩存储 4 串 5 树 5.1 树的基本概念 5.2 二叉树 5.3 树、森林的遍历 并查集 6 图 6.1 图的基本概念 图的分类 6.2 图的存储 6.3 图的遍历 6.4 图的应用 7 查找 7.1 查找的基本概念 7.2 查找算法 处理散列函数冲突的方法 .
数据结构详解：逻辑与存储结构、算法复杂度分析
"Linux C 数据结构相关资料，详细讲解数据结构" 数据结构是计算机科学中的核心概念，它...这份Linux C数据结构笔记提供了全面的数据结构和算法基础知识，对于理解和掌握数据结构的原理及其在C语言中的实现非常有帮助。
1.绪论——青岛大学王卓老师数据结构课程课堂笔记
fjhkrje的博客
03-23 2896
• 数据结构：数组、链表、栈、队列、散列表、二叉树、堆、跳表、图、Tire树 • 算法： 递归、排序、二分查找、搜索、哈希算法、贪心算法、分治算法、回溯算法、动态规划、字符串匹配算法。 1.1数据结构研究 无法用数学公式或者方程来描述，是一些”非数值计算”的程序设计问题，描述非数值计算问题的数学模型不是数学方程，而是诸如表、树和图之类的具有逻辑关系的数据。 数据结构是一门研究非数值计算的程序设计中计算机的操作对象以及它们之间的关系和操作的学科 1.2基本概念和术语 1.2.1 数据、数据元素、数据项和数据.
数据结构学习——单链表ADT（程序化）
fzzjoy的专栏
03-22 1065
看了一点网上的代码，结合自己对链表的理解。将对链表常用的操作集合程序化如下： #include #include typedef struct Node { int Val; struct Node *next; }List; List *list_add(List **p,int Val);//此处是二级指针 void List_Print(List *p); List *
数据结构与算法分析-用C语言实现栈（链表方式）
有余力，则学文。
05-20 1098
这种方法用链表来表示栈，头结点始终指向栈顶的元素，每次入栈就是在头结点后面插入一个元素，而出栈则是删除头结点后面的那个元素，思想很简单，有了链表的基础，实现起来也是很容易的。那么老规矩，先将栈ADT的声明部分放在Stack.h这个头文件里。代码如下：
C语言实现单链表之ADT定义
weixin_34150503的博客
11-01 582
/** link_list.h** Created on: Nov 1, 2010* Author: jenson*/#ifndef LINK_LIST_H_#define LINK_LIST_H_typedef int elem_type;typedef struct _sq_list_node_ * sq_list;struct _sq_list_n...
4.单链表ADT模板简单应用算法设计：单链表中前 m 个元素和后 n 个元素的互换
m0_57787206的博客
03-25 1263
单链表ADT模板简单应用算法设计：单链表中前 m 个元素和后 n 个元素的互换
DHU数据结构-单链表-ADT应用-单链表中前m个元素和后n个元素的互换
m0_49843646的博客
03-09 1629
1.题目 个元素的互换 作者: 冯向阳时间限制: 1S章节: DS:线性表 问题描述 : 目的：使用C++模板设计单链表的抽象数据类型（ADT）。并在此基础上，使用单链表ADT的基本操作，设计并实现单链表的简单算法设计。 内容：（1）请使用模板设计单链表的抽象数据类型。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。参考网盘中的ADT原型文件。） （2）ADT的简单应用：使用该ADT设计并实现单...
c语言广义链表ADT,C语言实现双向链表之ADT定义
weixin_36047538的博客
05-21 130
/** list.h** Created on: Nov 1, 2010* Author: jenson*/#ifndef LIST_H_#define LIST_H_typedef int elem_type;typedef struct _node_ * node;typedef struct _dr_list_ *dr_list;struct _dr_list_{dr_list ...
数据结构与算法分析c语言描述（Mark Allen）--队列ADT链表实现
OCEANtroye的博客
10-30 467
队列ADT链表实现 使用链表存储 操作集合 入队 出队 初始化 返回队前元素 打印 #include &amp;lt;stdio.h&amp;gt; #include &amp;lt;stdlib.h&amp;gt; typedef int ElementType; struct Node { ElementType Data; struct Node *Next; }; /...
链表ADT详解
yanghangjun的专栏
12-29 5504
链表原理很简单。这里实现了单链表的ADT。主要的操作有： 节点结构提的定义： struct Node {  int element;  struct Node *next; }; 以及链表的常见操作  /*生成一个空表，该链表只有头节点*/ List creatList(void) /*判断一个链表是否为空，形参为头节点指针;   为空返回1，否则返回0；   */ in
单链表ADT模板简单应用算法设计：单链表的逆置(WA 4610）（方法不是很好，索性就直接放源码吧）
Blackoutdragon的博客
10-18 894
文章目录问题描述输入说明输出说明输入范例输出范例思路分析尝试一尝试二尝试三伪码错误现场分析与总结 问题描述 目的：使用C++模板设计单链表的抽象数据类型（ADT）。并在此基础上，使用单链表ADT的基本操作，设计并实现单链表的简单算法设计。 内容：（1）请使用模板设计单链表的抽象数据类型。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。参考网盘中的ADT原型文件。） （2）ADT的简单应用：使用该ADT设计并实现单链表应用
C++学习：数据结构与算法分析笔记
"C++数据结构与算法的学习笔记，涵盖了数据结构、算法分析以及相关编程概念，旨在帮助学习者掌握核心编程技巧并提升问题解决能力。" 在这份"C++数据结构与算法学习笔记"中，重点讲解了以下几个关键知识点： 1. **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值