链表相关OJ

已于 2024-09-11 19:02:49 修改
阅读量393 收藏 11
点赞数 22
文章标签： 链表 数据结构
于 2024-09-11 19:02:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76227083/article/details/135596762
版权

目录

1、移除链表元素

（1）题目描述 

（2）算法原理 

2、链表的中间结点

（1）题目描述

（2）算法原理 

3、链表中倒数第K个结点 

（1）题目描述 

（2）算法原理 

4、反转链表

（1）题目描述

（2）算法原理

5、合并两个有序链表

 （1）题目描述

（2）算法原理

6、分割链表 

（1）题目描述

（2）算法原理

7、回文链表 

（1）题目描述

（2）算法原理 

8、链表相交

（1）题目描述

（2） 算法原理

9、环形链表

（1）题目描述

（2）算法原理 

10、环形链表ll

（1）题目描述

（2）算法原理

1、移除链表元素

203. 移除链表元素 - 力扣（LeetCode）

（1）题目描述 

（2）算法原理 

解法一：尾插到新链表

当我们看到这道题的时候，我相信大多数人脑海中的第一个想法就是直接尾插到一个新链表当中。因此，我们可以遍历这个链表，如果当前节点的val不是要删除的数，就将它尾插到新链表 ，最后返回新链表的头。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution 
{
public:
    ListNode* removeElements(ListNode* head, int val) 
    {
        if(head == nullptr)
            return nullptr;
        ListNode* newhead = nullptr, *tail = nullptr;
        ListNode* cur = head;
        while(cur)
        {
            //如果不是要删除的val,就尾插
            if(cur->val != val)
            {
                //刚开始newhead为空，需要特殊处理。
                if(newhead == nullptr)
                {
                    newhead = tail = cur;
                }
                //尾插
                else 
                {
                    tail->next = cur;
                    tail = tail->next;
                }
            }
            cur = cur->next;
        }
 
        if(tail)
        tail->next = nullptr;
        return newhead;
    }
};

这个地方还是有细节需要注意的， 在最后需要把tail的next置为空。这里tail是有可能为空的，如果为空的话就会报错。因此需要特判一下。比如说题目给的示例3，链表里的数全是7，要删除的也全是7，此时就不会进入尾插的逻辑，tail就是空的。

这种做法是可以解决这道题的，但是毕竟不是真正的删除。因此接下来我们考虑一下如何在原链表上进行删除。

解法二：双指针

我们先看用一个指针行不行，肯定是不行的，因为你需要更改链接关系，还要删除，一个指针肯定是不行的，因此我们需要一个前驱指针，帮助我们修改链接关系。

开始的时候让prev为空，cur为头节点， 然后遍历链表，如果cur节点的值不是要删除的值，就让prev更新为cur，cur=cur->next。否则说明cur节点的值是要删除的值，此时直接更新prev的指向关系，让prev的next指向cur的next,然后删除cur，在把cur更新为prev的next，prev和cur始终保持以前一后的关系。这里要注意一种情况，就是说我一上来第一个节点就是要删除的，那么这个时候prev是空呀，那么就会出问题，因此要特殊处理prev为空的情况，如果为空，说明一上来就是要删除的节点，那么此时将head更新为cur的下一个节点，然后删除cur,再将cur更新为head即可。prev不用动。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution 
{
public:
    ListNode* removeElements(ListNode* head, int val) 
    {
        ListNode* prev = nullptr;
        ListNode* cur = head;
        while(cur)
        {
            if(cur->val != val)
            {
                prev = cur;
                cur = cur->next;
            }
            else 
            {
                if(prev == nullptr)
                {
                    head = cur->next;
                    delete cur;
                    cur = head;
                }
                else
                {
                     prev->next = cur->next;
                     delete cur;
                     cur = prev->next;
                }
            }
        }
        return head;
    }
};

2、链表的中间结点

876. 链表的中间结点 - 力扣（LeetCode）

（1）题目描述

（2）算法原理 

解法一：暴力求解

这道题大多数人看到之后的第一想法就是，我先遍历一遍这个链表，统计一下节点个数，然后节点个数除以2，然后再遍历一遍链表，就可以得到答案。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution 
{
public:
    ListNode* middleNode(ListNode* head) 
    {
        int count = 0;
       ListNode* cur = head;
        while(cur)
        {
            count++;
            cur = cur->next;
        }

        count /= 2;
        cur = head;
        while(count--)
        {
            cur = cur->next;
        }
        return cur;
    }
};

解法二：快慢指针

但是这道题有一种非常优秀的解法就是快慢指针。就是搞fast,slow两个指针，一开始都指向头节点，然后fast一次都两步，slow一次走一步，当fast或者fast->next为空的时候，slow刚好就是中间节点。

节点个数为奇数时：

节点个数为偶数时：

代码： 

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution 
{
public:
    ListNode* middleNode(ListNode* head) 
    {
        ListNode* slow = head,  *fast = head;
        while(fast && fast->next)
        {
            slow = slow->next;
            fast = fast->next->next;
        }
        return slow;
    }
};

3、链表中倒数第K个结点 

链表中倒数第k个结点_牛客题霸_牛客网 (nowcoder.com)

（1）题目描述 

（2）算法原理 

解法一：暴力求解

我们第一眼看到这道题的时候肯定是想着先遍历一遍链表，统计链表长度n，然后长度n减去k，之后从头开始走n-k步。这里要注意，链表长度是有可能小于k的，因此要注意处理一下这种情况。

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution 
{
public:
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) 
	{
		if(pListHead == nullptr)
			return nullptr;

		ListNode* cur = pListHead;
		int count = 0;
		while(cur)
		{
			count++;
			cur = cur->next;
		}

		count -= k;
		if(count < 0)
			return nullptr;
			
		cur = pListHead;
		while(count--)
		{
			cur = cur->next;
		}
		return cur;
    }
};

解法二：快慢指针

这道题可以直接用快慢指针，定义slow和fast两个指针，先让fast走k步，然后再让fast和slow同时往后走，当fast走到空的时候，slow就是倒数第K个节点。其实是很好理解的。我们假设链表长度为n，fast先走k步，意味着fast到链表n的距离是n - k，之后slow和fast同时往后走，当fast到达结尾的时候，走的了n-k步，因此slow也就走了n-k步。刚好就是倒数第k个节点的位置。

但是要注意，就是K可能超出了链表的长度。

代码：

class Solution 
{
public:
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) 
	{
		if(pListHead == nullptr)
			return nullptr;
		ListNode* fast = pListHead;
		ListNode* slow = pListHead;
		while(k--)
		{
			if(fast)
			fast = fast->next;
			else
			return nullptr;
		}

		while(fast)
		{
			slow = slow->next;
			fast = fast->next;
		}

		return slow;
    }
};

4、反转链表

206. 反转链表 - 力扣（LeetCode）

（1）题目描述

（2）算法原理

解法一：头插到新链表

利用头插的思想，直接将原链表节点头插到新链表当中。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution 
{
public:
    ListNode* reverseList(ListNode* head) 
    {
        ListNode* newhead = nullptr;
        ListNode* cur = head;
        while(cur)
        {
            ListNode* next = cur->next;
            cur->next = newhead;
            newhead = cur;
            cur = next;
        }
        return newhead;
    }
};

解法二：三指针

话不多说，直接上图

代码：

class Solution 
{
public:
    ListNode* reverseList(ListNode* head) 
    {
        if(head == nullptr) return nullptr;
        ListNode* prev = nullptr;
        ListNode* cur = head;
        ListNode* next = head->next;

        while(cur)
        {
            cur->next = prev;
            prev = cur;
            cur = next;
            if(next)
            next = next->next;        
        }
        return prev;
    }
};

5、合并两个有序链表

21. 合并两个有序链表 - 力扣（LeetCode）

 （1）题目描述

（2）算法原理

如果大家做过合并两个有序数组那道题的话，这道题的解法是类似。我们可以同时遍历这两个链表，将val小的尾插到新链表中。当一个链表遍历结束的时候结束循环，之后将另一个尾插到新链表中。

代码：

class Solution 
{
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) 
    {
        if(list1 == nullptr)
            return list2;
        if(list2 == nullptr)
            return list1;
        ListNode* newhead = nullptr;
        ListNode* tail = nullptr;
      

        while(list1 && list2)
        {
            if(list1->val < list2->val)
            {
                if(newhead == nullptr)
                {
                    newhead = tail = list1;
                }
                else
                {
                    tail->next = list1;
                    tail = tail->next;
                }
                list1 = list1->next;
            }
            else
            {
                if(newhead == nullptr)
                {
                    newhead = tail = list2;
                }
                else
                {
                    tail->next = list2;
                    tail = tail->next;
                }
                list2 = list2->next;
            }
        }
        //直接尾插即可。不需要while
        if(list1)
        {
          tail->next = list1;
        }

        if(list2)
        {
          tail->next = list2;
        }

        return newhead;
    }
};

6、分割链表 

 面试题 02.04. 分割链表 - 力扣（LeetCode）

（1）题目描述

（2）算法原理

这道题的思路就是我们搞两个链表small和large，然后遍历原始链表，将小于x的尾插到small，然后大于x的尾插到large，之后把large连接到small后面。这道题最后搞个哨兵位的头结点，写代码的时候就不用处理特殊情况了

代码：

class Solution 
{
public:
    ListNode* partition(ListNode* head, int x) 
    {
        ListNode* small = new ListNode(0);
        ListNode* smallHead = small;
        ListNode* large = new ListNode(0);
        ListNode* largeHead = large;
        while (head != nullptr) 
        {
            if (head->val < x) 
            {
                small->next = head;
                small = small->next;
            } 
            else 
            {
                large->next = head;
                large = large->next;
            }
            head = head->next;
        }
        large->next = nullptr;
        small->next = largeHead->next;
        return smallHead->next;
    }
};

7、回文链表 

​​​​​​LCR 027. 回文链表 - 力扣（LeetCode）

（1）题目描述

（2）算法原理 

解法一：利用数组+双指针：

当我们看到这道题的时候，我头脑中的第一个想法就是遍历一遍链表，然后把节点的值存到数组里，然后定义两个指针，判断是不是回文。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution 
{
public:
    bool isPalindrome(ListNode* head) 
    {
        vector<int> v;
        ListNode* cur = head;
        while(cur)
        {
            v.push_back(cur->val);
            cur = cur->next;
        }
        int left = 0, right = v.size() - 1;
        while(left < right)
        {
            if(v[left] != v[right])
                return false;
            left++;
            right--;
        }
        return true;
    }
}

解法二：中间节点+反转链表 

第一种解法是可以通过的，但是，有点取巧，有没有更优秀的解法呢？我们可以先找到链表的中间节点，然后将链表的后半部分逆置，然后比较前半部分链表和后半部分是否相同。其实就是我们做过的链表的中间节点和反转链表的一个融合。copy一下上两道题的代码。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) 
    {
        if(head == nullptr) return nullptr;
        ListNode* prev = nullptr;
        ListNode* cur = head;
        ListNode* next = head->next;

        while(cur)
        {
            cur->next = prev;
            prev = cur;
            cur = next;
            if(next)
            next = next->next;
        }
        return prev;
    }
    ListNode* middleNode(ListNode* head) 
    {
        ListNode* fast = head, *slow = head;
        while(fast && fast->next)
        {
            slow = slow->next;
            fast = fast->next->next;
        }
        return slow;
    }

    bool isPalindrome(ListNode* head) 
    {
        ListNode* mid = middleNode(head);
        ListNode* rhead = reverseList(mid);
        while(rhead)
        {
            if(head->val != rhead->val)
                return false;
            rhead = rhead->next;
            head = head->next;
        }
        return true;
    }
};

8、链表相交

（1）题目描述

（2） 算法原理

通过观察不难发现我们可以遍历一下链表A和链表B的长度，然后让记录链表A和链表B的长度，之后让长的链表先走差距步，在同时走，如果有相同的节点就说明链表是有交点的。这里要注意不能比值，而要比地址。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution 
{
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) 
    {
        if(headA == nullptr || headB == nullptr)
            return nullptr;
        int len1 = 0, len2 =0;
        ListNode* cur1 = headA;
        ListNode* cur2 = headB;
        //求出链表长度
        while(cur1)
        {
            len1++;
            cur1 = cur1->next;
        }
        while(cur2)
        {
            len2++;
            cur2 = cur2->next;
        }
        
      
        //差距步
        int gap = abs(len1 - len2);
        //假设headA长
        ListNode* longg = headA;
        ListNode* shout = headB;
        if(len1 < len2)
        {
            //说明假设错了，更改一下
            longg = headB;
            shout = headA;
        }
        while(gap--) //长的链表走差距步
        {
            longg = longg->next;
        }
        while(longg != shout)
        {
            longg =longg->next;
            shout = shout->next;
        }
        return longg;
    }
};

9、环形链表

141. 环形链表 - 力扣（LeetCode）

（1）题目描述

（2）算法原理 

先说结论，这道题要用快慢指针。定义slow和fast两个指针，让slow每次走一步，fast每次走两步，如果是环形链表，则一定会有slow==fast。那么问题就来了。

1、为什么slow走一步，fast走两步它们两个会相遇，会不会错过呢？

2、如果slow走1步，fast走n步(n>2)，它们两个会相遇? 会错过?

当n为3的时候其实就看距离是奇数还是偶数了,n为4的时候看距离是不是3的倍数，以此类推。

代码：

/**
 * 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* slow = head;
        ListNode* fast = head;
        while(fast && fast->next)
        {
            slow = slow->next;
            fast = fast->next->next;
            if(slow == fast)
                return true;
        }
            return false;
       
    }
};

10、环形链表ll

142. 环形链表 II - 力扣（LeetCode）

（1）题目描述

（2）算法原理

解法一：快慢指针

这道题让我们返回入环时候的第一个点，这道题肯定是和上一道题是有 关联的。我们同样可以用快慢指针，和上一道题一样，求出fast和slow的相遇点，然后在用一个指针从头出发，另一个指针从相遇点出发，当它们的第一个地址相同的节点就是入环的第一个点。同样的我们来证明一下。

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution 
{
public:
    ListNode *detectCycle(ListNode *head) 
    {
        ListNode* slow, *fast;
        slow = fast = head;
        while(fast && fast->next)
        {
            slow = slow->next;
            fast = fast->next->next;
            if(slow == fast)
            {
                ListNode* meet = slow;
                while(meet != head)
                {
                    meet = meet->next;
                    head = head->next;
                }
                return meet;
            }
        }
        return nullptr;
    }
};

解法二：转换成链表相交

如果解法一大家有些迷惑，我们可以把它转换成链表相交。同样的，利用快慢指针，找到fast和slow的相遇点，然后将相遇点和相遇点下一个节点断开。然后其实就是两个链表找交点的问题了。

代码： 

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

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

    
 ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) 
    {
        if(headA == nullptr || headB == nullptr)
            return nullptr;
        int len1 = 0, len2 =0;
        ListNode* cur1 = headA;
        ListNode* cur2 = headB;
        //求出链表长度
        while(cur1)
        {
            len1++;
            cur1 = cur1->next;
        }
        while(cur2)
        {
            len2++;
            cur2 = cur2->next;
        }
        
      
        //差距步
        int gap = abs(len1 - len2);
        //假设headA长
        ListNode* longg = headA;
        ListNode* shout = headB;
        if(len1 < len2)
        {
            //说明假设错了，更改一下
            longg = headB;
            shout = headA;
        }
        while(gap--) //长的链表走差距步
        {
            longg = longg->next;
        }
        while(longg != shout)
        {
            longg =longg->next;
            shout = shout->next;
        }
        return longg;
    }
class Solution 
{
public:
   
    ListNode *detectCycle(ListNode *head) 
    {
        ListNode* fast , *slow;
        fast = slow = head;
        while(fast && fast->next)
        {
            slow = slow->next;
            fast = fast->next->next;
            if(slow == fast)
            {
                ListNode* meet = slow;
                ListNode* next = meet->next;
                meet->next = nullptr;
                ListNode* cur = head;
                return getIntersectionNode(next,cur);
            }
        }
        return nullptr;
    }
};

猫头鹰~
关注
  • 22
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
cpp代码-双向循环链表-oj
07-14
在这个"cpp代码-双向循环链表-oj"的主题中，我们将深入探讨C++实现的双向循环链表以及其在在线判题系统（Online Judge, OJ）上的应用。 首先，双向循环链表的基本结构包括节点（Node）和链表类...
西南科技大学SWUST OJ 线性结构，链表题解答案 线性结构.zip
12-31
本资料集中，我们主要关注的是链表相关的题目解答，这些题目来自西南科技大学的在线编程平台SWUST OJ。链表作为线性结构的一种，其灵活性和高效性使得它在解决诸多算法问题时具有广泛的应用。接下来，我们将逐一解析...
链表相关ＯJ题目
qq_52145272的博客
11-06 243
文章目录10-30移除链表元素问题描述思路分析代码实现反转链表问题描述思路分析代码实现链表的中间结点问题描述思路分析代码实现链表中倒数第K个结点问题描述思路分析代码实现合并两个有序链表问题描述思路分析代码实现链表分割问题描述思路分析代码实现10-31链表的回文结构问题描述思路分析代码实现相交链表问题描述思路分析代码实现11-2环形链表问题描述思路分析代码实现环形链表进阶问题描述思路分析代码实现 10-30 移除链表元素 问题描述 https://leetcode-cn.com/problems/remove
链表相关OJ及方法总结
m0_62918577的博客
11-15 403
自己总结了链表有关的oj题
链表相关oj题 一
qq_53010164的博客
03-27 824
203. 移除链表元素 - 力扣（LeetCode） (leetcode-cn.com) 题目：给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。 图解分析： 代码： /** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; ...
链表相关oj题 二
qq_53010164的博客
03-29 1119
一、分割链表86. 分隔链表https://leetcode-cn.com/problems/partition-list/题目：给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。你应当 保留 两个分区中每个节点的初始相对位置。 图解： 代码： struct ListNode* partition(struct ListNode* head, int x) { //新建立俩个链表，链表1为less（..
链表相关oj题
weixin_67401157的博客
03-16 822
链表相关oj题，快来检查一下你的掌握程度吧 ~
链表相关oj题 三
qq_53010164的博客
04-04 932
一、环形链表II 142. 环形链表 II - 力扣（LeetCode） (leetcode-cn.com) 题目：给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际..
顺序表、链表相关OJ题（1）
weixin_51142926的博客
01-29 9787
本文为经典算法OJ题练习，大部分题型都有多种思路，每种思路的解法博主都试过了（去网站那里验证）是正确的，大家可以参考！！
顺序表、链表相关OJ题（2）
热门推荐
weixin_51142926的博客
02-04 1万+
本文为数据结构相关的OJ题，多种思路可以参考！！
有关链表的oj题
2201_75537851的博客
07-29 345
cur = next;if (tail)876. 链表的中间结点 - 力扣（LeetCode）
链表相关OJ题 (一)
m0_57249790的博客
04-11 603
反转链表 合并有序链表 链表的中间结点 链表中倒是第k个结点 OJ题目
14_L3缓存友好的数据结构
刘炫320的博客
09-11 409
老鸟：L3缓存是CPU缓存层次结构中的第三层，通常比L1和L2缓存大，但访问速度稍慢。L3缓存友好的数据结构设计旨在最大限度地减少缓存未命中，从而提升性能。菜鸟：那这些数据结构有什么特点呢？老鸟：主要特点是数据局部性好，也就是说，数据在内存中是连续存储的，这样能更好地利用缓存行。我们可以从一个简单的例子开始，比如数组和链表的对比。老鸟：总结一下，L3缓存友好的数据结构通过提升数据局部性来提高性能。常见的有数组、等。它们在大数据处理和高性能计算中非常有用。但在实际应用中，需要权衡性能、可维护性和具体需求。
【数据结构】顺序表的应用
Sakura_ding的博客
09-07 483
2）能够保存用户信息：名字、性别、年龄、电话、地址等。1）至少能够存储100个⼈的通讯信息。
【数据结构】——1.1树
qq_43507078的博客
09-07 1045
树，二叉树
【数据结构】排序算法系列——希尔排序（附源码+图解）
Skrrapper的博客
09-07 934
希尔排序实际上是个相当复杂的排序算法，这主要是跟它的步长序列gap到底该如何取、后续应该减小有关。时，数组已经接近有序的了，就整体而言，最后一次整体的插入排序就可以大大提高效率——我们从插入排序的时间复杂度分析也可以看出，可以看到每次减小gap的规律是将原先的gap/2，但事实上这只是其中一种处理方法，并不说明这是最优解。，使得平均情况下的时间复杂度能够在O(n^1.3)左右，而不好的选择则可能导致接近最坏情况的性能。中，我们会将整体数据一分为多份，进行散布式的插入排序，这时候每一个子序列之间的间隙就是。
2.C_数据结构_线性表
Fresh_man111的博客
09-07 1077
线性表就是若干数据的一个线性序列。数学表达式：L：表名a0~an-1：数据元素n：表长，n>0是为非空表二元描述形式：D：数据元素D用 ai 表示，这个 i 范围是0~n-1R：关系用R表示，这个关系是，表示ai为ai+1的直接前驱，ai+1为ai的直接后继。：这符号称为有序对，xxx1是xxx2的直接前驱，xxx2是xxx1的直接后继。 xxx1和xxx2可以为一个或多个。
21_动态规划与数据结构结合
刘炫320的博客
09-11 373
老鸟：假设你有一个数组arr，你需要多次查询某个子数组arr[i:j]的和。直接计算会很慢，我们可以用动态规划预处理，再用一种数据结构来快速查询。菜鸟：听起来不错，但具体怎么做呢？老鸟：我们可以先构建一个数组prefixSum，其中表示数组arr从起始位置到i的和。这样每次查询arr[i:j]的和时，可以用来快速计算。菜鸟：这样确实能减少计算量，但构建prefixSum数组需要什么操作呢？老鸟：好问题。我们来看看代码示例。老鸟：今天我们讨论了动态规划与数据结构结合的应用，通过prefixSum。
浙大数据结构：05-树7 堆中的路径
最新发布
qq_74924951的博客
09-11 305
int size;}* Heap;int size;} *Heap;return H;int i;for (;for (;x;i < n;int f = 0;i < l;f = 1;return 0;
旋转链表 东华大学oj
06-03
旋转链表是一种操作链表的方法，它可以将链表中的元素向右旋转 k 个位置。具体来说，如果将链表中的每个节点向右移动 k 个位置，则从链表尾部开始计算，移动后的最后一个节点应该移动到链表头部，而倒数第二个节点移动到倒数第 k+1 个节点的位置，依此类推。旋转链表的主要应用场景是在某些需要处理循环数组的问题中，将链表视为循环数组来处理。 关于东华大学oj的问题，我不是很清楚，可以请您提供更多的信息吗？
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值