算法-链表

已于 2022-11-04 12:33:03 修改
阅读量239 收藏
点赞数
文章标签： 链表 数据结构
于 2022-11-01 23:44:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42170897/article/details/127643661
版权

一、链表反转

解法：始终将当前结点的next指针指向其前一个结点。借助两个辅助指针pre、next。

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        //如果没有链表没有结点或只有一个结点就直接返回。
		if (pHead == NULL || pHead->next == NULL)
		{
			return pHead;
		}
        //pre 保存cur结点的前一个结点，默认为NULL
		ListNode* pre = NULL;
		ListNode* cur = pHead;
		while(cur != NULL)
		{
            //next 保存当前结点的下一结点
			ListNode *next = cur ->next;
			cur->next = pre;
			pre = cur;
			cur = next;
		}
        //pre一定是新链表的头结点。
		return pre;
    }
};

二、合并两个有序的链表

解法：

1.首先判断两个有序链表是否为空，如果是返回另一个链表

2.定义pHead3作为新链表的头，然后根使用合并两个有序数组相同的算法合并两个有序链表。

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {
        if (pHead1 == NULL)
			return pHead2;
		if (pHead2 == NULL)
			return pHead1;

		ListNode *pHead3=NULL,*p=NULL;
		while(pHead1 != NULL && pHead2 != NULL)
		{
			if (pHead1->val < pHead2->val)
			{
				if (pHead3 == NULL)
				{
					pHead3 = pHead1;
					p = pHead1;
				}else{
					p->next = pHead1;
					p = p->next;
				}
				pHead1 = pHead1->next;
			}else
			{
				if (pHead3 == NULL)
				{
					pHead3 = pHead2;
					p = pHead2;
				}else{
					p->next = pHead2;
					p = p->next;
				}
				pHead2 = pHead2->next;
			}
		}

		while(pHead1 != NULL)
		{
			p->next = pHead1;
			p = p->next;
			pHead1 = pHead1->next;
		}
		while(pHead2 != NULL)
		{
			p->next = pHead2;
			p = p->next;
			pHead2 = pHead2->next;
		}
		return pHead3;
    }
};

三、判断链表是否有环

解法：使用快慢指针，指针p1每次向后移动一个单位，指针p2每次向后移动两个单位，如果存在环，则p2会再次与p1相等。(类比操场跑步，跑的快的迟早会“追上”跑的慢的)。

#include <iostream>

using namespace std;

// Definition for singly-linked list.
struct ListNode
{
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

class Solution
{
public:
    bool hasCycle(ListNode *head)
    {
        ListNode *p1 = head;
        ListNode *p2 = head;

        while (p1 != NULL && p2 != NULL)
        {
            p1 = p1->next;
            if (p2->next == NULL)
            {
                return false;
            }
            p2 = p2->next->next;

            //判断
            if (p2 == p1)
            {
                return true;
            }
        }

        return false;
    }
};

void test01()
{
    //{3,2,0,-4},1

    ListNode n0(3);
    ListNode n1(2);
    ListNode n2(0);
    ListNode n3(-4);

    n0.next = &n1;
    n1.next = &n2;
    n2.next = &n3;
    n3.next = &n1;

    cout << Solution().hasCycle(&n0) << endl;
}

void test02()
{
    //{1},-1

    ListNode n0(-1);
    cout << Solution().hasCycle(&n0) << endl;
}

void test03()
{
    // {-1,-7,7,-4,19,6,-9,-5,-2,-5},6
    ListNode n0(-1);
    ListNode n1(-7);
    ListNode n2(7);
    ListNode n3(-4);
    ListNode n4(19);
    ListNode n5(6);
    ListNode n6(-9);
    ListNode n7(-5);
    ListNode n8(-2);
    ListNode n9(-5);

    n0.next = &n1;
    n1.next = &n2;
    n2.next = &n3;
    n3.next = &n4;
    n4.next = &n5;
    n5.next = &n6;
    n6.next = &n7;
    n7.next = &n8;
    n8.next = &n9;
    n9.next = &n6;

    cout << Solution().hasCycle(&n0) << endl;
}

int main()
{
    test01();
    test02();
    test03();

    return 0;
}

四、链表中倒数k个结点

解法一:时间复杂度 O(n)、空间复杂度：O(n)。

使用数组记录所有结点，这样可以知道所有结点的个数，并且很容易的得到倒数第K个结点。

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pHead ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
    ListNode* FindKthToTail(ListNode* pHead, int k) {
        // write code here
        ListNode *p = pHead;
        vector<ListNode *> v;
        while (p != NULL)
        {
            v.push_back(p);
            p = p->next;
        }

        if (k == 0 || k > v.size())
        {
            return NULL;
        }

        return v[v.size() - k];
    }
};

解法二：时间复杂度 O(n)、空间复杂度：O(1)。

使用两个指针p、q，先让两个最大距离达到K,然后同步向后移动。

#include <iostream>

using namespace std;

// Definition for singly-linked list.
struct ListNode
{
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

class Solution
{
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param pHead ListNode类
     * @param k int整型
     * @return ListNode类
     */
    ListNode *FindKthToTail(ListNode *pHead, int k)
    {

        ListNode *p = pHead;
        ListNode *q = pHead;

        for (int i = k; i > 0; i--)
        {
            if (q == NULL)
            {
                return NULL;
            }

            q = q->next;
        }
        while (q)
        {
            p = p->next;
            q = q->next;
        }
        return p;
    }
};

int main()
{
    ListNode n0(1);
    ListNode n1(2);
    ListNode n2(3);
    ListNode n3(4);
    ListNode n4(5);

    n0.next = &n1;
    n1.next = &n2;
    n2.next = &n3;
    n3.next = &n4;

    ListNode *p = Solution().FindKthToTail(&n0, 2);
    while (p != NULL)
    {
        cout << p->val << " ";
        p = p->next;
    }
    cout << endl;

    return 0;
}

五、两个链表的第一个公共结点

解法1:如果两个人以相同速度，不同路程跑步，如何让他们同时到达终点，答案就是：将对方的路程也加到自己的路程上来。

 
 

ListNode *FindFirstCommonNode(ListNode *pHead1, ListNode *pHead2)
    {
        ListNode *p = pHead1;
        ListNode *q = pHead2;

        while (p != q)
        {
            p = (p == NULL) ? pHead2 : p->next;
            q = (q == NULL) ? pHead1 : q->next;
        }
        return p;
    }

        

解法2：先进行两次循环，得出两个链表的长度。再让长度链表先走k的长度(k为长度差)，然后两个指针一起走，直到相等（都为NULL也算相等）。

ListNode *FindFirstCommonNode(ListNode *pHead1, ListNode *pHead2)
    {
        ListNode *p = pHead1;
        ListNode *q = pHead2;
        int len1 = 0, len2 = 0;
        while (p != NULL)
        {
            len1++;
            p = p->next;
        }
        while (q != NULL)
        {
            len2++;
            q = q->next;
        }
        p = pHead1, q = pHead2;
        if (len1 >= len2)
        {
            for (int i = 0; i < len1 - len2; i++)
            {
                p = p->next;
            }
        }
        else
        {
            for (int i = 0; i < len2 - len1; i++)
            {
                q = q->next;
            }
        }
        while (p != NULL && q != NULL && p != q)
        {
            p = p->next;
            q = q->next;
        }
        return p;
    }

        

六、判断链表是否为回文序列

所谓回文序列就是正序和逆序相同的字符串：如a、aa、aba、abba

解法一：由于链表只能单向遍历，所以遍历链表，将所有值放入数组中，然后判断数组是否为回文数组。 时间复杂度：O(n)、空间复杂度：O(n)


class Solution {
public:
    /**
     * 
     * @param head ListNode类 the head
     * @return bool布尔型
     */
    bool isPail(ListNode* head) {
        vector<int> v;
        ListNode* p =head;
        while(p != NULL)
        {
            v.push_back(p->val);
            p=p->next;
        }
        int i=0;
        int j=v.size()-1;

        while(i<j)
        {
            if (v[i] != v[j])
            {
                return false;
            }
            i++;
            j--;
        }
        return true;
    }
};

解法二：从中间将链表一分为二、并将链表的一半反转，然后顺序比较。至于怎么将链表一分为二，可是根据链表长度、也可以使用快慢指针。 时间复杂度：O(n)、空间复杂度：O(1)

#include <iostream>
#include <vector>

using namespace std;

struct ListNode {
public:
    int val;
    struct ListNode *next;
    ListNode(int _val):val(_val),next(NULL){}
};


class Solution {
public:
    /**
     * 
     * @param head ListNode类 the head
     * @return bool布尔型
     */
    bool isPail(ListNode* head) {
        if (head == NULL)
        {
            return false;
        }

        ListNode* s = head;
        ListNode* f = head;

        while(f != NULL && f->next != NULL && f->next->next != NULL)
        {
            s = s->next;
            f = f->next->next;
        }
        bool jishu = false;
        if (f->next == NULL)
        {
            jishu = true;
        }
        
        if (jishu)
        {
            ListNode* end = s;
            ListNode* start1 = head;
            ListNode* start2 = s->next;
            start2 = reverse(start2);

            while(start1 != end && start2 !=NULL)
            {
                if (start1->val != start2->val)
                {
                    return false;
                }
                start1 = start1->next;
                start2 = start2->next;
            }
            return true;
        }else
        {
            ListNode* end = s->next;
            ListNode* start1 = head;
            ListNode* start2 = s->next;
            start2 = reverse(start2);

            while(start1 != end && start2 != NULL)
            {
                if (start1->val != start2->val)
                {
                    return false;
                }
                start1 = start1->next;
                start2 = start2->next;
            }
            return true;
        }
    }
    ListNode* reverse(ListNode* head)
    {
        ListNode*p = head;
        ListNode*pre =NULL;
        while(p != NULL)
        {
            ListNode* next=p->next;
            p->next = pre;
            pre = p;
            p = next;
        }
        return pre;
    }
};

void test01();
void test02();
void test03();
void test04();
void test05();
void test06();

int main(){
    test01();
    test02();
    test03();
    test04();
    test05();
    test06();
    return 0;
}

void test01()
{ 
    bool ret = Solution().isPail(NULL);
    cout<<ret<<endl;
}

void test02()
{
    ListNode n0(1);
  
    bool ret = Solution().isPail(&n0);
    cout<<ret<<endl;
}

void test03()
{
    ListNode n0(1);
    ListNode n1(1);
    n0.next = &n1;
  
    bool ret = Solution().isPail(&n0);
    cout<<ret<<endl;
}

void test04()
{
    ListNode n0(1);
    ListNode n1(2);
    ListNode n2(1);
    n0.next = &n1;
    n1.next = &n2;
  
    bool ret = Solution().isPail(&n0);
    cout<<ret<<endl;
}

void test05()
{
    ListNode n0(1);
    ListNode n1(2);
    ListNode n2(2);
    ListNode n3(1);
    n0.next = &n1;
    n1.next = &n2;
    n2.next = &n3;
  
    bool ret = Solution().isPail(&n0);
    cout<<ret<<endl;
}

void test06()
{
    ListNode n0(1);
    ListNode n1(2);
    ListNode n2(2);
    ListNode n3(3);
    n0.next = &n1;
    n1.next = &n2;
    n2.next = &n3;
  
    bool ret = Solution().isPail(&n0);
    cout<<ret<<endl;
}

七、有序链表去重

解法：略。

class Solution
{
public:
    /**
     *
     * @param head ListNode类
     * @return ListNode类
     */
    ListNode *deleteDuplicates(ListNode *head)
    {
        ListNode *p = head;
        while (p != NULL)
        {
            ListNode *back = p->next;
            if (back != NULL && back->val == p->val)
            {
                p->next = back->next;
                continue;
                // free(next)
            }
            p = p->next;
        }
        return head;
        // write code here
    }
};

pakano
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
算法 - 链表
Ralap的博客
02-18 378
链表单链表反转双向链表反转单链表删除某一个值的节点单链表，链表长度为基数则返回中点元素，偶数则返回上中点元素单链表，链表长度为基数则返回中点元素，偶数则返回下中点元素单链表，链表是否是回文结构 单链表反转 将链表的头结点变成尾结点 /** * 翻转单链表 * * @param head * @return */ public static Node reverseLinkedList(Node head) { // 预存前节点
cailingling721#data-structures-and-algorithms#数据结构和算法-链表实战-环形链表I
07-25
链表实战题目4 - 链表入环的第一个节点给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回 null。为了表示给定链表中的环，我们使用整数 pos
【数据结构与算法 - 链表】
04-18
在实际应用中，链表常用于实现队列、栈、哈希表等高级数据结构，以及解决各种算法问题，如LRU缓存、图的深度优先搜索等。 总的来说，掌握链表及其C语言实现对于提升编程能力至关重要。通过模块化的设计，我们可以更...
cailingling721#data-structures-and-algorithms#数据结构和算法-链表实战-两两交换链
07-25
# 将第一个节点指向第三个节点# 第二个节点指向第一个节点# 节点first指向第二个节点# 当前节点后移动，记得a.next是节点3，相当于跳了一个节点，往后
算法设计-实验五-链表.docx
最新发布
09-06
链表是一种重要的数据结构，它在计算机科学中广泛应用于各种算法和程序设计中。与数组不同，链表的元素不需要连续的内存空间，每个元素（称为节点）包含数据和指向下一个节点的引用。本资源专注于Python中链表的实现...
算法——链表
一个憨憨写的胡言乱语
09-16 310
算法
《算法系列》之链表
小夏陌的博客
06-30 412
我们平时会发现如果一道题如果涉及数据结构，那么他的算法思路一般相对其它同等难度的题要简单，其实链表也一样。
【数据结构和算法03】链表
武哥聊编程
04-12 5238
在第一章的数组中，我们看到数组作为数据存储结构有一定的缺陷。在无序数组中，搜索时低效的；而在有序数组中，插入效率又很低；不管在哪一种数组中删除效率都很低。况且一个数组创建后，它的大小是无法改变的。 在本章中，我们将讨论下链表这个数据结构，它可以解决上面的一些问题。链表可能是继数组之后第二种使用得最广泛的通用数据结构了。本章主要讨论单链表和双向链表。 ...
头插法逆序输出单链表
许你一片梁城的博客
09-11 1191
带头结点单链表逆序输出 算法思想：遍历链表元素，利用头插法建立新的链表，这样新生成的链表就是之前的逆序链表，直接对其进行输出即可。（函数中没有写头结点初始化的信息，读者自行补充） 1.链表节点结构 typedef struct LNode{ int data; struct LNode* next; }LNode,*LinkList; 2.链表逆序 //链表逆序 void RevLinkList(LinkList &L){ LNode *p = L->ne
算法专题之链表
brokenkay的博客
11-20 631
前言 链表是一种物理存储结构上非连续的数据结构,数据的逻辑顺序是通过链表中的指针链接次序实现相互勾连. 链表相对数组而言有很多不同之处,在特定场景下能发挥独特的优势. 例如链表的插入和删除操作比数组效率高,数组需要改变其他元素的位置,而链表只需要改变指针的指向. javascript中没有直接生成链表的api,但仍然可以利用语言本身的特性实现一条链表并完成其他操作. 链表的实现 链表的数据结构如下图,每一个节点都包含一条数据和指向下一个节点的索引. 如果获取了链表中的某一个节点,比如第一个节点,那么就可以获
算法之链表
yaoyao071500的博客
03-11 1962
`链表简单算法题 1.将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成。（附leetcode 21.) //方法一 struct ListNode *mergeTwoLists(struct ListNode* l1, struct ListNode* l2){ if(!l1) return l2; if(!l2) return l1; struct ListNode *head=(struct ListNode*
算法链接
ZHO9504的博客
11-20 156
PCA SVM详细介绍 逻辑回归1 逻辑回归2 机器学习好多算法  HMM KNN 张量 强化学习 K-Means EM算法 LDA 朴素贝叶斯 随机森林 sigmoid 和 softmax区别 http://www.cnblogs.com/leoo2sk/archive/2010/09/17/naive-bayesian-classifier.html 朴素贝叶...
1.算法之链表
CarmenIsOK的博客
03-19 150
&lt;LeetCode&gt; 链表逆序 反转链表 反转一个单链表。 示例: 输入: 1-&gt;2-&gt;3-&gt;4-&gt;5-&gt;NULL 输出: 5-&gt;4-&gt;3-&gt;2-&gt;1-&gt;NULL class Solution { public: ListNode* reverseList(ListNode* head) {
线性表操作与算法设计-链表合并
在提供的描述中，提到的算法是用于寻找两个链表的公共后缀。这个算法涉及到链表操作，是数据结构中的一个重要概念，特别是线性表的链式存储。线性表是一种基本的数据结构，由具有相同特性的数据元素按特定顺序排列...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值