单链表(带或不带头结点)的建立、反转和部分反转

最新推荐文章于 2022-04-13 10:43:37 发布
最新推荐文章于 2022-04-13 10:43:37 发布
阅读量1.4k 收藏 5
点赞数 1
分类专栏： 数据结构+链表 文章标签： 数据结构 线性表 存储 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/g360z247j123/article/details/51854512
版权

数组是将元素在内存中连续存放，由于每个元素占用内存相同，可以通过下标迅速访问数组中任何元素。链表恰好相反，链表中的元素在内存中不是顺序存储的，而是通过存在元素中的指针联系到一起。

这里写图片描述

这里写图片描述

从上可知：链表中的元素在内存中是不连续的存储，每个结点只能也只有它能知道下一个结点的存储位置。

单链表是线性表链式存储的一种，其存储不连续。它的数据结构中包含两个变量：数据和指向下一个结点的指针。每个结点(尾结点除外)都只知道它的下一个结点的存储地址。一个单链表必须有一个头指针，用来指向单链表中的第1个元素结点(或头结点)；否则链表会在内存中丢失。

1 单链表的建立

1.1 不带头结点，从头部插入

#include <iostream>
#include <stdlib.h>

using std::cin;
using std::cout;
using std::endl;

struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
            val(x), next(NULL) {
    }
};

//不带头结点，从头部插入
ListNode* CreateList_Head(int n)
{
    if(n==0)
        return NULL;
    ListNode* pHead=NULL;
    ListNode* pNext=NULL;
    for(int i=0;i<n;i++)
    {
        ListNode* pNew=(ListNode*)malloc(sizeof(ListNode));
        if(pNew!=NULL)
        {
            int value;
            cin>>value;
            pNew->val=value;
            if(i)  //始终从第1个结点之后的位置开始插入
            {
                pNew->next=pNext->next;
                pNext->next=pNew;
            }
            else   //第1个结点
            {
                pNew->next=NULL;
                pHead=pNew;
                pNext=pNew;
            }
        }
    }
    return pHead;
}

1.2 不带头结点，从尾部插入

//不带头结点，从尾部插入
ListNode* CreateList_Tail(int n)
{
    if(n==0)
        return NULL;
    ListNode* pHead=NULL;
    ListNode* pNext=NULL;
    for(int i=0;i<n;i++)
    {
        ListNode* pNew=(ListNode*)malloc(sizeof(ListNode));
        if(pNew!=NULL)
        {
            int value;
            cin>>value;
            pNew->val=value;
            if(i)  //依次向后插入
            {
                pNext->next=pNew;
                pNext=pNext->next;
            }
            else   //第1个结点
            {
                pHead=pNew;
                pNext=pNew;
            }
        }
    }
    pNext->next=NULL;
    return pHead;
}

1.3 带头结点，从头部插入

//带头结点，从头部插入
ListNode* CreateListHead_Head(int n)
{
    if(n==0)
        return NULL;
   //创建头结点，头结点的val变量没有赋值
    ListNode* pHead=(ListNode*)malloc(sizeof(ListNode)); 
    if(pHead!=NULL)
    {
        pHead->next=NULL;
        for(int i=0;i<n;i++)
        {
            ListNode* pNew=(ListNode*)malloc(sizeof(ListNode));
            if(pNew!=NULL)
            {
                int value;
                cin>>value;
              //始终从头结点之后(向第1个元素结点的位置)插入
                pNew->val=value; 
                pNew->next=pHead->next;
                pHead->next=pNew;
            }
        }
    }
    return pHead;
}

1.4 带头结点，从尾部插入

//带头结点，从尾部插入
ListNode* CreateListHead_Tail(int n)
{
    if(n==0)
        return NULL;
    ListNode* pHead=(ListNode*)malloc(sizeof(ListNode)); //创建头结点，头结点的val变量没有赋值
    if(pHead!=NULL)
    {
        ListNode* pNext=pHead;
        pNext->next=NULL;
        for(int i=0;i<n;i++)
        {
            ListNode* pNew=(ListNode*)malloc(sizeof(ListNode));
            if(pNew!=NULL)
            {
                int value;
                cin>>value;
                pNew->val=value;   //从头结点之后依次向后插入
                pNext->next=pNew;
                pNext=pNext->next;
            }
        }
        pNext->next=NULL;
    }
    return pHead;
}

【注：】当单链表不带头结点时，头指针指向链表的第1个元素结点；当单链表带头结点时，头指针指向链表的头结点。

2 单链表的反转(逆置)

2.1 反转整个单链表

//反转整个链表
ListNode* RevListNode(ListNode* pHead)
{
    if(pHead==NULL)
        return NULL;
    ListNode* pRevHead=pHead;
    ListNode* pPrev=pHead;
    ListNode* pNext=pHead->next;
    while(pNext)
    {
        ListNode* pTemp=pNext->next;
        pNext->next=pPrev;
        pPrev=pNext;
        if(pTemp==NULL)
            pRevHead=pNext;
        pNext=pTemp;
    }
    pHead->next=NULL;
    return pRevHead;
}

2.2 反转单链表的部分区间元素

//反转链表的某一区间结点[startid,endid]，结点下标从1开始
ListNode* RevPartListNode(ListNode* pHead,int startid,int endid)
{
    if(pHead==NULL||startid<1||startid>endid)
        return NULL;
    ListNode* pRevPartHead=pHead;
    ListNode* pPrev=pHead;
    ListNode* pPPrev=NULL;
    ListNode* pNext=pHead->next;
    int indexid=1;
    while(pNext)
    {
        if(indexid>=startid)
        {
            if(indexid<endid)
            {
                ListNode* pTemp=pNext->next;
                pNext->next=pPrev;
                indexid++;
               //下标到达反转终止下标或者到达链表的尾部
                if(indexid==endid||pTemp==NULL) 
                {
                    if(startid>1)
                    {
                        pPPrev->next->next=pTemp;
                        pPPrev->next=pNext;
                        pRevPartHead=pHead;
                    }
                    else  //反转起始下标为1时链表的头指针才会改变
                    {
                        pHead->next=pTemp;
                        pRevPartHead=pNext;
                    }
                    break;
                }
                pPrev=pNext;
                pNext=pTemp;
            }
        }
        else
        {
            pPPrev=pPrev;
            pPrev=pNext;
            pNext=pNext->next;
            indexid++;
        }
    }
    return pRevPartHead;
}

3 打印单链表的所有结点元素值

//打印链表的所有结点值
void PrintListNode(ListNode* pHead)
{
    if(pHead==NULL)
        return ;
    ListNode* pNext=pHead;
    while(pNext)
    {
        cout<<pNext->val<<" ";
        pNext=pNext->next;
    }
    cout<<endl<<endl;
}

接着测试上述代码的正确性

#define ListNodeLen 10

int main()
{
　　//不带头结点从尾部插入
    ListNode* pHead=CreateList_Tail(ListNodeLen);
    cout<<endl<<endl;

    PrintListNode(pHead);
    PrintListNode(RevListNode(pHead));

    PrintListNode(RevPartListNode(pHead,1,4));
    PrintListNode(RevPartListNode(pHead,2,5));
    PrintListNode(RevPartListNode(pHead,6,10));

    return 0;
}

输入测试用例(单链表)为{0->1->2->3->4->5->6->7->8->9}，测试结果为

这里写图片描述

从上图可知，除了打印初始单链表和打印全部反转后的单链表的结果符合预期外，打印部分反转后的单链表的结果显得比较奇怪，都只有一个元素0值。

原因:在这5个打印操作中，链表结点指针pHead没有改变，它始终指向元素值为0的链表结点。自从第2个打印中单链表全部反转操作后，元素值为0的链表结点成为了新链表的尾结点；此时pHead指向的“单链表”只包含元素值为0的这一个结点。故后面的3个部分反转后的打印结果只有一个元素0值。

更改测试程序重新测试

#define ListNodeLen 10

int main()
{
　//不带头结点从尾部插入
    ListNode* pHead=CreateList_Tail(ListNodeLen); 
    cout<<endl<<endl;

    PrintListNode(pHead);
    ListNode* pRevHead=RevListNode(pHead);
    PrintListNode(pRevHead);

    pHead=RevListNode(pRevHead);
    PrintListNode(RevPartListNode(pHead,1,4));
    PrintListNode(RevPartListNode(pHead,2,5));
    PrintListNode(RevPartListNode(pHead,6,10));

    return 0;
}

测试结果如下所示

这里写图片描述

从上可知，单链表顺利地完成了全部反转和部分反转。例如第3个打印操作将初始单链表的前4个结点反转。由于pHead始终指向元素值为0的结点，故在第4个打印操作时“单链表”只有7个结点，接着反转它的第[2,5]个结点。由于“单链表”长度只有7，故最后的反转操作在第[6,7]个结点上。

参考资料

1.单链表带头结点&不带头结点

2.数据结构（四）——单链表 、带头结点的单链表、循环链表 及其实现

g360z247j123
关注
专栏目录
不带头结点的单链表反转 三种不同方法实现
漂客的博客
02-26 2620
typedef struct LinkList{ struct LinkList *next; int data; }LinkList; //头插法创建单链表 不带头结点(1+1 指针数，1个保存头结点+1个遍历指针) LinkList *creatLinkList(int n) {//创建一个含n个元素的单链表 LinkList *head = (LinkList *)...
数据结构（2）—单链表（带头结点和不带头结点）
qq_61914039的博客
08-31 3409
单链表是通过一组任意的存储单元来存储线性表中的数据元素。每个结点都有data数据域（用来存放数据元素）和next指针域（用来存放后继节点的地址）。对于顺序表，单链表可以解决顺序表需要一整个大量的连续的存储单元的缺点，单链表的元素可以离散地分布在存储空间中，即非随机存取的存储结构，不能直接找到表中某个特定的结点，当查找某个特定的结点时，需要从表头开始一个一个遍历。因为单链表附加了指针域，缺点就是存储空间增大。单链表有带头结点和不带头结点两种类型。引入头结点。
函数fun的功能是将不带头结点的单向链表逆置
07-23
给定程序中，函数fun的功能是将不带头结点的单向链表逆置，即若原链表中从头到尾结点数据域依次为：2、4、6、8、10，逆置后，从头至尾结点数据域依次为：10、8、6、4、2。 请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。
给定一个不带头结点的单链表，写出将链表倒置的算法
11-29
给定一个不带头结点的单链表，写出将链表倒置的算法
逆置单链表c语言不带头节点,单链表-不带头结点
weixin_30456235的博客
05-21 1019
链表，别名链式存储结构或单链表，用于存储逻辑关系为 "一对一" 的数据。与顺序表不同，链表不限制数据的物理存储状态，换句话说，使用链表存储的数据元素，其物理存储位置是随机的。链表中数据元素的构成每个元素本身由两部分组成：本身的信息，称为“数据域”；指向直接后继的指针，称为“指针域”。这两部分信息组成数据元素的存储结构，称之为“结点”。n个结点通过指针域相互链接，组成一个链表。typedef int...
逆置无头结点的单链表
lxy99的博客
04-13 5148
对于不带头结点的单链表L，设计一个递归算法逆置所有结点。编写完整的实验程序，并采用相应数据进行测试。 采用递归方法 思路：设f(L)返回单链表逆置后的首结点指针，为“大问题”，则f(L->next)返回逆置后的首结点指针p,为“小问题”，当小问题解决后，大问题的求解只需要将首结点（L指向它）链接到L->next节点的末尾就可以了。 #include<iostream> using namespace std; #define NULL 0 typedef struct node {
数据结构作业带或不带头结点链表
06-24
在本题目中，我们探讨的是两种常见的链表实现：带头结点和不带头结点的链表。这两种链表在C++编程语言中具有广泛的应用，是数据结构作业中的常见主题。 首先，链表是一种线性数据结构，其元素（节点）在内存中不是...
C语言 逆置单链表。 对于不带头结点的单链表h，设计一个递归算法逆置所有结点
最新发布
09-25
对于不带头结点的单链表，我们可以利用递归的方式实现这个操作，这里提供一个简单的递归算法思路： 1. **基础情况**：当链表只有一个节点时，不需要进行任何操作，因为单个节点本身就是它的逆序版本，所以返回原...
带头结点的单链表反转
weixin_30443813的博客
01-12 1141
struct Node { int data; Node *next; }; 方法一：就地逆序 主要思路：在遍历链表的时候，修改当前结点的指针域的指向，让其指向前驱结点。 为此，需要用三个指针变量分别指向当前结点、前驱结点、后继结点。遍历完所有的结点后，即可以完成指针的逆序。最后，让头节点的指针域指向原来最后一个元素结点。 void re...
不带头结点的单链表逆置c语言,设计不带头结点的单链表类模板,其功能是对链表中元素结点进行逆置.docx...
weixin_39922683的博客
05-21 533
设计不带头结点的单链表类模板,其功能是对链表中元素结点进行逆置设计不带头结点的单链表类模板,其功能是对链表中元素结点进行逆置篇一：实验一 不带头结点形式的单链表 　　实验一 不带头结点形式的单链表 　　专业：软件工程班级：09软工 学号：1XX11041XX 姓名：XXX 实验日期：XX-09-30 实验地点：B102 指导老师：吴景岚 一、 问题描述 　　实现不带头结点形式的单链表。...
将不带头结点的单链表倒置
10-15
《数据结构与算法》（张宪超）给定一个不带头结点的单链表，写出将单链表倒置的算法
不带头节点的单链表倒置算法
10-08
数据结构上机作业张宪超第二章。 给定一个不带头节点的单链表，写出链表倒置的算法。
不带头结点的链表操作及其逆置
lixin_com的博客
09-27 2624
一、概述 前面我们已经完成了带头结点的链表，今天我们来完成一下不带头结点的链表。事实上不带头结点的链表玉带头结点的链表差别在哪呢？ （1）带头结点的单链表更容易操作，因为不带头结点的单链表在第一个节点的操作与其他节点不一样，在初始化的时候就必须把第一个结点创建出来，然后将它的next置空而不带头结点的单链表则直接置空即可。 （2）不带头结点的单链表，初始化时一定要返回指向头结点的地址，所以要
C语言实现不带头结点的单链表逆置的三种方法
qq_44423388的博客
02-03 6740
C语言实现不带头结点的单链表逆置的三种方法直接循环头插法递归法END！ 直接循环 图片解释 ListNode* ReverseList1(ListNode *head) { if(head == NULL || head->next == NULL) { return head; } ListNode* tail = NULL; ListNode* p = head; ListNode* s = head -&gt
单链表的逆置（不带头结点）
weixin_30268921的博客
08-13 267
#include <stdio.h> #include <stdlib.h> typedef struct node { int data; struct node *next; }Node; Node *Initiate(Node *linklist) { linklist=NULL; return linklist; } Nod...
对一个不带头结点的单链表进行逆置
kungfu panda
01-22 8189
#include #include using namespace std; struct node { int data; node* next; }; node *L; node* reverse(node *h) { node *p,*q; p=NULL; q=h; while(q!=NULL) { h=h->next; q->next
不带头结点的单链表（非空）逆置
vener_的博客
08-29 761
typedef struct LNode{ int data; struct LNode *next; }LNode, *LinkList; LinkList Reverse(LinkList &L) { LNode *s,*p=L,*r=p->next; p->next==NULL;//处理第一个结点 while(r!=NULL) { s=p; p=r; r=r->next; p->next=s; } L.
【剑指Offer】反转链表（不带头结点）
桐原因的博客
04-15 186
题目描述 输入一个链表，反转链表后，输出新链表的表头。 /* struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(NULL) { } };*/ class Solution { public: ListNode* ReverseList(ListNode* pH...
不带头结点的单链表的就地逆置算法
qq_42584241的博客
06-18 8065
typedef struct node{ struct node *next; int data; }*LinkList,NODE; LinkList reverseList(LinkList head) LinkList p,q,l; q=head; L=head; p->next=NULL; while(L){ L=L->next; q->next=p...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值