王道链表编程题目笔记

最新推荐文章于 2022-11-28 23:20:38 发布
最新推荐文章于 2022-11-28 23:20:38 发布
阅读量351 收藏 4
点赞数
分类专栏： 卑微考研鼠 文章标签： 链表 数据结构 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shshuahw/article/details/124632257
版权

一.删除链表中所有值为x的节点

1.使用递归，无头结点

LinkList deleteAllX(LinkList L,int x) {
	if (!L) return NULL;
	if (L->data == x) {
		LNode* p = L;
		L = deleteAllX(L->next, x);
		delete(p);
		return L;
	}
	else {
		LinkList result;
		result = L;
		L->next = deleteAllX(L->next, x);
		return result;
	}
}

2.有头节点

void deleteAllX(LinkList& L,int x) {
	LNode* p1 = L;
	LNode* p2 = L->next;
	while (p2) {
		if (p2->data == x) {
			LNode* p = p2;
			p1->next = p2->next;
			p2 = p2->next;
			delete(p);
		}
		else {
			p1 = p2;
			p2 = p2->next;
		}
	}
}

二.链表反向

方法一：头插法

​ 在**O（1）**的空间复杂度内实现链表的反向输出

​ 使用方法：将链表节点依次摘下使用头插法插入到头节点之后。

​ 注意点：不需要创建新的头节点和头指针，直接在原链表上进行操作。

void reverse(LinkList &L) {
	LNode* p1 = L->next;
	L->next = NULL;
	while (p1) {
		LNode* p2 = p1->next;
		p1->next = L->next;
		L->next = p1;
		p1 = p2;
	}
}

方法二：使用指针r防止断链

void reverse(LinkList &L) {
	//pre节点以及之前的节点的指针都已指向原前驱节点，p指向当前需要处理的节点，r用于保存后面的链表
	LNode* pre = L->next;
	LNode* p = pre->next;
	LNode* r = p->next;
	pre->next = NULL;
	while (r) {
		p->next = pre;
		pre = p;
		p = r;
		r = r->next;
	}
	p->next = pre;
	L->next = p;
}

三.删除链表中最小元素

void deleteMin(LinkList& L) {
	if (!L->next) {
		return;
	}
	LNode* p = L->next;
	//当前最小值元素
	int minVal = L->next->data;
	//指向具有最小值的元素的前一个元素
	LNode* minP = L;
	while (p->next) {
		LNode* p1 = p->next;
		if (p1->data < minVal) {
			minVal = p1->data;
			minP = p;
		}
		p = p->next;
	}
	//删除操作
	p = minP->next;
	minP->next = p->next;
	delete(p);
}

四.链表插入排序

注意点：

①当执行操作p->next=…时，要使用指针r将后续链表保存，防止断链。

②链表和顺序表插入排序不同处在于：先创建了一个只含一个元素的链表，将原链表中元素插入其中。

​ 原因是：如果直接将链表结点插入原链表，当链表最尾端结点被插入前面，NULL将丢失。

//错误示范
LNode* p = L->next->next;
//循环插入
while (p) {
    LNode* r = p->next;
    LNode* pre = L;
    while (pre->next->data <= p->data && pre->next != p) {
        pre = pre->next;
    }
    p->next = pre->next;
    pre->next = p;
    p = r;
}

正确答案：

//使用直接插入排序法对链表进行排序
void sort(LinkList& L) {
	//先构成一个只含一个元素的单链表
	LNode* p = L->next->next;
	L->next->next = NULL;
	//循环插入
	while (p) {
		LNode* r = p->next;
		LNode* pre = L;
		while (pre->next->data <= p->data && pre->next != NULL) {
			pre = pre->next;
		}
		p->next = pre->next;
		pre->next = p;
		p = r;
	}
}

五.寻找两个链表的公共部分

LNode* pub(LinkList L1,LinkList L2) {
    int count1 = length(L1);
    int count2 = length(L2);
    if (count1 > count2) {
        int contrast = count1 - count2;
        LNode* p1 = L1->next;
        LNode* p2 = L2->next;
        for (int i = 1; i <= contrast; ++i) {
            p1 = p1->next;
        }
        while (p1 && p2) {
            if (p1 == p2) {
                return p1;
            }
        }
    }
    else {
        int contrast = count2 - count1;
        LNode* p1 = L1->next;
        LNode* p2 = L2->next;
        for (int i = 1; i <= contrast; ++i) {
            p2 = p2->next;
        }
        while (p1 && p2) {
            if (p1 == p2) {
                return p1;
            }
        }
    }
    return NULL;
}

六.将链表按照奇偶数分割

1.原题

题目：将一个带有头节点的链表A分解成两个带头结点的链表A，B，其中A保存序号为奇数的结点，B保存序号为偶数的结点。保持两个链表中元素相对顺序不变。

我的解法：

void depart(LinkList& A, LinkList& B) {
    //构造B的头结点
    B = new LNode;
    B->data = -1;
    B->next = NULL;
    LNode* p = A; //p用于保存A当前需要操作节点的前驱节点
    LNode* tail = B; //tail指向B的尾部元素
    LNode* r; //r用于防止A断链
    for (int i = 1; p->next; ++i) {
        if (i % 2 == 0) {//序号为偶数
            r = p->next->next;
            tail->next = p->next;
            tail = tail->next;
            p->next->next = NULL;
            p->next = r;
        }
        else {
            p = p->next;
        }
    }
}

注意：①p表示操作结点的前驱结点，方便将p->next插入B链表后，将p和原先的p->next->next连接上。

②使用r指针防止A断链

标准答案：先初始化两个链表A，B（A->next=NULL,B->next=NULL,然后将结点按奇偶性插入A或B表中，此方法无需对操作结点前一个结点后后一个结点进行连接）。

2.变式

题目：和1中一样，但是B中的元素要求和原来的顺序相反。

方法：对B使用头插法。

void depart(LinkList& A, LinkList& B) {
    B = new LNode;
    B->data = -1;
    B->next = NULL;
    LNode* p = A; //p用于保存A当前需要操作节点的前驱节点
    LNode* r;
    for (int i = 1; p->next; ++i) {
        if (i % 2 == 0) { //操作结点序号为偶数
            r = p->next->next;
            p->next->next = B->next;
            B->next = p->next;
            p->next = r;
        }
        else {
            p = p->next;
        }
    }
}

七.删除链表中重复元素

1.有序链表

void delDuplicate(LinkList& L) {
	if (!L->next || !L->next->next) { //若链表为空或者只含一个有效结点，直接返回
		return;
	}
	LNode* p = L->next;
	LNode* q = L->next->next;
	LNode* temp;
	while (q) {
		if (p->data == q->data) {
			temp = q;
			p->next = q->next;
			q = p->next;
			delete(temp);
		}
		else {
			p = q;
			q = q->next;
		}
	}
}

2.无序链表

​ 高时间复杂度

void deleteDuplicate(LinkList L) {
    LNode* p = L;
    while (p->next) {
        for (LNode* q = L->next; q != p->next && q; q = q->next) {
            if (q->data == p->next->data) {
                LNode* r = p->next;
                p->next = p->next->next;
                delete(r);
                break;
            }
        }
        p = p->next;
    }
}

​ 空间换时间法

八.链表合成

1.将两个升序链表L1和L2合成为一个降序链表

void merge(LinkList& L1, LinkList& L2) { //使用L1存放归并后的链表
	LNode* p1 = L1->next;
	LNode* p2 = L2->next;
	LNode* r;
	L1->next = NULL;
	while (p1 || p2) {
		if (!p2 || p1->data <= p2->data) {
			r = p1->next;
			p1->next = L1->next;
			L1->next = p1;
			p1 = r;
		}
		else if (!p1 || p1->data > p2->data) {
			r = p2->next;
			p2->next = L1->next;
			L1->next = p2;
			p2 = r;
		}
	}
    delete(L2);//最后不要忘记释放L2的内存空间
}

2.将两个链表公共元素合成在一个链表中

​ 例如：1，2，3，3，4，5和1，2，2，5

​ 合成为1，1，2，2，2，5

void merge(LinkList& L1, LinkList& L2) { //使用L1存放归并后的链表
    LNode* p1 = L1->next;
    LNode* p2 = L2->next;
    LNode* r;
    int temp = -1;//保存刚刚插入的值，这个值在链表中不可能是-1
    L1->next = NULL;
    while (p1 || p2) {
        if (p1 && p1->data == temp) {
            r = p1->next;
            p1->next = L1->next;
            L1->next = p1;
            p1 = r;
        }
        else if (p2 && p2->data == temp) {
            r = p2->next;
            p2->next = L1->next;
            L1->next = p2;
            p2 = r;
        }
        else if (p1 && p2) {
            if (p1->data < p2->data) {
                p1 = p1->next;
            }
            else if (p1->data > p2->data) {
                p2 = p2->next;
            }
            else if (p1->data == p2->data) {
                temp = p1->data;
            }
        }
    }
}

九.链表子串判断

1.判断sub是不是L1的子串，其中sub和L1都是链表

暴力算法：

bool subStr(LinkList L1, LinkList sub) {
    LNode* p1 = L1->next;
    for (;p1;p1=p1->next) {
        bool flag = true;
        LNode* pI1 = p1;
        LNode* pI2 = sub->next;
        while (pI1 && pI2) {
            if (pI1->data != pI2->data) {
                flag = false;
                break;
            }
            pI1 = pI1->next;
            pI2 = pI2->next;
        }
        if (!flag) {
            continue;
        }
        else {
            return true;
        }

    }
    return false;
}

十.判断双向循环链表是否对称

bool judge(LinkList L) {
	LNode* p1 = L->next;
	LNode* p2 = L->prior;
	while (p1 != p2 && p1->next != p2) {
		if (p1->data != p2->data) {
			return false;
		}
		p1 = p1->next;
		p2 = p2->prior;
	}
	return true;
}

十一.判断单链表是否存在环

​ 使用方法：快慢指针法，如果存在环，快指针一定可以追上慢指指针。慢指针速度必须设置为1。

bool judge(LinkList L) {
    LNode* fast = L->next;
    LNode* slow = L->next;
    while (fast && slow && fast->next) {
        if (fast == slow) {
            return true;
        }
        slow = slow->next;
        fast = fast->next->next;
    }
    return false;
}

十二.找到倒数第k个元素（2009统考）

​ 找到链表倒数第k个元素，输出其元素值，若不存在，返回0，存在返回1.

int find(LinkList L, int k) {
    LNode* p = L->next;
    int count = 0;
    while (p) {
        p = p->next;
        ++count;
    }
    p = L->next;
    if (k > count) {
        return false;
    }
    for (int i = 1; i <= count - k + 1; ++i) {
        p = p->next;
    }
    cout << p->data;
    return 1;
}

​ 多遍扫描获得答案，得分：10分

正确答案：设置两个指针p和q，初始时候都指向链表第一个结点，p先移动，当移动了k个节点后，q开始移动。当p移动到链表末尾时，q则移动到倒数第k个结点。

十三.2019统考真题，链表部分倒置

在这里插入图片描述

void transform(LinkList L) {
    LNode* p = L->next;
    LNode* r;
    int count;
    //统计链表的长度count
    for (count = 0; p; p = p->next) {
        count++;
    }
    p = L->next;
    LNode* p1 = L->next;
    L->next = NULL;
    
    //将链表后半部分内容以头插法插入L中
    for (int i = 1; p; ++i) {
        if (i == count / 2) {
            r = p;
            p = p->next;
            r->next = NULL;
        }
        else if (i >= count / 2 + 1) {
            r = p->next;
            p->next = L->next;
            L->next = p;
            p = r;
        }
        else {
            p = p->next;
        }
    }
    p = L->next;
    LNode* start = L;
    
    //将链表前半段内容以头插法插入L中
    while (p1) {
        r = p1->next;
        p1->next = start->next;
        start->next = p1;
        start = p1->next;
        p1 = r;
    }
}

十三.双向链表维持结点有序

原题：设头指针为L，有头结点的非循环双向链表，其每个节点有一个访问频度域freq，在链表被启用前，freq均为0.每当对链表进行一次Locate(L,x)运算时，对元素值为x的结点频度值增加1，并使链表中结点按访问频度非增顺序排列。同时最近访问的结点排在频度相同的结点前面，以使频繁访问的结点总是靠近表头。编写符合以上要求的Locate函数。返回找到的结点地址，类型为指针型。

LNode* Locate(LinkList& L, int x) {
    LNode* p = L->next;
    while (p) {
        if (p->data == x) {
            p->freq++;
            LNode* q = p;
            while (q->freq <= p->freq && q != L) { //将结点q插在结点p后面
                q = q->prior;
            }
            if (q->next != p) { //若q的下一个就是p，则不需要对结点进行移动
                //使用三个指针防止断链
                LNode* r1 = p->next, * r2 = p->prior, * r3 = q->next;
                p->next = r3;
                p->prior = q;
                q->next = p;
                r3->prior = p;
                r2->next = r1;
                if (r1) {
                    r1->prior = r2;
                }
            }
            break;
        }
        p = p->next;
    }
    return p;
}
shshuahw
关注
专栏目录
【专栏必读】王道考研408数据结构+计算机算法设计与分析万字笔记、题目题型总结、注意事项、目录导航和思维导图
快乐江湖的博客
11-23 4万+
各位老铁思维导图在我整理完笔记后会放上去的，我需要根据王道的思维导图重新再做一遍 文章目录一：有关注意事项二：关于专栏三：学习建议四：各专栏导航（各位老铁别催，质量优先）（1）第一章：绪论（2）第二章：线性表（3）第三章：栈和队列第四章：串第五章：二叉树第六章：图 首先感谢王道大大（手动比心），很用心在做了，大家可以看其中两节是否符合胃口 (王道408考研数据结构)第五章树-第三节1：二叉树遍历（先序、中序和后序） (王道408考研数据结构)第五章树-第四节2：平衡二叉树(AVL)及其旋转 一：有.
记录一次笔试编程题总结笔记
submarineas的博客
12-30 807
引言 本篇希望能记录当次笔试未清楚的几个题，解决心头之患，另外也为明年做准备。 双端队列的构造 此题好像是什么地方的原题，我在搜索上找到一篇全英的转载，所以我主要参考了最后第一篇以及第二篇我引用的那篇思路，结合自己的理解对这题进行了复盘。过程如下： 题目描述 6-7 Deque（25 point(s)） A “deque” is a data structure consisting of a list of items, on which the following operations are poss
王道第二章【链表】
qq_32863265的博客
08-28 410
1. void Delete(LNode *&L,int x) { LNode *p; //p指向待删除结点 if(L == NULL) //递归出口 return; if(L->data == x) //若L所指结点的值为x { p = L; L = L->next; free(p); Delete(L,x); //递归调用 } else ...
23王道——单链表
下次再说的博客
03-14 1491
#include<iostream>
王道数据结构经典代码题-链表
qq_43208817的博客
07-31 422
记录自己考研的过程
王道数据结构——链表、循环单链表实现
qq_42242452的博客
04-29 1508
王道考研单链表、循环单链表代码实现。
链表大总结（王道加红皮书）
最新发布
m0_46335449的博客
11-28 1430
补上了双向链表和循环链表
王道程序员求职宝典+算法笔记
04-24
《王道程序员求职宝典+算法笔记》是一本旨在帮助准备进入IT行业的程序员们提升技能、熟悉面试流程的重要参考资料。这本书结合了众多知名企业的程序员笔试和面试题目，为读者提供了全面而深入的学习路径，旨在帮助...
考研/保研机试（王道机试指南+算法笔记上机指南）
04-24
《考研/保研机试（王道机试指南+算法笔记上机指南）》这个资料集合，对于准备考研或保研的学生来说，是一份非常重要的参考资料。它涵盖了两个核心部分：《王道机试指南》和《算法笔记上机训练实战指南》，旨在帮助...
NEEPAlgorithms:《王道机试指南》和《算法笔记》（“晴神宝典”）例题题解
05-24
《王道机试指南》与《算法笔记》（“晴神宝典”）是两本在计算机科学领域，特别是编程竞赛和面试准备中备受推崇的书籍。这些书籍深入浅出地讲解了各种基础及进阶算法，帮助读者提升解决实际问题的能力。...
王道数据结构的所有选择题
10-29
考研数据结构总结
2019王道考研数据结构勘误
05-04
2019王道论坛数据结构最新版勘误 修订错误统计表
王道数据结构(链表)
Admnbl的博客
10-02 2039
链表定义 typdef struct Node{ ElemType data; struct Node *next; }Node,*LinkList; 1.删除不带头结点的单链表中值为x的结点用递归 void delX（LinkList &amp;L,ElemType x){ Node *p; if(L==null) return ; ...
2020年王道数据结构（第二章 2.6）题解 ----c语言自顶向上归并排序链表
Yannie's Blog
04-17 319
对于链表的排序其实是有很多方法的 可以用自顶向下递归的进行排序，也可以自底向上迭代的进行排序 或者用一个新的链表进行每一次插入的时候找到需要插入的位置 由于之前写过排序的算法，本来想写自底向上迭代的排序算法，结果我能力有限，没有写出来，就参照这写了一个自顶向上递归的排序算法 //自顶向下归并排序 //明天写自低向上归并排序 #include<stdio.h> #include<...
2021版王道《数据结构》编程题汇总
shazi4399的博客
03-27 7068
2021版王道《数据结构》编程题汇总 第二章 线性表P19 1 ​ 1.从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删元素的值。空出的位置由最后一个元素填补，若顺序表为空则显示出错信息并退出运行。 ​ 算法思想：搜索整个顺序表，查找最小值元素并记住其位置，搜索结束后用最后一个元素填空出的原最小值元素的位置。 ​ 代码： bool Del_Min(sqList &L, El...
分割链表[先取next再斩断链表防止断链]
qq_43164662的博客
06-30 413
链表操作的核心问题之一，就是断链，不断链就需要把后面的被动节点先用指针变量指着。
23王道数据结构代码题全解（三）
漫磋嗟
04-22 2928
此次更新链表（8/25），计划更新23王道数据结构所有课后代码习题的实现，虽然考试写的一般都是伪代码，但是强迫症的我还是全部实现了一遍，都可以编译运行，包含暴力解和最优解，仓库在这里 https://github.com/mancuoj/wangdao
2021-09-27 单链表
weixin_45676126的博客
09-27 86
// // Created by 民 on 2021/9/26. // #include <iostream> using namespace std; typedef int Elem; typedef struct LNode{ Elem data; struct LNode* next; }LNode,*LinkList; //单链表 void Init_LinkList(LinkList &L){ LNode *node = new LNode;//
数据结构学习之单向链表C语言实现
lzp1467188465的博客
10-15 339
#include <stdio.h> #include <stdlib.h> #include <malloc.h> typedef struct Node { int data; struct Node* next; }Lnode,Linklist; void InitList(Linklist* l){//初始化无头单向链表 int i; for(i=1;i<10;i++){ l->data=i; .
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值