考研——线性表算法大题整理(二)

已于 2023-10-07 11:11:07 修改
阅读量275 收藏 3
点赞数 6
分类专栏： 考研——数据结构 文章标签： 算法 考研
于 2023-10-05 19:50:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jayna_Su/article/details/133377580
版权

文章目录

亿点说明：对于要用带头结点或者不带头结点的单链表问题，题目只要不特别指明，默认都是对带头结点的单链表进行操作

一、两个单链表的操作问题

1. A、B递增，求C = A ∪ B (并集，归并)

无题目链接

(1) C递增
// 利用尾插法将两个递增单链表归并
LNode* merge(LNode* A, LNode* B)
{
    auto dummy = new LNode(-1);
    auto cur = dummy;
    A = A->next, B = B->next;
    while (A && B)
    {
        if (A->data <= B->data)
        {
            cur->next = A;
            A = A->next;
            cur = cur->next;
        }
        else
        {
            cur->next =B;
            B = B->next;
            cur = cur->next;
        }
    }
    if (A) cur->next = A;
    else cur->next = B;
    return dummy;
}
(2) C递减
// 利用头插法将两个递增单链表归并
LNode* merge(LNode* A, LNode* B)
{
    auto dummy = new LNode(-1);
    dummy->next = NULL;
    A = A->next, B = B->next;
    while (A && B)
    {
        if (A->data <= B->data)
        {
            auto s = A;
            A = A->next;	// 不可以放下面两句后面
            s->next = dummy->next;
            dummy->next = s;
        }
        else
        {
            auto s = B;
            B = B->next;	// 不可以放下面两句后面
            s->next = dummy->next;
            dummy->next = s;
        }
    }
    while (A)
    {
        auto s = A;
        A = A->next;
        s->next = dummy->next;
        dummy->next = s;
    }
    while (B)
    {
        auto s = B;
        B = B->next;
        s->next = dummy->next;
        dummy->next = s;
    }
    return dummy;
}

2. A、B递增，求A = A - B (差集)，A递增

无题目链接

LNode* difference(LNode* A, LNode* B)
{
    auto p = A->next, q = B->next;
    auto pre = A;
    while (p && q)
    {
        if (p->data < q->data)
        {
            pre = p;
            p = p->next;
        }
        else if (p->data > q->data)
            q = q->next;
        else
        {
            auto r = p;
            pre->next = r->next;
            p = p->next;
            free(r);
        }
    }
    return A;
}

3. A、B递增，求A = A ∩ B (交集)，A递增

无题目链接

LNode* converge(LNode* A, LNode* B)
{
    auto p = A->next, q = B->next;
    auto pre = A;
    while (p && q)
    {
        if (p->data < q->data)
        {
            auto r = p;
            pre->next = r->next;
            p = p->next;
            free(r);
        }
        else if (p->data > q->data)
            q = q->next;
        else
        {
            pre = p;
            p = p->next;
            q = q->next;
        }
    }
    while (p)
    {
        auto r = p;
        pre->next = r->next;
        p = p->next;
        free(r);
    }
    return A;
}

4. A、B递增有序，公共元素产生单链表C(与上一题求∩相像)

无题目链接

void get_common(LNode* A, LNode* B)
{
    auto C = new LNode(-1);
    auto cur = C;
    auto p = A->next, q = B->next;
    while (p && q)
    {
        if (p->data < q->data) p = p->next;
        else if (p->data > q->data) q = q->next;
        else
        {
            auto s = new LNode(p->data);
            cur->next = s;
            cur = cur->next;
            p = p->next;
            q = q->next;
        }
    }
    cur->next = NULL;
}

5. A = A + B (分解)

(1) A中含有序号为奇数的元素，B中含有序号为偶数的元素

无题目链接

LNode* B = new LNode(-1);
void split(LNode* &A)
{
    if (!A->next) return;
    auto cur = B;
    auto pre = A, p = A->next;
    int cnt = 0;
    while (p)
    {
        cnt ++;
        if (cnt % 2)
        {
            pre = p;
            p = p->next;
        }
        else
        {
            cur->next = p;
            cur = cur->next;
            pre->next = p->next;
            p = p->next;
            // 或者这样写
            // auto r = p;
            // pre->next = p->next;
            // p = p->next;
            // cur->next = r;
            // cur = cur->next;
        }
    }
    cur->next = NULL;
}
(2) A中含有data域为奇数的元素，B中含有data域为偶数的元素，且保持相对顺序

无题目链接

LNode* B = new LNode(-1);
void split(LNode* &A)
{
    if (!A->next) return;
    auto cur = B;
    auto pre = A, p = A->next;
    while (p)
    {
        if (p->data % 2)
        {
            pre = p;
            p = p->next;
        }
        else
        {
            cur->next = p;
            cur = cur->next;
            pre->next = p->next;
            p = p->next;
            // 或者这样写
            // auto r = p;
            // pre->next = p->next;
            // p = p->next;
            // cur->next = r;
            // cur = cur->next;
        }
    }
    cur->next = NULL;
}

6. 找出A和B的公共结点

题目链接

LNode *findFirstCommonNode(LNode* A, LNode* B) {
        auto p = A->next, q = B->next;
        while (p != q)
        {
            if (p) p = p->next;
            else p = B->next;
            
            if (q) q = q->next;
            else q = A->next;
        }
        return p;
    }

二、逆置(反转)问题

1. 将单链表L就地逆置

题目链接

void reverse(LNode* &L)
{
    auto p = L->next;
    L->next = NULL;
    while (p)
    {
        // 头插法建立新的链表
        auto q = p->next;
        p->next = L->next;
        L->next = p;
        p = q;
    }
}

2. 从尾到头反向输出结点值

无题目链接

// 方法1：反转后遍历输出
// 方法2：递归
void print(LNode* L)
{
    if (L)
    {
        print(L->next);
        cout << L->data << ' ';
    }
}

三、去重问题

1. 去掉递增有序的单链表L中数值相同的结点

题目链接

LNode* deleteDuplicates(LNode* L) {
        if (!L->next) return L;
        auto pre = L, p = L->next;
        while (p && p->next)
        {
            if (p->next->val == p->val)
            {
                int tmp = p->val;
                while (p && p->val == tmp) p = p->next;
                pre->next = p;
            }
            else
            {
                pre = p;
                p = p->next;
            }
        }
        return L;
    }

2. 去掉单链表中绝对值相等的结点

题目链接

bool st[10010] = {};
// bool st[10010];
    LNode* filterList(LNode* L)
    {
        // memset(st, false, sizeof st);
        auto pre = L, p = L->next;
        while (p)
        {
            if (st[abs(p->val)])
            {
                auto r = p;
                pre->next = p->next;
                p = p->next;
                free(r);
            }
            else
            {
                st[abs(p->val)] = true;
                pre = p;
                p = p->next;
            }
        }
        return L;
    }

四、删除问题

1. 递归删除不带头结点的单链表L中所有值为x的节点

无题目链接

void delete_x(LNode* &L, ElemType x)
{
    if (!L) return;
    if (L->data == x)
    {
        auto p = L;
        L = L->next;
        free(p);
        delete_x(L, x);
    }
    else delete_x(L, x);
}

2. 删除单链表L中所有值为x的结点并释放空间

无题目链接

void delete_x(LNode* &L, ElemType x)
{
    // if (!L->next) return;
    auto pre = L, p = L->next;
    while (p)
    {
        if (p->data == x)
        {
            auto r = p;
            pre->next = p->next;
            p = p->next;
            free(r);
        }
        else
        {
            pre = p;
            p = p->next;
        }
    }
}

3. 删除单链表L中最小值结点(假设唯一)

无题目链接

void delete_min(LNode* &L)
{
    // if (!L->next) return;
    auto pre = L, p = L->next;
    auto minpre = pre, minp = p;
    while (p)
    {
        if (p->data < minp->data)
        {
            minpre = pre;
            minp = p;
        }
        pre = p;
        p = p->next;
    }
    minpre->next = minp->next;
    free(minp);
}

4. 删除单链表L中所有值介于x和y之间的元素的结点

无题目链接

void delete_xtoy(LNode* &L, ElemType x, ElemType y)
{
    if (!L->next) return;
    auto pre = L, p = L->next;
    while (p)
    {
        if (p->data > x && p->data < y)
        {
            auto r = p;
            pre->next = p->next;
            p = p->next;
            free(r);
        }
        else
        {
            pre = p;
            p = p->next;
        }
    }
}

5. 递增输出单链表L中各结点的数据元素并释放空间

无题目链接

// 方法1
void dele_print(LNode* &L)
{
    while (L->next)
    {
        auto pre = L, p = L->next;
        auto minpre = pre, minp = p;
        while (p)
        {
            if (p->data < minp->data)
            {
                minpre = pre;
                minp = p;
            }
            pre = p;
            p = p->next;
        }
        cout << minp->data << ' ';
        minpre->next = minp->next;
        free(minp);
    }
    free(L);
}
// 方法2：王道书上给的，个人感觉没方法1好用
void dele_print(LNode* &L)
{
    while (L->next)
    {
        auto minpre = L;
        auto p = L->next;
        while (p->next)
        {
            if (p->next->data < minpre->next->data)
                minpre = p;
            p = p->next;
        }
        cour << minpre->next->data << ' ';
        auto r = minpre->next;
        minpre->next = r->next;
        free(r);
    }
    free(L);
}

五、排序问题

1. 插入排序：使单链表中元素递增有序

无题目链接

void insert_sort(LNode* L)
{
    if (!L->next) return;
    auto p = L->next, r = p->next;
    p->next = NULL;
    p = r;
    while (p)
    {
        r = p->next;
        auto pre = L;
        while (pre->next && pre->next->data < p->data)
            pre = pre->next;
        p->next = pre->next;
        pre->next = p;
        p = r;
    }
}

2. 快速排序：使单链表中元素递增有序

LNode* quickSortList(LNode* head) {
        if (!head->next) return head;
        quick_sort(head->next, NULL);
        return head;
    }
    
    void quick_sort(LNode *head, LNode *tail)
    {
        if (head != tail)
        {
            // 定义参考元素x，永远取头指针指向的元素
            int x = head->data;
            // 双指针操作，p之前(不包括p)都是小于等于x的，
            // p——q(包括p)都是大于等于x的
            // p指针作用: 分段用
            // q指针作用: 遍历用，检索当前元素dataue与x的关系，
            // 若dataue比x小，则扔p前面
            LNode *p = head, *q = head->next;
            while (q != tail)
            {
                if (q->data < x)
                {
                    p = p->next;
                    swap(p->data, q->data);
                }
                q = q->next;
            }
            // 遍历完之后，重置参考元素x的位置，
            // 即依旧在头指针指向的位置，然后开始递归两段
            if (p != head) swap(head->data, p->data);
            quick_sort(head, p);
            quick_sort(p->next, tail);
        }
    }

最后——杂七杂八

1. 判断单链表L是否有环

题目链接

/*
以下文字来自题目链接中牛客官方给的解析：
step 1：设置快慢两个指针，初始都指向链表头。
step 2：遍历链表，快指针每次走两步，慢指针每次走一步。
step 3：如果快指针到了链表末尾，说明没有环，因为它每次走两步，
        所以要验证连续两步是否为NULL。
step 4：如果链表有环，那快慢双指针会在环内循环，因为快指针每次走两步，
        因此快指针会在环内追到慢指针，二者相遇就代表有环
*/
bool has_cycle(LNode *head) {
        auto fast = head, slow = head;
        while (fast && fast->next)
        {
            fast = fast->next->next;
            slow = slow->next;
            if (fast == slow) return true;
        }
        return false;
    }

2. 查找单链表L中倒数第k个位置上的结点

题目链接

LNode* FindKthToTail(LNode* head, int k)
{
    if (!head->next) return NULL;
    int len = 0;
    for (auto i = head->next; i; i = i->next) len ++;
    int cnt = len - k + 1;
    if (k <= 0 || cnt <= 0) return NULL;
    auto p = head;
    for (int i = 0; i < cnt; i ++) p = p->next;
    return p;
}

3. 重排单链表L’ = (a1,an,a2,an-1,a3,an-2,···)

题目链接
参考我去年写的博客

// 不带头结点的反转链表
void reverse(LNode* &b)
    {
        auto c = b->next;
        b->next = NULL;
        while (c)
        {
            auto tmp = c->next;
            c->next = b;
            b = c;
            c = tmp;
        }
    }
    // 两个链表的归并
    void merge(LNode* &a, LNode* b)
    {
        while (b)
        {
            auto p = a->next, q = b->next;
            b->next = a->next;
            a->next = b;
            a = p, b = q;
        }
    }
    void rearrangedList(LNode* head) {
        if (!head->next) return;
        // 1. 对链表进行分段
        // 结点1 ~ (n + 1)/2是左半段，结点(n + 1)/2 ~ n是右半段
        int len = 0;
        for (auto i = head; i; i = i->next) len ++;
        int left = len + 1 >> 1;
        // int len = 0;
        // auto i = head;
        // while (i) i = i->next, len ++;
        // int left = len + 1 >> 1;
        
        auto a = head;
        for (int i = 1; i < left; i ++) a = a->next;
        // auto a = head;
        // while (-- left) a = a->next;
        auto b = a->next;
        a->next = NULL;
        // 2. 反转右边那段链表
        reverse(b);
        // 3. 合并链表，即将b归并入主链表中
        merge(head, b);
    }
晴天飞鱼
关注
  • 6
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
考研题目 第二章线性表
懒王子的专栏
12-02 9946
导读：  　　一 选择题 　　1．下述哪一条是顺序存储结构的优点？（ ）【北方交通大学2001 一、4（2分）】 　　A．存储密度大 B．插入运算方便 C．删除运算方便 D．可方便地用于各种逻辑结构的存储表示 　　2．下面关于线性表的叙述中，错误的是哪一个？（ ）【北方交通大学2001 一、14（2分）】 　　A．线性表采用顺序存储，必须占用一片连续的存储单元。 　　B．线性表采用顺序存储
数据结构算法复习1：线性表相关考点2
Joye-joy的博客
11-06 444
考纲要求：在算法实现方面要求，能够根据实际问题的需求来决定采用何种存储结构并给出具体的算法，如：插入、删除满足条件的链表节点，在链表上排序等。 1，设计一个算法删除单链表L中第一个值为x的结点。 2，设计一个算法判定单链表L的所有结点值是否是递增的。 ...
考研——线性表算法大题整理(一)
Jayna_Su的博客
09-28 170
整理线性表的基本算法
数据结构-基础算法系列——线性表算法集合
yaoguaiba579567的博客
10-08 383
  此系列以考研的408数据结构为基础，挑选出了线性表中的27个基础算法，包括概述算法原理，C语言实现和Java语言实现三块内容，希望对想要扎实数据结构基础的朋友有帮助。
东北大学——考研初试——计算机842——线性表编程题
virgilwjj
05-31 314
顺序表的定义 typedef struct SqList { int data[Max]; int length; }SqList; 需要掌握的基本操作 插入 先从后往前挪，给插入地方留位置 删除 从前往后挪，覆盖删除的地方 修改 查找 交换 快排模板 void func(int A[], int low, int high) { if(low >= high) { return; } int temp = A[low];
考研篇——排序算法总结
d1006913064的博客
08-14 438
算法思想：从后往前（或从前往后）两两比较相邻元素的值，若为逆序（即A[i-1]>A[i]），则交换它们，直到序列比较完。i++) { //依次将A[2]~A[n]插入前面的已排序序列。//当low>high时，折半查找停止，应将[low,i-1]内的元素全部右移，并将A[0]复制到low所指位置。最坏情况：初始序列为逆序，比较次数为n(n-1)/2，移动次数为3n(n-1)/2，时间复杂度为O(n²)if (A[i]
数据结构实战——线性表（顺序表、链表——单链表、双链表、循环链表、静态链表）
wypds的博客
04-09 1015
数据结构线性表实战 顺序表、单链表（头插法、尾插法、双链表、循环链表、静态链表） 一、什么是线性表 二、顺序表 三、链表 一、单链表 1、头插法 2、尾插法 二、双链表 三、循环链表 四、静态链表 前言 提示：这里可以添加本文要记录的大概内容： 数据结构——线性表 提示：以下是本篇文章正文内容，下面案例可供参考 一、什么是线性表 线性表是具有相同数据类型的n(>=0)个数据元素的有限序列，n为表长，n=0时线性表是一个空表。若用L命名线性表，一般表示为：L=(a[1]，a[2]，a[3]，.
数据结构——线性表学习总结1（顺序表）
Star_jiang的博客
03-08 735
前言：我是为了考研来学习的数据结构，作为计算机专业基础课，它是当值无愧的一块难啃的硬骨头，对于我这个跨专业的考生学起来非常的难受；前面发的C学习的博客是为了学习这里的铺垫，毕竟不熟悉结构体、指针、还有malloc()等函数简直就不是到那些代码写的啥。下面的总结笔记主要来自于小甲鱼老师的视频教程，我边看边暂停记笔记写代码，在博客里做一个归拢，当作一个回顾和复习（其实和预习差不多）。 一、线性表定义及...
408数据结构考研笔记——第二章线性表
qq_52189899的博客
03-17 364
408数据结构考研笔记整理，笔记+课后习题，习题是王道书的课后习题，整理主要用于个人学习归纳，侵删
算法练习题13——除自身以外数组的乘积（动态规划）
hello77的blogggg 祝你得偿所愿
09-04 515
给你一个整数数组nums，返回 数组answer，其中answer[i]等于nums中除nums[i]之外其余各元素的乘积。
【算法】C++贪心算法解题（单调递增数字、坏了的计算器、合并区间）
卜及中的博客
09-03 604
【算法】贪心算法解析：基本概念、策略证明与代码例题演示。
LeetCode LCR088.使用最小花费爬楼梯
m0_63816268的博客
09-03 1043
动态规划
树状数组记录
最新发布
volcan的博客
09-06 456
树状数组（Fenwick Tree）是一种用于维护数组前缀和的数据结构，支持高效的单点更新和区间查询操作。它的查询和更新时间复杂度为Ologn，适用于需要频繁更新和查询的场景。
P7492 [传智杯 #3 决赛] 序列
summ1ts的博客
09-03 408
的数组，表示区间内所有数的二进制表示下某一位是否为1，但这太难写，最后无奈去看官方题解，发现只要维护区间所有数的按位与和And，如果(And&k)==k的话那就不用修改了。那样的话这个题就很简单了，维护最大子段和可以见。一道类似势能线段树的题，区间按位或上k，不满足区间可合并的性质，只能暴力的单点修改。，如果我们能找到一个方法，能够判定区间里的数，或上k后是否有改变，就可以避免。至于时间复杂度用类似势能分析的方法分析一波就行了，时间复杂度。我一开始想的是线段树里维护一个。但是考虑按位或的性质，
【滑动窗口】将 x 减到 0 的最小操作数
qq_42150700的博客
09-03 1071
当然也是没有必要的, 因为你要求区间里面的和至少要 target. 你刚刚区间, 就恰好是 >= target 的边界. 也就是说, 左边的值应该都是 <= target 的, 也就是下面这个图蓝色区间的和, 肯定是小于 target 的. 因为是正好加了右侧指针的值才 >= target 停下的。更新结果: 结果的更新, 可以说是最好写的一个部分, 你要什么, 你就在什么时候更新. 我们要的是 sum = target 的长度, 那我们就在 sum = target 的时候更新长度不就行了?
算法训练营|图论第8天 拓扑排序 dijkstra
qq_53125539的博客
09-02 517
拓扑排序。
备战秋招60天算法挑战，Day30
溜达虎的博客
09-03 420
给你一个字符串 和一个字符串列表 作为字典。请你判断是否可以利用字典中出现的单词拼接出 。注意：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。举个例子： 视频题解 单词拆分 思路来源 思路来源 知识回顾 动态规划是一种通过将原问题分解为子问题来求解复杂问题的算法思想。它通常用于求解最优化问题，例如最长公共子序列、背包问题等。动态规划的核心思想是将原问题分解为若干个子问题，通过求解子问题的最优解推导出原问题的最优解。可以通过两点来判断一个问题能不能通过动态规划来解，一是该问题是否存在递
循环结构程序
BlueBachke的博客
09-03 474
循环结构的基础知识
苏州大学历年考研算法题解析：负数前置，奇偶分组
"苏州大学2005-2019年考研算法题，涵盖40多道数据结构算法，包括单链表、双链表、顺序表等结构，重点是链表操作和线性表的排序。" 这篇文档是关于苏州大学计算机专业考研的数据结构算法历年真题集合，主要涉及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值