数据结构代码题--头插法和尾插法的应用

最新推荐文章于 2024-04-27 18:02:39 发布
最新推荐文章于 2024-04-27 18:02:39 发布
阅读量943 收藏 8
点赞数 1
分类专栏： 数据结构 文章标签： 链表 数据结构 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XUN__MLF/article/details/126432684
版权

头插法建立单链表（一般用于链表的逆置）头插防断链 就是说用头插法时要给 p指针一个后继结点

// 单链表的定义 
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList; 
​
 
/*头插法建立单链表*/ 
LinkList Insert_Head(LinkList &L){
    LNode *s;
    int x;
    L = (LinkList)malloc(sizeof(LNode));    // 创建头结点 
    L->next = NULL;                         // 初始为空链表
    scanf("%d",&x);
    while(x!=-1){
        s = (LNode *)malloc(sizeof(LNode));     // 创建新结点
        s->data = x;
        s->next = L->next;          // 将新结点插入表头 
        L->next = s; 
        scanf("%d",&x);
    } 
        return L; 
}

、2、尾插法建立单链表 尾插留尾指针 用尾插法时要有一个尾指针 r

// 单链表的定义 
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList; 
​
 
/*尾插法建立单链表*/ 
LinkList Insert_Head(LinkList &L){
    LNode *s;
    LNode *r;   // 表尾指针 
    int x;
    L = (LinkList)malloc(sizeof(LNode));    // 创建头结点 
    r = L; 
    scanf("%d",&x);
    while(x!=-1){
        s = (LNode *)malloc(sizeof(LNode));     // 创建新结点
        s->data = x;
        r->next = s;
        r = s;                  // r 指向新的表尾结点 
        scanf("%d",&x);
    } 
    
    r->next = NULL;         // 尾结点指针指向空 
    return L; 
} 
​

1、单链表逆置

1、带头结点的单链表就地逆置 头插法

// 单链表的定义 
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList; 
​
/*算法思想：用头插法*/ 
LinkList Reverse(LinkList L){
    LNode *p = L->next;
    LNode *r;       // P 的后继结点
    while(P->NULL){
        r = p->next;    // 保留p的后继，防止断链 
        p->next = L->next;      // 头插法 
        L->next = p;
        p = r;
    } 
    return L; 
}

2、L={a1,a2,a3,……an}------>L={a1,an,a2,an-1,a3,an-2……}

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList; 
​
​
/*算法思想：
找中间结点：两个指针同步从开头遍历，一个慢指针一次走一步，一个快指针一次走两步，当快指针到达表尾时，慢指针就刚好指向中间结点 
后半段逆置：头插法 
合并 ：尾插法 
​
*/
​
void change_list(LinkList &L){
    LNode *p,*q,*r,*s;
    // 1、寻找中间结点 
    while(q->next!=NULL){
        p = p->next;    // p走一步 
        q = q->next;    // q走两步 
        if(q->nextQ=NULL){
            q = q->next;
        } 
    }
    // 2、逆置（头插法） 
    q = p->next;  //  后半段链表，p为中间结点，q为后半段链表的首结点 
    while(q!=NULL){
        r = q->next;  // 头插法，防止断链
        q->next = p->next;
        p->next = q;
        q = r; 
    }  
    // 3、从新合并
    s = L->next;        // s指向前半段第一个结点，即插入点
    q = p->next;        // q 指向后半段第一个结点 
    p->next = NULL;
    while(q!=NULL){
        r = q->next;
        q->next = s->next;
        s->next = q;
        s = q->next;        // s指向前半段下一个插入点
        q = r; 
    } 
}

2、链表归并与分解

1、将一个带头结点的单链表A分解为两个带头结点的单链表A和B,使得A表中保存序号是奇数的元素，B中保存序号是偶数的元素

// 单链表的定义 
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList; 
​
/*算法思想：不断的使用尾插法，序号奇数插入A,偶数插入B*/
LinkList Creat(LinkList &A){
    LNode *p = A->next;
    LinkList B = (LinkList)malloc(sizeof(LNode));   // 创建B链表 
    B->next = NULL;     // B链表初始化 
    A->next = NULL;     // 置空新的A链表 
    LNode *ra=A,*rb = B;        // 两个尾指针 
    int i = 0;      // 记录序号是奇数还是偶数 
    while(p!=NULL){
        i++;
        if(i%2 == 0){   // 偶数位插入B 
            rb->next = p;    // 尾插法 
            rb = p; 
        }else{          // 奇数插入A 
            ra->next = p;
            ra = p;
        }
        p = p->next;
    }
    ra->next = NULL;    // 表尾指针指空 
    rb->next = NULL;
    return B;
}

2、A={a1,b2,a2,b2……an,bn}，采用带头结点的单链表存放，将其拆分为两个单链表A={a1,a2,……an},B={bn,bn-1,……b2,b1}

// 单链表的定义 
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList; 
​
/*算法思想：遍历A链表，将奇数位尾插入A中，偶数位头插入B中*/
LinkList Creat(LinkList &A){
    int i = 0;
    LNode *p = A->next,*q;
    LNode *ra = A;
    LinkList B = (LinkList)malloc(sizeof(LNode));
    B->next = NULL;
    A->next = NULL;
    while(p!=NULL){
        i++;
        if(i%2 == 0){   // 奇数位,头插入B 
            q = p->next; // 头插法遍历原来的A链表时，保留p的后继结点，防止断链
            p->next = B->next;
            B->next = p;
            p = q; 
        }else{      // 奇数位，尾插入A中 
            ra->next = p;   // 尾插法 
            ra = p;
            p = p->next;
        }
    } 
    ra->next = NULL;
    return B;
}

3、将两个按元素值递增排序的单链表合并位一个按元素值递减排序的单链表

// 单链表的定义 
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList; 
​
/*算法思想：依次比较A和B中的值，将小的头插入到C中,如果其中一条链表有元素剩余，则依次进行头插入C中*/ 
void MergeList(LinkList &A,LinkList &B){
    LNode *p = A->next;
    LNode *q = B->next;
    LNode *t;       // 防止断链 
    A->next = NULL  // A置空 
    while(p!=NULL&&q!=NULL){
        if(p->data<=q->data){   // 将较小的头插入A中
            t = p->next;        //头插法遍历原来的链表时，保留p的后继结点，防止断链
            p->next = A->next;
            A->next = p;
            p = q;
        }else{              //  将较小的B头插入A中
            t = q->next;
            q->next = A->next;
            A->next = q;
            q = t; 
        }
    }
    
    while(p!=NULL){     // A中还有元素剩余，依次头插入A中 
        t = p->next;        //头插法遍历原来的链表时，保留p的后继结点，防止断链
        p->next = A->next;
        A->next = p;
        p = q;
    }
    
    while(q!=NULL){     // B中还有元素剩余，依次头插入A中 
        t = q->next;
        q->next = A->next;
        A->next = q;
        q = t;
    } 
    free(B);
}

4、A，B为元素递增有序的单链表，找到A和B中的公共元素，存放到C中

// 单链表的定义 
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList; 
​
/*算法思想：遍历A和B链表，比较元素值，将元素值小的指针后移，将相等的元素值尾插法插入到C中*/
void Creat_Conmmon(LinkList A,LinkList B){
    LinkList C = (LinkList)malloc(sizeof(LNode));   // 创建C链表 
    C->next = NULL;         // 初始化C链表 
    LNode *p = A->next;
    LNode *q = B->next;
    LNode *r = C;
    LNode *s; 
    while(p!=NULL&&q!=NULL){
        if(p->data > q->data){      //更小的指针后移， q向后移 
            q = q->next; 
        }else if(p->data < q->data){    // p向后移
            p = p->next; 
        }else{  // 相同结点尾插法插入C中
            s = (LNode *)malloc(sizeof(LNode)); 
            s->data = p->data;
            r->next = s;
            r = s;
            // p,q同时后移
            p = p->next;
            q = q->next; 
        } 
    } 
    
    r->next = NULL; 
}

5、A,B两个单链表递增有序，求A，B的交集并存放于A中

​
// 单链表的定义 
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList; 
​
​
​
/*算法思想：依次扫描A，B两条链表，比较data域的值，将较小的指针向后移动（并释放空间），若
两者相等，则尾插入A中，直到遍历表尾，（若A链表还有元素剩余，则逐个释放剩余元素，只保留公共元素）*/
​
void Union(LinkList &A,LinkList &B){
    
    LNode *p = A->next;
    LNode *q = B->next;
    LNode *u;
    A->next = NULL;         // A链表置空，重新插入元素 
    LNode *r = A;
    
    while(p!=NULL && q->next!=NULL){
        if(p->data < q->data){      // 元素小的指针后移，并释放空间 
            u = p;
            p = p->next;
            free(u);
        }
        else if(p->data > q->data){
            u = q;
            q = q->next;
            free(u);
        }
        else{               // 找到公共元素，保留一个，释放一个 
            r->next = p;
            r = p;          // 保留p释放q;
            p = p->next;
            u = q;
            q = q->next;
            free(u); 
        }
    }
    
    while(p!=NULL){     // A链表还存在元素，但是已经一定不含公共结点，依次释放空间 
        u = p;
        p = p->next;
        free(u);
    }
    while(q!=NULL){    // B链表还有元素 
        u = q;
        q = q->next;
        free(u);
    }
    r->next = NULL;
    free(B);
}

4、寻找相同子序列

1、两个整数子序列A = a1,a2……an B= b1,b2,……bn,存放到两个单链表中，判断序列B是否为A的连续子序列

// 单链表的定义 
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList; 
​
/*算法思想：暴力法：类似字符串的模式匹配，依次遍历A和B链表，如果data值相同，同时后移，如果不相同
A返回开始比较结点的后继结点，B则从头开始 
​
*/
bool Pattern(LinkList A,LinkList B){
    LNode *p = A->next;
    LNode *q = B->next;
    LNode *pre = p;
    
    while(p!=NULL&&q!=NULL){
        if(p->data == q->data){     // 结点值相同，两个结点同时向后移
            p = p->next;
            q = q->next; 
        }else{
            pre = pre->next;    // 
            p = pre;            // A返回开始比较结点的后继结点
            q = B->next;        // B则从头开始  
        } 
    }
    
    if(q == NULL){      // B中没有元素了,说明B是A的自序列 
        return true;
    }else{
        return false;
    }
     
} 
​
XUN~MLF
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
单链表应用
11-01
该资源能实现在每三次就把链表的一个元素消除，知道剩最后一个
小白算法积累——单链表5#带头结点单链表+就地逆置
aprilzj123的博客
02-18 1906
题目：试编写算法将带头结点的单链表就地逆置，所谓“就地”是指辅助空间复杂度为O(1)。 关键字：带头结点的单链表+就地逆置 思路 关注：递归算法的设计重点在于找到“递归”的部分，即重复调用函数，改变部分相关变量 设f(L,x)的功能是：删除以L为首结点指针的单链表中所有值等于x的结点，显然有f(L->next,x) 1.通用逆置函数:遍历循环+头尾元素互换 需要变量：L, 相对头尾结点下标：...
数据结构（2）——头插法、尾插法（详细）新建列表
MilesXue的博客
03-05 293
链表的插入方法
单链表及其应用
01-07
利用单链表实现电话本的模拟程序：定义单链表的数据类型，将头插法和尾插法、插入、删除、查找、修改、计数、逆置、输出等操作都定义成子函数的形式，最后在主函数中调用它，并将每一种操作前后的结果输出，以查看每一种操作的效果。
数据结构与算法实际应用.doc
07-11
学院 《数据结构与算法》之实际应用 二零一三年三月十三日 目录 数据结构与算法在实际中的应用 2 摘要： 2 一、 定义： 2 二、 在各领域中的实际应用 2 （一）、排队叫号系统（尾插法） 3 （二）、搜索引擎与数据结构算法 4 （三）、图论应用 5 （四）、最小生成树在城市高速公路问题中的应用 5 三、小结 6 四、参考文献……………………………………………………………6 小组成员： 数据结构与算法在实际中的应用 摘要： 计算机科学是一门研究用计算机进行信息表示和处理的科学。这里面涉及到两个问题 ：信息的表示，信息的处理 。何为信息，信息就是大量的数据，需要对大量的数据进行处理。进而我们需要《数据结 构与算法》这门课作为基础，去发展计算机学科。数据结构是一门研究非数值计算的程序 设计问题中计算机的操作对象（数据元素）以及它们之间的关系和运算等的学科，而且 确保经过这些运算后所得到的新结构仍然是原来的结构类型。通过《数据结构与算法》的 学习，我们能够解决很多学科问题、生活实际问题。 一、定义 《数据结构与算法》应该包括两个部分：数据结构、算法。 数据结构在计算机科学界至今没有标准的定
数据结构 单链表的实现及其应用
04-20
数据结构课程，是关于单链表的实现及其应用程序，希望可以帮助你
单链表头插法和尾插法的算法程序
01-19
头插法 头插法是用结构体数组来实现的。 具体的思路是:在建立邻接表时，记录的不是点而是边，对于每一个点所对应的邻接表都是以栈的形式存储的，也就是说先添加的边在遍历时后取出，除此以外，所有的边用一个结构体数组存储起来，每条边对应的索引就是其编号，在建立邻接表时，表中存放的实质是边的编号，在遍历时先获得编号，在放回结构体数组中获得相应的边的数据。
#数据结构 单链表头插法和尾插法代码实现
qq_42368203的博客
05-14 582
[数据结构]头插法与尾插法
ilikeprograming的专栏
09-29 1万+
#include "stdio.h" #include "stdlib.h" typedef struct List { int data; //数据域 struct List *next; //指针域 } List; void TailCreatList(List *L) //尾插法建立链表 { List *s, *r;//s用来指向新生成的节点。r始终指向L的终端节点。 r = L;
单链表的头插法与尾插法代码实现及详解
大彤小忆的博客
05-25 9013
1. 头插法2. 尾插法 1. 头插法   头插法： 从一个空表开始，重复读入数据，生成新结点，将读入数据存放到新结点的数据域中，然后将新结点插入到当前链表的表头结点之后，直到读入结束标志为止。   头插法代码实现： List HeadCreatList() //头插法建立链表 { List L = (List)malloc(sizeof(PtrToNode)); //初始化空表，申请一个头结点 L->Next = NULL; //头指针为空 for (int i = 0; .
（最详细）c语言尾插法&头插法代码讲解
热门推荐
HHHSSD的博客
04-14 2万+
1.尾插法 尾插法 头指针和尾指针都指向头结点，然后往里边插入元素， 每插入一个元素尾指针就后移一下 其中如下图所示 尾插法的核心代码是： pointer->next = s; //pointer指向新生成的节点 pointer = pointer->next;//pointer移动至新节点位置 尾插法建立单链表的算法如下： #include <stdio.h> #include <stdlib.h> struct Test { int .
数据结构——基于C语言实现单链表的应用.rar
08-11
//初始化表 //头插法添加结点 // 尾插法添加结点 //查找的函数（按序号查找） //根据长度输出单链表的数据 // 插入一个新的结点 //单链表的删除操作
头插法，尾插法sequence-table-master.zip
04-17
头插法，尾插法sequence-table-master.zip
test3-插入.rar_尾插法_有头插法_链表 插入创建
09-20
链表 插入创建，有头插法，尾插法，入门级的，供实验使用
头插法、尾插法、链表长度test-c-master.zip
04-17
头插法、尾插法、链表长度test_c-master.zip
cpp代码-单链表的建立（头插法、尾插法）
07-14
cpp代码-单链表的建立（头插法、尾插法）
【数据结构】三、栈和队列：2.顺序栈&共享栈（顺序栈的初始化，判空，进栈，出栈，读取栈顶，顺序栈实例）
来csdn只办三件事：开源！开源！还是***开源！
04-23 1210
因为顺序栈的缺点是栈的大小不可变，所以引出共享栈，两个栈共享一片空间。这片存储空间不单独属于任何一个栈，某个栈需要的多一点，它就可能得到更多的存储空间。两个栈的栈底在这片存储空间的两端，当元素入栈时，两个栈的栈顶指针相向而行。当他们下一个指针的位置在一起时，说明这个栈已经放满元素。C++是一门面向对象的高级语言，在我们编写代码中，常常离不开对对象的创建和清理对象资源。指向栈顶元素，一般存储的是数组的下标。top当前指向的位置是栈顶上面的一个没有元素的空位置。如果有abcde，5个元素，那么满栈top=4。
【Redis 开发】(Feed流的模式，GEO数据结构，BitMap,HyperLogLog)
最新发布
weixin_62513677的博客
04-27 567
如果我们需要统计UV值，我们可以使用HyperLogLog，它是从LogLog算法中派生出来的概率算法，用于确定非常大的集合的基数，但是它的单个存储的统计内存永远小于16kb，但是代价就是统计是概率性的有小于0.81%的误差，不过可以忽略。也叫做写扩散，发布的消息不需要写入到发件箱中，直接推送到被关注人的收件箱中并通过时间戳进行排序，延时低，但是比如说微博中的一些大V，粉丝人特别多，这样就会写很多。范围可以是圆形或矩形。:指定圆心、半径，找到该圆内包含的所有member，并按照与圆心之间的距离排序后返回。
数据结构中的串（String）：概念、操作和实际应用
JAZJD的博客
04-24 1009
在计算机科学中，串 是由零个或多个字符组成的有限序列，是数据结构中常见的一种基本类型。它可以为空串，也可以是由字符组成的非空串。串通常用于表示文本数据，如文件内容、用户输入等，因此在算法和程序设计中占据着重要的地位。一个串可以是由字母、数字、符号等任意字符组成，字符的种类和个数没有固定限制。例如，"Hello, World!@#$%" 都是串的例子。串的重要性在于它是对文本数据进行处理和操作的基础，涉及字符串匹配、文本编辑、编译器设计等多个领域。因此，深入理解串的特性和操作对于程序设计人员至关重要。
 数据结构头插法尾插法区别
03-23
数据结构中的头插法和尾插法是两种常见的插入元素的方式，它们的区别如下： 1. 头插法： 头插法是将新元素插入到链表或者队列的头部。具体步骤如下： - 创建一个新节点，并将新节点的值设置为待插入的元素。 - ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

XUN~MLF

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值