单链表实现

最新推荐文章于 2022-09-07 16:38:32 发布
最新推荐文章于 2022-09-07 16:38:32 发布
阅读量586 收藏
点赞数
分类专栏： 数据结构 文章标签： 单链表 数据结构 单链表排序 合并单链表 单链表公共结点
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ajay666/article/details/73250478
版权

目录

线性表是数据结构的第一章，而考研和找工作都喜欢考察这方面的内容，因此，我就用C++实现了单链表，以及一些常见的算法题。

本文的具体内容包括：

  1. 单链表的基本操作
  2. 反向输出单链表
  3. 找到两个单链表的第一个公共结点
  4. 对单链表进行排序
  5. 将两个有序的链表合在一起，使之仍然有序

单链表的基本操作

不多说，直接上代码（注意基本操作中参数L的不同）：

///初始化一个单链表，申请头结点
void InitList(LinkList *L){
    *L = new LNode;
    if(*L==NULL){
        cout<<"new error"<<endl;
        return;
    }
    (*L)->next = NULL;
}
///释放头结点，将其设为null
void DestroyList(LinkList *L){
    LinkList t ;
    while((*L)!=NULL){
        t = (*L)->next;
        delete (*L);
        (*L) = t;
    }
}
///释放除头结点以外的所有空间
void ClearList(LinkList L){
    LinkList t,q=L;
    L = L->next;
    while(L!=NULL){
        t = L->next;
        delete L;
        L = t;
    }
    q->next = NULL;
}
///获取链表的长度
int Length(LinkList L){
    if(L == NULL)
        return -1;
     int cnt = 0;
     L = L->next;
     while(L!=NULL){
        ++cnt;
        L=L->next;
     }
     return cnt;
}
///返回链表L中第1个与e相等的元素的位置
int locateElem(LinkList L,int e){
    if(L==NULL)
        return -1;
    int index = 0;
    L = L->next;
    while(L!=NULL){
        if(L->data==e){
            return index;
        }
        ++index;
        L = L->next;
    }
    return -1;
}
///获取链表第i个元素的值
bool getElem(LinkList L,int i,LNode &e){
    if(L==NULL or i<0)
        return false;
    int j = 0;
    L = L->next;
    while(L!=NULL){
        if(j==i){
            e.data=L->data;
            e.next=L->next;
            return true;
        }
        ++j;
        L = L->next;
    }
    return false;
}
///在L中第i个位置插入结点e
bool ListInsert(LinkList L,int i,LNode e){
    if(L==NULL)
        return false;
    LinkList p;
    p = L;
    L = L->next;
    int j = 0;
    while(p!=NULL){
        if(j==i){
            LinkList t;
            t = new LNode;
            t->data = e.data;
            t->next = e.next;
            p->next = t;
            t->next = L;
            return true;
        }
        p = L;
        L = L->next;
        ++j;
    }
    return false;
}
///删除第i个元素，并返回该结点
bool ListDelete(LinkList L,int i,LNode &e){
    if(L==NULL)
        return false;
    LinkList p;
    int j = 0;
    p = L;
    L = L->next;
    while(L!=NULL){
        if(i==j){

            e.data = L->data;
            e.next = L->next;

            p->next = L->next;

            delete L;
            return true;
        }
        p = p->next;
        L = L->next;
        ++j;
    }
    return false;

}
///打印单链表L
void PrintList(LinkList L){

    if(L==NULL)
        return;
    L = L->next;
    while(L!=NULL){
        cout<<L->data<<' ';
        L = L->next;
    }
    cout<<" end"<<endl;
}

测试代码：

LinkList L;
    InitList(&L);
    cout<<"the address of the head node is "<<L<<endl;
    LNode e;
    e.data = 124;
    e.next = NULL;

    ListInsert(L,0,e);
    e.data = 132;
    ListInsert(L,0,e);
    e.data = 123;
    ListInsert(L,0,e);
    PrintList(L);

    cout<<"the length of L is "<<Length(L)<<endl;

    cout<<"the location of 132 is "<<locateElem(L,132)<<endl;

    if(getElem(L,1,e)){
        cout<<"the value of location 1 is "<<e.data<<endl;
    }

    if(ListDelete(L,1,e))
        cout<<"the value of deleted element is "<<e.data<<endl;
    else
        cout<<"delete failed"<<endl;

    ClearList(L);
    cout<<L<<endl;
    DestroyList(&L);
    cout<<L<<endl;

运行结果：
这里写图片描述

反向输出单链表

///从尾到头反向输出单链表L
///思路：反向输出很容易就想到栈，
///然后递归的本质就是栈，因此可以用
///递归来实现，先一层层递归到链表尾部，
///当指针为NULL时，返回，返回时输出当前节点的值
void PrintListByReverse(LinkList L){
    if(L==NULL)
        return;
    PrintListByReverse(L->next);
    cout<<L->data<<' ';
}

测试代码：

LinkList L;
    InitList(&L);
    LNode e;
    e.data = 124;
    e.next = NULL;
    ListInsert(L,0,e);
    e.data = 132;
    ListInsert(L,0,e);
    e.data = 123;
    ListInsert(L,0,e);
    e.data = 88;
    ListInsert(L,0,e);
    e.data = 14;
    ListInsert(L,0,e);
    e.data = 26;
    ListInsert(L,0,e);
    cout<<"the origin linklist is:"<<endl;
    PrintList(L);
    cout<<"print list in reverse:"<<endl;
    PrintListByReverse(L->next);
    cout<<"end"<<endl;

运行结果：
这里写图片描述

求两个单链表的公共结点

///找到两个链表的第一个公共结点
/**< 思路：若两个单链表有公共结点，那么他们的逻辑结构
肯定是Y形而不是X形（因为节点的next域只有一个），因此，
可以先计算两个链表的长度，然后先让较长的先移动d
（他们的长度差）个节点这样他们就会同时到达公共结点，
只需比较两个指针就可以了 */
bool FindCommonNode(LinkList La,LinkList Lb,LNode &e){
    if(La==NULL || Lb==NULL)
        return false;
    int la,lb;///La/Lb 的长度
    la = Length(La);
    lb = Length(Lb);
    int d = la-lb;
    int i = 0;
    La = La->next;
    Lb = Lb->next;
    if(d>0){
        while(La!=NULL){
            if(i==d){
                break;
            }
            ++i;
            La = La->next;
        }
    }
    else{
        d=-d;
        while(Lb!=NULL){
            if(i==d){
                break;
            }
            ++i;
            Lb = Lb->next;
        }
    }
    while(La!=NULL && Lb!=NULL){
        if(La == Lb){
            e.data = La->data;
            e.next = La->next;
            return true;
        }
        La = La->next;
        Lb = Lb->next;
    }
    return false;
}

测试代码：

LinkList L;
    InitList(&L);
    LNode e;
    e.data = 124;
    e.next = NULL;
    ListInsert(L,0,e);
    e.data = 132;
    ListInsert(L,0,e);



    LinkList myList;
    InitList(&myList);
    e.data = 83;
    ListInsert(myList,0,e);
    e.data = 19;
    ListInsert(myList,0,e);
    e.data = 46;
    ListInsert(myList,0,e);
    ConcatList(myList,L);
    cout<<"list 1 is:"<<endl;
    PrintList(myList);

    LinkList hisList;
    InitList(&hisList);
    e.data = 547;
    ListInsert(hisList,0,e);
    e.data = 78;
    ListInsert(hisList,0,e);
    ConcatList(hisList,L);
    cout<<"list 2 is:"<<endl;
    PrintList(hisList);

    if(FindCommonNode(myList,hisList,e))
        cout<<"the first common node is "<<e.data<<endl;

运行结果：
这里写图片描述

单链表排序

///对单链表进行排序
/**< 可使用插入排序，每次从后面选择一个结点，
在前面有序的序列选择一个合适的位置插入 */
void SortList(LinkList L){
    if(L==NULL)
        return;
    LinkList q,r,s,x;
    r = L;
    x = L;
    L=L->next;
    bool flag;
    while(L!=NULL){
        ///在前面找到合适的位置插入
        s = r;
        q = r->next;
        flag = false;
        while(q!=NULL && q!=L){
            ///找到第一个比当前结点大的结点
            if(q->data > L->data){
                flag = true;
                x->next = L->next;
                L->next = q;
                s->next = L;
                //PrintList(r);
                break;
            }
            s = s->next;
            q = q->next;
        }
        if(flag!= true)
            x=x->next;
        L=x->next;
    }

}

测试代码：

LinkList L;
    InitList(&L);
    LNode e;
    e.data = 124;
    e.next = NULL;
    ListInsert(L,0,e);
    e.data = 132;
    ListInsert(L,0,e);

    LinkList myList;
    InitList(&myList);
    e.data = 83;
    ListInsert(myList,0,e);
    e.data = 19;
    ListInsert(myList,0,e);
    e.data = 46;
    ListInsert(myList,0,e);
    ConcatList(myList,L);
    cout<<"before sort:"<<endl;
    PrintList(myList);
    SortList(myList);
    cout<<"after sort:"<<endl;
    PrintList(myList);

运行结果：
这里写图片描述

合并有序单链表

///合并有序单链表La、Lb，放到La里面去，并且合并后的链表仍然有序
void MergeList(LinkList La,LinkList Lb){
    LinkList pa = La->next,pb = Lb->next,t;
    LNode *r;
    La->next  = NULL; ///La 作为结果链表的指针
    t = La;
    while(pa != NULL && pb != NULL){
        if(pa->data > pb->data){
            r = pb->next; ///r 暂存pb的后继结点
            ///在La插入
            pb->next = La->next;
            La->next = pb;
            ///恢复pb为下一个待比较结点
            pb = r;
            La = La->next;
        }
        else{
            r = pa->next; ///r 暂存pb的后继结点
            ///在La插入
            pa->next = La->next;
            La->next = pa;
            ///恢复pb为下一个待比较结点
            pa = r;
            La = La->next;
        }
        //PrintList(t);

    }
    if(pa!=NULL)
        La->next = pa;
    if(pb!=NULL)
        La->next = pb;
    delete Lb;
}

测试代码：

 LNode e;
    LinkList List1;
    InitList(&List1);
    e.data = 24;
    ListInsert(List1,0,e);
    e.data = 68;
    ListInsert(List1,0,e);
    e.data = 35;
    ListInsert(List1,0,e);
    e.data = 123;
    ListInsert(List1,0,e);
    e.data = 77;
    ListInsert(List1,0,e);
    e.data = 15;
    ListInsert(List1,0,e);
    SortList(List1);


    LinkList List2;
    InitList(&List2);
    e.data = 23;
    ListInsert(List2,0,e);
    e.data = 46;
    ListInsert(List2,0,e);
    e.data = 98;
    ListInsert(List2,0,e);
    e.data = 143;
    ListInsert(List2,0,e);
    e.data = 18;
    ListInsert(List2,0,e);
    e.data = 85;
    ListInsert(List2,0,e);
    SortList(List2);
    cout<<"list 1 is :"<<endl;
    PrintList(List1);
    cout<<"list 2 is :"<<endl;
    PrintList(List2);
    MergeList(List1,List2);
    cout<<"after merge:"<<endl;
    PrintList(List1);

运行结果：
这里写图片描述

总结

虽然说单链表逻辑比较简单，但是涉及指针操作，很容易出错，我建议在纸上画图来编写代码，这样思路比较清晰。

数据结构-单链表
L1290340915的博客
04-10 617
1.LinkList.h #pragma once #include<stdio.h> #include<stdlib.h> typedef int elemType; typedef struct LNode { elemType data; //结点数据域 struct LNode* next; //结点指针域 }LNode, * LinkList; //LinkList为指向结构体LNode的指针类型，与LNote*等价 bool InitList(LinkLi
编写一个程序，实现单链表的各种基本运算
Stay hungry
11-14 1万+
本实验的单链表元素的类型为char，完成如下实验要求： （1）初始化单链表h （2）采用尾插法依次插入a、b、c、d、e （3）输出单链表h （4）输出单链表h的长度 （5）判断单链表h是否为空 （6）输出单链表h的第3个元素 （7）输出元素a的逻辑位置 （8）在第4个元素位置上插入元素f （9）输出单链表h （10）删除单链表h的第3个元素 （11）输出单链表h （12）
数据结构(3)--线性表实现一元多项式加法
热门推荐
小白的专栏
02-05 4万+
参考书籍：数据结构（C语言版） 严蔚敏 吴伟民编著 清华大学出版社 本文中的代码可从这里下载：https://github.com/qingyujean/data-structure 1.简要说明 一元多项式的表示和相加 多项式Pn(x)按升幂可写成： Pn(x) = P0+P1*x+p2*x^2+...+Pn*x^n, 它由n+...
数据结构知识点重点
qq_46264183的博客
11-12 849
A—熟练掌握 B—理解 C—了解 第一章：绪论 基本概念： 包括数据的逻辑结构、数据的存储结构和数据的相关运算。C 四类数据组织结构：集合、线性表、树形、图状结构 C 数据的存储方式：顺序存储和链式存储。B 2.算法和分析 算法的特征、时间复杂度的分析和常见的时间复杂度增长率排序、空间复杂度 B 本章重点：分析算法时间复杂度 例1. 下面关于算法说法错误的是（ ） A．算法最终必须由计算机程序实现 B.为解决某问题的算法同为该问题编写的程序含义是相同的 C. 算法的可行性是指指令不能有二义
用单链表实现栈
qq_51793991的博客
07-16 1218
用单链表实现栈的压栈和弹栈操作，栈是一种先进后出，后进先出的数据结构（类似弹夹），top节点指向栈第一个元素
单链表实现简单选择排序
weixin_45278641的博客
07-29 4906
递增有序每次从原链表中找出一个最大(最小)元素，然后头插(尾插)到结果链表中。递减有序每次从原链表中找出一个最小(最大)元素，然后头插(尾插)到结果链表中。
对单链表实现就地逆置
qq_47991812的博客
11-27 3553
对单链表实现就地逆置 /* 对单链表实现就地逆置 */ #include <stdio.h> #include "malloc.h" typedef struct LNode{ int data; struct LNode *next; }LNode,*LinkList;//线性链表类型 //逆置 //先把头结点后一个结点i放在末尾，然后在之前末尾结点和当前末尾结点i之间插入结点如：1 2 3 4 -->2 3 4 1 --> 4 3 2 1 vo...
单链表实现约瑟夫环问题
weixin_52596036的博客
09-07 3326
这两天想到了之前自己用数组实现约瑟夫环问题时写了好多的代码，然后想到数据结构中的但链表好像也可以实现，于是去实践了一下，发现果然可以实现，而且还代码还简洁明了不少。
单链表实现多项式相加
魏宇轩
12-03 8073
循环链表
单链表实现大整数相加
qq_62175345的博客
05-02 2269
C/C++语言中的int类型能表示的整数范围是-2^31~2^31-1,unsigned int类型能表示的整数范围是0~2^32-1, 即0~4 294 967 295，所以，int和unsigned int类型都不能存储超过10位的整数。有些问题需要处理的整数远远不止10位， 这种大整数用C/C++语言的基本数据类型无法直接表示。请编写算法，采用顺序表或者单链表实现两个大整数相加运算。 提示：将用户输入的十进制整数字符串转化为顺序表或者带头结点的单链表， 每个数据元素或每个结点中存放一个整数位，然...
C++单链表实现大数加法
08-19
C++单链表实现大数加法 大数加法是一种常见的算法问题，特别是在C++中实现大数加法时需要考虑到数字的位数和溢出问题。使用单链表来实现大数加法可以解决这个问题。本文将详细介绍如何使用C++单链表实现大数加法。 ...
利用带头结点的单链表实现两个集合的并、交、差运算.docx
04-19
利用带头结点的单链表实现两个集合的并、交、差运算 本文档的主要内容是使用带头结点的单链表实现两个集合的并、交、差运算。该文档共分为八个部分，分别是题目重述、题目功能描述、概要设计图、程序源代码及注释、...
单链表实现约瑟夫环
09-29
单链表解决约瑟夫环问题
单链表实现双向循环链表_链表_
09-29
单链表实现双向循环链表单向链表存在一个弊端就是，当需要获取某个结点p的前驱时，需要从头指针开始遍历链表，获得“前驱”的执行时间为O(n)，为了克服单向链表的这种缺点，可以利用双向链表。在双向链表中有两个...
单链表实现的多项式运算.cpp
03-25
利用单链表的数据结构，在读取数据时就按指数次方排序好，再加法的运算中可以直接按指数的大小进行运算，相比随机的读入数据，这个方法优化了程序。乘法则是在加法的基础上把每一项的系数进行相乘并最后求和。注意...
二叉树的C++实现
Ajay666的博客
08-05 3万+
数据结构与二叉树类的定义我采用链式存储结构来表示二叉树，每一个二叉树节点包含树节点的值、树的左孩子指针、树的右孩子指针：class BiNode{ public: char data; struct BiNode *lchild,*rchild; };那么对于一个二叉树来说，只需要存放指向树根节点的指针即可，另外还需要声明二叉树的一些功能，比如遍历方法、求树高等（BiTree.h）：
利用二叉树的非递归后序遍历求解最近公共祖先问题
Ajay666的博客
08-05 3002
通过上一篇的博客我们知道，可以利用栈来实现二叉树的后序遍历。其实这里有一个性质，就是当使用非递归后序遍历时，栈中的元素就是当前节点到根节点的路径。利用这个规律，我们就可以求解最近公共最先问题了。 算法 找出两个节点各自到根节点的路径。这里利用非递归后序遍历二叉树，既可以找到两个节点到根节点的路径。 根据路径找出最近的公共祖先。首先根节点肯定是他们的祖先，可以从跟节点开始查找，直到最后一个相同的树节点
栈的C++实现及其应用
Ajay666的博客
07-20 1509
栈是一种先进后出的数据结构，是一种功能受限的线性表。因为这世间存在这后进先出的计算顺序，为简化计算的过程，栈得以应用。好比装水的桶，好比装子弹的弹夹。 栈的C++实现本文主要是编程实现栈，使用的是顺序储存结构（动态数组）来实现栈，需要注意的是当内存空间不够用，即栈满的时候，应该将重新开辟新的空间（大小为源空间大小+STACK_INCREMENT），然后将数据复制到新空间，在重新释放旧空间。 下面给
二叉排序树、平衡二叉树以及红黑树
Ajay666的博客
08-09 1342
现实生活中，有很多找东西的例子，比如在学校找某个人，在驿站找快递，在信息登记表上查找某个人的信息，那么在计算机科学中，具体有哪些可以加快查找的算法？下面我们就来看看其中的动态查找算法，动态查找的意思是当你查找某个键值的信息，若存在则输出，否则将插入该键值为后续进行查找。 二叉排序树首先我们来看看二叉排序树，二叉排序树有点类似于二分查找的思路，但是它用树的形式来表示查找的方向。 定义： （1）一个
单链表实现与操作详解
在实现单链表时，通常会引入一个头结点，即使得链表的头部有一个特殊的节点，它的主要作用是在链表头部进行插入和删除操作时提供便利。头结点的数据域通常不存储实际数据，而其指针域指向链表的第一个数据节点。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值