王道链表编程题目笔记

最新推荐文章于 2023-01-06 11:06:20 发布
最新推荐文章于 2023-01-06 11:06:20 发布
阅读量284 收藏 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
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
双向链表的增删改查
weixin_48856218的博客
03-17 1110
单向链表特点：1.我们可以轻松的到达下一个节点, 但是回到前一个节点是很难的.2.只能从头遍历到尾或者从尾遍历到头(一般从头到尾)双向链表特点1.每次在插入或删除某个节点时, 需要处理四个节点的引用, 而不是两个. 实现起来要困难一些2.相对于单向链表, 必然占用内存空间更大一些.3.既可以从头遍历到尾, 又可以从尾遍历到头双向链表的定义:双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。
从链表中移除节点(leetcode)
wx20041102的博客
03-28 344
翻转后 8 3 13 2 5 定义一个最大值max == 第一个节点的值依次迭代。翻转后 左侧有更大值 就需要移除。当右侧有更大值 就需要移除。
2021版王道《数据结构》编程题汇总
shazi4399的博客
03-27 6957
2021版王道《数据结构》编程题汇总 第二章 线性表P19 1 ​ 1.从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删元素的值。空出的位置由最后一个元素填补，若顺序表为空则显示出错信息并退出运行。 ​ 算法思想：搜索整个顺序表，查找最小值元素并记住其位置，搜索结束后用最后一个元素填空出的原最小值元素的位置。 ​ 代码： bool Del_Min(sqList &L, El...
分割链表[先取next再斩断链表防止断链]
qq_43164662的博客
06-30 370
链表操作的核心问题之一，就是断链，不断链就需要把后面的被动节点先用指针变量指着。
【数据结构】【王道】【线性表】单链表的实现及基本操作（带头结点）（可直接运行）
treesorshining的博客
07-11 1751
1.2 初始化 1.3 判空 1.4 按位序插入 1.5 指定结点后插操作 1.6 指定结点前插操作 1.7 按位序删除 1.8 按位查找 1.9 按值查找 1.10 表的长度 1.11 单链表建立（尾插法） 1.12 单链表建立（头插法） 1.13 输出所有链表元素 2.完整代码 3.运行截图............
C语言链表相关面试题.zip
03-13
C语言链表相关的面试题在软件开发领域的面试中是非常常见的，这是因为链表作为一种基本的数据结构，对于理解数据结构、算法以及内存管理等方面有着重要的作用。以下是一些关于C语言链表的面试题及其详细解释。 1. ...
c语言编程题之链表操作设计链表.zip
最新发布
03-30
c语言 c语言编程题之链表操作设计链表
c语言编程题之链表操作回文链表.zip
03-30
c语言 c语言编程题之链表操作回文链表
《剑指Offer》刷题笔记——面试题24. 反转链表
01-20
一、题目描述： 二、解题分析： 1、leetcode解析 2、测试用例 3、代码实现 # Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val = x # self.next = None from ...
王道数据结构的所有选择题
10-29
考研数据结构总结
2019王道考研数据结构勘误
05-04
2019王道论坛数据结构最新版勘误 修订错误统计表
链表面试题_链表_面试题_cow3cm_数据结构_
09-30
Linked lists of data structures often meet questions.
如果你能读懂这段代码并能回答我的问题，那么你的链表就没有任何问题了！
C_Engineer的博客
09-04 82
如果你能读懂这段代码并能回答我的问题，那么你的链表就没有任何问题了！ # include <stdio.h> struct LinkNode{ int data; struct LinkNode *next; }; void initLinkList(struct LinkNode *&L){ struct LinkNode *p, *s; int num; L = new LinkNode; p = L; printf("
链表大总结（王道加红皮书）
m0_46335449的博客
11-28 1292
补上了双向链表和循环链表
23王道数据结构代码题全解（三）
漫磋嗟
04-22 2798
此次更新链表（8/25），计划更新23王道数据结构所有课后代码习题的实现，虽然考试写的一般都是伪代码，但是强迫症的我还是全部实现了一遍，都可以编译运行，包含暴力解和最优解，仓库在这里 https://github.com/mancuoj/wangdao
数据结构专题（一）
Xaiochengsmdbh的博客
01-06 142
大学数据结构笔记专题C++
详解链表反转问题
qq_54850598的博客
11-03 2234
链表是数据结构中的一种线性数据结构，它的结构可以理解为一个结构体，内部存储着一个值和其对下一个链表的指向。链表的种类很多，主要有单链表（本文所有题目都是讲解单链表），双链表，循环链表，他们的结构大同小异，都是类似的结构体指向，只是单链表只有一个指针，双链表存在两个 两个指针，循环链表的尾结点指向不同提示：以下是本篇文章正文内容，下面案例可供参考本人对于数据结构熟练度不高，如果有讲得不够好的地方，请包涵此外：链表问题一定要画图，脑海浮现会很乱的。
请实现反向reverse一个单向链表编程
06-01
2. 从头节点开始遍历链表，每次迭代将当前节点的next指针指向上一个节点prev，然后将prev指针指向当前节点，将curr指针指向下一个节点。 3. 遍历结束后，prev指针指向原链表的尾节点，即反转后的头节点。 4. 返回...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值