c链表经典基础算法

已于 2022-01-29 15:52:15 修改
阅读量910 收藏 22
点赞数
分类专栏： 后台专栏-C语言 文章标签： 链表
于 2021-03-05 14:16:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gaosunka/article/details/114394666
版权

0.1.10 已知一个顺序表L中的数据元素是是整数类型，编写算法删除顺序表中的最小的数据元素。

//线性表的顺序存储结构如下：
#define MaxSize = 100
typedef struct
{
    int data[MaxSize]; //线性表占用的数组空间
    int length;        //记录顺序表的长度
}SeqList;

// Answer

void del_num(SeqList *L)
{
    int i, j, min;
    min = L->data[0];
    for (i = 1; i < L->length; i++)
        if (L->data[i] < min)
            min = L->data[i];
    for (i = 0; i < L->length; i++)
        if (L->data[i] == min) //如果数据是最小值
        {
            for (j = i; j < L->length - 1; j++)
                L->data[j] = L->data[j + 1]; //将数据向上移动
            L->length--;
            i--; //为了保证删除的正确,应使循环变量向后退一个
        }
}

0.2.15 有两个带头结点的非递减有序的单链表A和B，设La是单链表A的头指针，Lb是单链表B的头指针。编写算法，将这两个单链表合并成一个非递增有序的单链表C。要求单链表C仍使用原来两个链表的存储空间。


LinkList MergeLinkList(LinkList LA, LinkList LB)
{
    LNode *pa, *pb, *r;
    LinkList LC;
    pa = LA->next; //定位到链表的第一个元素结点
    pb = LB->next;
    LC = LA;
    LC->next = NULL;
    r = LC; //对新链表 LC 进行尾插
    while (pa != NULL && pb != NULL)
        if (pa->data <= pb->data)
        {
            r = pa;
            pa = pa->next; //指针向后移动
            r->next = LC->next;
            LC->next = r;
        }
        else
        {
            r = pb;
            pb = pb->next; //指针向后移动
            r->next = LC->next;
            LC->next = r;
        }
    while (pa)
    {
        r = pa;
        pa = pa->next;
        r->next = LC->next;
        LC->next = r;
    }
    while (pb)
    {
        r = pb;
        pb = pb->next;
        r->next = LC->next;
        LC->next = r;
    }
    return LC;
}

9.1.15 已知线性表A采用顺序存储结构。编写算法，将该表A中的元素循环右移k位，要求空间复杂度为O(1)。

/**@gdr
 * 例如：表A的原始数据是1、2、3、4、5、6
 * 若k=2
 * 则表A的最终数据是5、6、1、2、3、4
 * 线性表的顺序存储结构如下
 * 
 * */
typedef struct
{
    ElemType elem[MaxSize]; /* 线性表占用的数组空间 */
    int length;             //记录顺序表的长度
} SeqList;

//answer 算法思想:现将顺序表的前(n-k)位翻转，再将后 k 位翻转
//，最后将整个顺序表翻转，即可实现顺序表循环右移 k 位。

void reverse(Seqlist &L, int left, int right)
{
    for (int i = 0; i < (right - left + 1) / 2; i++)
    {
        int temp = L.elem[left + i];
        L.elem[left + i] = L.elem[right - i];
        L.elem[right + i] = temp;
    }
}
void r_converse(Seqlist &L, int k)
{
    int n = L.length;
    reverse(L, 0, n - k - 1);
    reverse(L, n - k, n - 1);
    reverse(L, 0, n - 1);
}

19.2.15 设head为一个带头结点单链表的头指针，且该单链表的数据是无序的。编写算法删除该单链表中值相同的多余结点。
在这里插入图片描述

/**算法思想：采用尾插法，先将头结点摘下，然后从
*第一个结点开始，在已经插入结点的链表中查找此结
*点，若不存在，则插入，反之跳过，直到最后一个结
点为止。*/
typedef struct LNode
{
    ElemType data;
    struct LNode *next;
} LNode, *LinkList;
void Del_same(LinkList &head)
{
    LNode *p = head->next; //p 为扫描工作指针
    head->next = NULL;     //将头结点摘下
    while (p != NULL)
    {
        ElemType temp = p->data;
        LNode *q = head->next;
        LNode *pre = head;
        while (q != NULL && temp != q->data)
        {
            q = q->next;
            pre = pre->next;
        }
        if (q == NULL)
        {
            pre->next = p;
            p = p->next;
            pre->next->next = NULL;
        }
        else
        {
            p = p->next;
        }
    }
}

18.1.10已知顺序表L，编写算法查找值为Key的元素，若找到则输出其位置i(1<=i<=L.length)，否则输出0作为标志。

/**@gdr
 * 线性表的顺序存储结构如下
 * 
 * */
#define MaxSize = 线性表可能达到的长度
typedef struct 
{
    ElemType elem[MaxSize];/* 线性表占用的数组空间 */
    int length;/* 记录顺序表的长度 */
}SeqList;


//answer---------
void search_key(SeqList L, ElemType key)
{
    bool flag = 0;
    for (int i = 0; i < L.length; i++)
    {
        if (L.elem[i] == key)
        {
            flag = 1;
            printf(“% d\n”, i);
        }
    }
    If(flag == 0) printf(“0”);
}

17.1.15已知顺序表L中的数据元素按递增有序排列。编写算法，删除该顺序表中的所有值大于k1且小于k2的元素(k1≤k2)。


typedef struct
{
    ElemType data[maxsize];
    int length;
} SqList;
void Del_k1_k2(SqList &L, ElemType k1, ElemType k2)
{
    for (int i = 0; i < L.length;)
    {
        if (L.data[i] < k2 && L.data[i] > k1)
        {
            for (int j = i; j + 1 < L.length; j++)
            {
                L.data[j] = L.data[j + 1];
            }
            L.length--;
        }
        else
        {
            i++;
        }
    }
}

17.2.15 已知两个带头结点的单向循环链表，LA和LB分别是链表的头指针，LA=(a1,a2…,am),LB=(b1,b2…,bn)。编写算法，将LA和LB合并成一个单向循环链表LC=(a1,a2…,am,b1,b2…,bn)。

LinkList merge(LinkList la, LinkList lb)
{
    LNode *lc = la;
    LNode *p = la;
    while (p->next != la)
        p = p->next;
    p->next = lb;
    p = lb;
    while (p->next != lb)
        p = p->next;
    p->next = la;
    return lc;
}

18.2.10已知两个带头结点的单向循环链表RA和RB，RA和RB分别是链表的尾指针。编写算法，将表RB连接到表RA后，使它们合并成一个单向循环链表。若RA=(a1,a2…,am),RB=(b1,b2…,bn)，则合并后的单向循环链表RC=(a1,a2…,am,b1,b2…,bn)。

/**@gdr
 * 单向循环链表的存储结构如下
 * 
 * */
typedef struct Node
{
    int data; /* 线性表占用的数组空间 */
    struct Node *next;
} Node, *LinkList; //LinkList为结构指针类型

// answer-------------------

LinkList merge(LinkList RA, LinkList RB)
{
    LinkList RC = RA->next;
    LinkList p = RB->next;
    RB->next = RA->next;
    RA->next = p;
    return RC;
}

16.1.15 有两个单链表LA和LB，其元素均为非递减有序排列，编写算法，将它们合并成一个单链表LC，要求LC也是非递减有序排列。(要求：新表LC利用原表的存储空间)。

LinkList MergeList(LinkList &la, LinkList &lb)
{
    LNode *r, *pa = la->next, *pb = lb->next;
    la->next = NULL;
    while (pa && pb)
    {
        if (pa->data < pb->data)
        {
            r = pa->next;
            pa->next = la->next;
            la->next = pa;
            pa = r;
        }
        else
        {
            r = pb->next;
            pb->next = la->next;
            la->next = pb;
            pb = r;
        }
    }
    if (pa)
        pb = pa;
    while (pb)
    {
        r = pb->next;
        pb->next = la->next;
        la->next = pb;
        pb = r;
    }
    //注:采用头插法，此时得到的链表是递减序列，
    //而题目要求非递减序列，需要再逆置一遍
    LNode *p = la->next;
    la->next = NULL;
    while (p)
    {
        r = p->next;
        p->next = la->next;
        la->next = p;
        p = r;
    }
    return la;
}

16.2.15 已知一个顺序表LA,并且顺序表的数据域是整数类型，编写算法计算所有数据的平均值。

typedef struct
{
    int data[maxn];
    int length;
} SeqList;

float average(SeqList L)
{
    int sum = 0;
    for (int i = 0; i < L.length; i++)
    {
        sum += L.data[i];
    }
    return (float)sum / L.length;
}

15.1.15已知带头结点的单链表H，并且链表的数据域是整数类型，编写算法删除该单链表中值是奇数的结点。

void Del_odd(LinkList &H)
{
    LNode *p = H->next, *r = H;
    while (p)
    {
        if (p->data % 2 == 1)
        {
            r->next = p->next;
            p = r->next;
        }
        else
        {
            r = p;
            p = p->next;
        }
    }
}

15.2.15 已知长度为n的线性表A采用顺序存储结构，编写算法将A中所有的非零元素依次移到线性表A的前端。

typedef struct
{
    int data[maxn];
    int length;
} SeqList;

void move_0(SeqList &L)
{
    for (int i = 0; i < L.length; i++)
    {
        if (L.data[i] == 0)
        {
            for (int j = i + 1; j < L.length; j++)
            {
                if (L.data[j] != 0)
                {
                    L.data[i] = L.data[j];
                    L.data[j] = 0;
                    break;
                }
            }
        }
    }
}
祁连之子
关注
  • 0
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用单链表实现插入排序
02-28
作为数据结构的基础，单链表，它的基本练习就是排序了，本文详细地给出其代码，供参考。
C语言实现带头结点的链表的创建、查找、插入、删除操作
01-20
本文实例讲述了C语言实现带头结点的链表的创建、查找、插入、删除操作。是数据结构中链表部分的基础操作。分享给大家供大家参考。具体方法如下： #include #include typedef struct node { int data; struct ...
【数据结构】第2章 线性表 单链表整理
wwr's study notes
08-13 728
啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊
C++实现单链表操作
weixin_45883188的博客
12-16 933
1、任务描述： 编写函数，实现输入一组元素，建立一个带头结点的单链表；对该链表进行非递减排序；实现在非递减有序链表中删除值为x的结点； 2、亮点： ①输入利用cin的返回值来判断(想要结束的时候输入ctrl+Z) while（cin>>num） ②每个函数在执行前都会判断链表是否为空，增强了实用性 3、运行情况： 4、源代码： #include <iostream> #define LinkedListType int using namespace std; class
数据结构线性表1-3
chaichai126的博客
10-04 546
数据结构线性表作业错误记录
单链表的归并
w.here的CSDN
03-18 585
Description假设两个按元素值非递减有序排列的线性表A和B，均以单链表作为存储结构，试编写程序，将A表和B表归并成一个按元素值非递增有序排列的线性表C，并要求利用原表（即A表和B表的）结点空间存放表C。Input第一行输入两个正整数m,n(m,n&lt;=100),用空格分开，分别表示线性表A和B中元素个数，其后两行分别输入单链表A和B。Output输出单链表C。Sample Input ...
数据结构-单链表操作实践
快乐的小小程序猿
09-22 1134
数据结构-单链表操作实践 1. 编写函数，实现输入一组元素，建立一个带头结点的单链表 #include <iostream> #include <malloc.h> using namespace std; /** * 定义结点类型结构体，有一个data域和一个next域 */ typedef struct LNode { int data; struct LNode* next; }LNode, * LinkList; /** * 初始化，生成带有头结点的单链表 *
直接插入排序——对单链表进行非递减排序（带头结点）c语言实现
sw520lkm的博客
09-09 3023
直接插入排序——对单链表进行非递减排序（带头结点）c语言实现 /*************************** * author：vivi * date: 19-09-09 ****************************/ #include <stdio.h> #include <stdlib.h> // function：单链表递增直接插入排序 ...
带头结点的单链表，采用直接插入排序的方法，按照非递减排序
CosmosSeed的博客
12-04 5533
直接插入排序的思想，就是先默认第一个元素是排序好的，在顺序表中，从后面往前依次进行比较，从而进行排序。但是在单链表中，从后面遍历的话，找结点的前驱非常困难。故需要设一指针，从头进行遍历。 代码如下： void Sort(LinkNode *&amp;L) { LinkNode *p,*pre,*q; p=L-&gt;next-&gt;next; ///p指向L的第二个...
数据结构——线性表链式表示和实现（1）
程序员的修养
02-20 452
本文所有代码均为伪码，仅阐述算法基本思想——《数据结构》清华大学出版社 - 算法1 带有头结点的单链表的基本操作 struct LNode{ ElemType data; LNode *next; }LNode, *LinkList; // 构造一个空的线性表L void InitList(LinkList &L){ L=(LinkList)malloc(si
递增排序，递减排序，非递减排序，非递增排序
weixin_75202470的博客
08-30 1515
递增排序，递减排序，非递减排序，非递增排序的定义
单链表的排序操作
qq_45917176的博客
06-30 6721
数据结构--单链表的排序操作
JavaScript数据结构与算法之链表
11-26
(有C语言基础的可能比较好理解)。 使用链表结构可以克服数组需要预先知道数据大小的缺点(C语言的数组需要预先定义长度)，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。 接下来就是介绍两种常见的...
C语言中的一些算法和面试题
03-29
1. 数据结构算法:如链表、栈、队列、树、哈希表等经典数据结构的实现和相关算法,如排序、查找、遍历等。 2. 字符串处理:字符串的基本操作、模式匹配、字符串编码等。 3. 数值计算:大数运算、进制转换、数值处理等...
C语言经典算法100例.rar
09-09
C语言的经典算法。 第一篇　基础与提高 　实例1利用库函数编写基本显示程序 　实例2变量属性 　实例3运算符与类型 　实例4关于程序结构 　实例5显示函数曲线图 　实例6二分法选代的应用 　实例7多变的立方体 　实例8...
C语言解字符串逆序和单向链表逆序问题的代码示例
09-02
主要介绍了C语言解字符串逆序和单向链表逆序问题的代码示例,求逆序也是考研和面试中的基础算法题类型,需要的朋友可以参考下
99-智慧园区数据平台方案.pptx
04-27
99-智慧园区数据平台方案.pptx
node-v12.11.1-x86.msi
最新发布
04-27
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
c语言链表初学者在哪学
03-14
初学者可以通过以下途径学习C语言链表： 1. 在线教程和学习网站：有很多免费的在线教程和学习网站提供C语言链表的学习资源，比如CSDN、菜鸟教程、LeetCode等。这些网站通常提供了详细的教程、示例代码和练习题，帮助初学者理解链表的概念和基本操作。 2. 书籍：有一些经典的C语言教材专门介绍链表的实现和应用，比如《C程序设计语言》、《数据结构与算法分析》等。这些书籍通常从基础概念开始介绍，逐步深入，帮助初学者建立起对链表的理解和应用能力。 3. 视频教程：有一些优质的视频教程也可以帮助初学者更直观地理解链表的概念和操作。可以在一些在线教育平台或视频网站上搜索相关的C语言链表教程，如B站、慕课网等。 4. 实践项目：通过实践项目来学习链表是一种非常有效的方式。可以尝试自己实现链表的基本操作，如插入、删除、查找等，并应用到一些具体问题中，如链表的逆序、链表的合并等。这样可以加深对链表的理解，并提升编程能力。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值