数据结构笔记1---链表与顺序表

最新推荐文章于 2024-04-23 14:18:24 发布
最新推荐文章于 2024-04-23 14:18:24 发布
阅读量373 收藏
点赞数
分类专栏： android 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37527943/article/details/78615197
版权

导读

1.单链表（创建，插入，删除，查找（2），判空）
2.数组线性表（创建，插入，删除，查找，判空，判满）
3.循环链表（创建，插入，删除，判空）
4.运用数组线性表的串的替换暴力算法

单链表

#include <iostream>
using namespace std;

typedef struct LNode *List;
struct LNode{
    int data;//以int为例
    List next;
};

//创建空链表
List create(){
    List head=new LNode;
    head->next=NULL;
    return head;
}

//判空
bool Isempty(List head){
    if(head->next==NULL)
        return true;
    else return false;
}

//返回链表长度
int Length(List head){
    int result=0;
    List p=head->next;
    while(p!=NULL){
        result++;
        p=p->next;
    }
    return result;
}

//查找第k个元素并返回其指针
List Findkth(List head,int k){
    if(Isempty(head)){
        cout<<"It's empty!"<<endl;
        return NULL;
    }
    List p=head;
    int i=0;
    while(p!=NULL&&i<k){
        p=p->next;
        i++;
    }
    if(p==NULL)
    {
        cout<<"There is not such a data!"<<endl;
        return NULL;
    }
    else  return p;
}

//查找数值为i的元素并返回其指针
List Findelem(List head,int i){
    if(Isempty(head)){
        cout<<"It's empty!"<<endl;
        return NULL;
    }
    List p=head->next;
    while(p!=NULL&&p->data!=i)
        p=p->next;
    if(p==NULL)
    //注意这里if与else的位置很重要，如果不先判定p为空很有可能报错
    {
        cout<<"There is not such a data!"<<endl;
        return NULL;
    }
    else  return p;


}

//插入元素，元素按照非递减排序
void Insert(List &head,int data){
    List p=head;
    List s=new LNode;
    s->data=data;
    while(p->next!=NULL&&p->next->data<data)
        p=p->next;
    s->next=p->next;
    p->next=s;
}

//删除一个元素，这里用return 的效率不如用引用的效率高
void Deletedata(List &head,int data){
    List p=head;
    List s;
    if(Isempty(head))
        cout<<"It's empty!"<<endl;
    while(p->next!=NULL&&p->next->data!=data)
        p=p->next;
    if(p->next->data==data){
        s=p->next;
        p->next=p->next->next;
        delete(s);
    }

    else
        cout<<"There is not such a data!"<<endl;
}

int main(){
    List chain;
    List p;
    chain=create();
    for(int i=1;i<=10;i++)
    {
        Insert(chain,i);
    }
    cout<<"链表长度："<<endl;
    cout<<Length(chain)<<endl;
    cout<<"查找第5个元素："<<endl;
    p=Findkth(chain,5);
    cout<<p->data<<endl;
    cout<<"查找元素7:"<<endl;
    p=Findelem(chain,7);
    cout<<p->data<<endl;
    cout<<"删除元素8"<<endl;
    Deletedata(chain,8);
    cout<<"查找元素8"<<endl;
    p=Findelem(chain,8);
    return 0;

}

输出结果
链表长度：
10
查找第5个元素：
5
查找元素7:
7
删除元素8
查找元素8
There is not such a data!
Program ended with exit code: 0

数组线性表

#include <iostream>
using namespace std;
#define MAXSIZE 100

typedef struct Node *snode;
struct Node{
    char data[MAXSIZE+1];
    int length;
};

//数组初始化
snode init(){
    snode head=new Node;
    head->length=0;
    return head;
}

//判空
bool Isempty(snode head){
    bool flag=false;
    if(head->length==0)
        flag=true;
    return flag;
}

//判满
bool Isfull(snode head){
    bool flag=false;
    if(head->length==MAXSIZE)
        flag=true;
    return flag;
}

//插入数据
void insert(snode &head,char data){
    int i;
    for(i=1;i<=head->length&&head->data[i]<data;)
    {i++;}
    if(i>head->length)
        head->data[i]=data;
    else{
        i--;
        for(int j=head->length;j>=i;j--){
            head->data[j+1]=head->data[j];
        }
        head->data[i]=data;
    }
    head->length++;
}

//删除数据
void del(snode &head,char data){
    for(int i=1;i<=head->length;i++){
        if(head->data[i]==data){
            for(int j=i;j<=head->length;j++)
                head->data[j]=head->data[j+1];
            head->length--;
        }
    }
}


//查找数据
void find(snode &head,char data){
    bool flag=false;
    for(int i=1;i<=head->length;i++){
        if(head->data[i]==data){
            cout<<"yes,it's here.The position is "<<i<<endl;
            flag=true;
        }
    }

    if(flag==false)
        cout<<"There is not such a data"<<endl;

}

int main(){
    snode list;
    list=init();
    for(char i='a';i<='m';i++){
        insert(list,i);
    }
    find(list,'k');
    del(list,'k');
    find(list,'k');
    return 0;
}

输出结果
yes,it’s here.The position is 11
There is not such a data
Program ended with exit code: 0

循环链表

以约瑟夫环为例：
输入：人数n，（编号为1～n），约瑟夫环数m(每m人淘汰一次)
输出：按照出圈顺序打印编号

#include <iostream>
using namespace std;

typedef struct Node *List;
struct Node{
    int num;
    List next;
};


//创建循环链表
List init(int num){
    List flag=new Node;
    flag->num=num;
    flag->next=flag;
    return flag;
}


//判空
bool Isempty(List flag){
    if(flag)
        return false;
    else return true;
}


//插入元素
void insert(int num,List &flag){
    List s=new Node;
    s->num=num;
    s->next=flag->next;
    flag->next=s;
    flag=s;
}

//删除第k个元素
void del(List &flag,int k){
    if(Isempty(flag))
        cout<<"it's  empty!"<<endl;
    List p=flag;
    //循环链表删除要分k=1和k>1两种情况
    if(k==1){
        List p1=flag;
        while(p->next!=flag)
            p=p->next;
        p->next=flag->next;
        flag=flag->next;
        cout<<p1->num<<endl;
         delete(p1);
    }
    else{
        List p2;
        for(int i=1;i<=k-2;i++)
            p=p->next;
        p2=p->next;
        p->next=p->next->next;
        flag=p->next;
        cout<<p2->num<<endl;
         delete(p2);
    }
}
//如果每次删除的k都不同，则需要将k定义为引用类型



int main(){
    List flag;
    int n,m;
    cout<<"输入人数n和淘汰数m:"<<endl;
    cin>>n>>m;
    flag=init(1);
    for(int i=2;i<=n;i++){
        insert(i,flag);
    }
    flag=flag->next;//此步用于回到第1个人的位置
    for(int i=1;i<=n;i++)
        del(flag,m);


    return 0;
}

输出结果
输入人数n和淘汰数m:
3 3
3
1
2
Program ended with exit code: 0

运用数组线性表的串的替换暴力算法

#include <iostream>
using namespace std;
#define MAXSIZE 100


struct chuan{
    char data[MAXSIZE+1];
    int length;
};


bool compare(char a,char b){
    if(a==b) return true;
    else return false;
}

//暴力匹配算法
int match(chuan S,chuan T,int start){
    int flag,i,j;
    for(flag=start;flag<=S.length-T.length+1;flag++)
    {
        for(j=1,i=flag;j<=T.length;i++,j++){
            if(compare(S.data[i],T.data[j])==false)
                break;
        }
        if(j>T.length)
            break;
    }
    if(flag>S.length-T.length+1)
        return 0;//匹配失败返回0
    return flag;//匹配成功返回位置
}


//替换算法
void replace(chuan &S,chuan T,chuan V,int flag){
    //1.替换串与被替换串长度一样
    if(T.length==V.length){
        for(int i=flag,j=1;i<=T.length;i++,j++)
            S.data[i]=V.data[j];
    }
    //2.替换串长度小于被替换串
    else if(T.length>V.length){
        int k=T.length-V.length;
        //要缩短的长度
        for( int i=flag+V.length;i<=S.length-T.length+V.length;i++){
            S.data[i]=S.data[i+k];
        }
        for(int i=flag,j=1;j<=V.length;i++,j++)
            S.data[i]=V.data[j];
        S.length-=k;

    }
    //3.替换串长度大于被替换串
    else{
        int k=V.length-T.length;
        //要增加的长度
        for(int i=S.length;i>=flag+T.length;i--){
            S.data[i+k]=S.data[i];
        }
        for(int i=flag,j=1;j<=V.length;i++,j++){
            S.data[i]=V.data[j];
        }
        S.length+=k;
    }
}

//打印函数
void output(chuan S){
    for(int i=1;i<=S.length;i++)
        cout<<S.data[i];
    cout<<endl;
}


int main(){
    chuan S,T,V;
    char a;
    int len=0;
    cout<<"请输入主串："<<endl;
    while((a=getchar())!='\n')
    {
        len++;
        S.data[len]=a;
    }
    S.length=len;
    len=0;
    cout<<"请输入被替换串："<<endl;
    while((a=getchar())!='\n')
    {
        len++;
        T.data[len]=a;
    }
    T.length=len;
    len=0;
    cout<<"请输入替换串："<<endl;
    while((a=getchar())!='\n')
    {
        len++;
        V.data[len]=a;
    }
    V.length=len;
    output(S);
    int i=1;
    //一个主串里可能有多个被替换串
    while(i<=S.length-T.length+1){
        i=match(S,T,i);
        if(i!=0)
        {
            replace(S,T,V,i);
            i+=V.length;
        }
        else break;
    }
    output(S);
    return 0;
}

输出结果
请输入主串：
retioioret
请输入被替换串：
ret
请输入替换串：
df
retioioret
dfioiodf
Program ended with exit code: 0

hala-22
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法-学习笔记 Java 版.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
数据结构-------链表（递归）操作
weixin_51578598的博客
09-23 2565
数据结构中的链表估计很多人会觉得简单，我也是怕记不住所以就尝试整理一下笔记吧 1.创建链表（初始化） struct ListNode { //链表结点类 int data; //数据域，当然int类型可以改为自定义类型T等等 ListNode * next; //主要讨论单链表 }; typedef ListNod
数据结构笔记-----链表
碧海蓝天观潮涌
03-09 342
静态链表 1 2 逻辑结构 3 静态链表是在顺序表的基础上利用数组实现的单链表，无指针 4  静态链表是柔性数组的一种典型的应用 5 6 7 8 9 创建可复用静态链表 11 12 13 20 小结 10 为什么静态链表的结构体中要再定义一个header成员，而不直接用node[0]?  21 header是逻辑上的一个链表上的头，而no
笔记---K个一组链表反转（java）
2302_79014065的博客
12-13 975
head` 表示要反转的子链表的起始节点，`tail` 表示要反转的子链表的终止节点。该方法返回一个包含两个 `ListNode` 类型的数组，其中第一个元素是反转后的子链表的尾节点，第二个元素是反转后的子链表的头节点。这时，`prev` 已经变成了反转后的子链表的尾节点，`p` 变量则指向反转后的子链表的最后一个节点（也是原子链表的首个节点）。1. 首先，初始化一个 `ListNode` 类型的变量 `prev`，并将它的值设置为 `tail` 的下一个节点。如果小于 k，则直接返回反转后的头结点。
数据结构-带头双向循环链表
2302_79539362的博客
12-02 2503
数据结构-带头双向循环链表
（数据结构）顺序表和链表
Captain_ldx的博客
08-07 548
一份详细的顺序表链表实现笔记！
数据结构笔记：单向链表
12-22
链表与顺序表都是线性表 知识点补充 b = 20 a = 'achar' a = b # 在python中，所有的变量保存的都是值的地址（就相当于c语言中的指针） # 等号右边表示执行，=b中的b就是执行，根据值的地址取到b的值，就成了a=20，...
数据结构学习笔记——单链表
12-21
链表（linked list）是一种在物理上非连续，非顺序的数据结构，由若干节点（node）组成 单链表每一个节点又包含两部分，1是存放数据的变量data，2是存放指向下一个结点的指针next 双向链表每一个节点包含三部分，在...
记录 — 数据结构与算法笔记.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）...
数据结构与算法学习笔记.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
【C语言】深入解析选择排序算法
qq_40205510的博客
04-19 577
选择排序是一种简单直观的排序算法，其基本思想是在未排序的序列中找到最小（或最大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。本文将详细介绍选择排序算法的原理，并给出C语言实现示例。
常见的数据结构，附带图解
weixin_58016347的博客
04-19 728
理解常见的数据结构
数据结构-并查集
qq_48664605的博客
04-21 194
【代码】数据结构-并查集。
高级数据结构—线段树（一）
最新发布
2302_81761369的博客
04-23 562
线段树
【数据结构】时间复杂度的例题
djdjiejsn的博客
04-22 901
🔍🌷前言：这篇文章是关于时间复杂度的一些例题，关于时间复杂度和空间复杂度和算法的计算效率的基本知识点我放在这篇文章。
C++进阶：搜索树
qq_71806743的博客
04-20 1088
【代码】C++进阶：搜索树。
【数据结构】二叉树（定义、性质、存储、遍历、构造）解析+完整代码
m0_61628700的博客
04-20 1134
定义1.每个结点至多有两棵子树；2.左右子树不能颠倒（二叉树是有序树）。特殊二叉树1.满二叉树一棵高度为h，且含有2h−12^h-12h−1个结点的二叉树。特点：（1）只有最后一层有叶子结点；（2）不存在度为1的结点；（3）按层序从1开始编号，结点i的左孩子为2i2i2i，右孩子为2i12i+12i1；结点i的父节点为⌊i2⌋⌊i/2⌋。2.完全二叉树。
数据结构-KMP算法
qq_48664605的博客
04-21 632
在进行字符串匹配的过程中，当模式串与主串在某个位置发生失配时，KMP算法意识到已有的部分匹配并没有被完全浪费。这是因为，从模式串的起始位置到失配点，有一段子串已经在主串中成功匹配。对于ABABC这个子串,前缀集合{A,AB,ABA,ABAB},后缀集合{C,BC,ABC,BABC}对于ABAB这个子串,前缀集合{A,AB,ABA}后缀集合{B,AB,BAB}对于ABA这个子串,前缀集合{A,AB}后缀集合{A,BA}对AB这个子串,前缀集合{A},后缀集合{B}对A这个子串,前缀集合,后缀集合都为空。
Redis入门到通关之数据结构解析-QuickList
莫等闲 白了少年头 空悲切
04-22 823
分段存储: QuickList将列表分成多个节点，每个节点都包含一定数量的元素，这样可以降低内存碎片化的程度，提高内存利用率。支持快速尾部插入和删除操作: 由于QuickList是一个双向链表，因此在列表的两端进行插入和删除操作的性能都很高，时间复杂度为O(1)。压缩列表优化: QuickList中使用的ziplist是一种紧凑的数据结构，它可以在一定程度上减少内存的消耗。另外，ziplist还支持一些特殊的操作，比如在固定时间内查找元素、在固定时间内插入元素等。
数据结构与算法c++笔记
08-31
很高兴回答你关于数据结构与算法的问题！以下是一些关于C语言中数据结构和算法的笔记： 1. 数据结构： - 数组（Array）：一组相同类型的元素按顺序存储在连续的内存空间中。 - 链表（Linked List）：由节点（Node）...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值