【算法与数据结构】链表——题目详解

已于 2023-06-30 20:01:44 修改
阅读量486 收藏 3
点赞数 2
分类专栏： 算法与数据结构 文章标签： 链表 数据结构 算法
于 2023-05-09 13:23:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38362786/article/details/130546627
版权

题目详解

Leetcode-206. 反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

在这里插入图片描述
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：

在这里插入图片描述
输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

提示：

链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000

进阶：

链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？

题目解析-1：链表头插法

用一个指针遍历链表，把每次遍历到的节点都插入到一个新的链表的头部

// Definition for singly-linked list.
#include <stdio.h>
#include <stdlib.h>

 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 new_head, *p = head, *q;   // q用来记录当前节点的下一个节点. newhead是虚拟头节点
		new_head.next = NULL;               // 新的链表头部
		while (p)
		{
			q = p->next;                     // 先记录一下原链表当前节点p的下一个节点
			p->next = new_head.next;         // 将当前节点插入到新链表的第一个节点
			new_head.next = p;
			p = q;                          // 当前节点再次回到原链表的下一个节点
		}
		return new_head.next;               // 返回新链表的虚拟头节点的下一个节点


	}
};

测试结果：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

题目解析-2：递归

假设后面部分已经反转了，head应该接在哪里？
head节点应该接在head的下一个节点的后面。
递归过程： 如果没有到达边界条件，首先先记录一下当前head节点的下一个节点，利用递归函数，将后面部分的全部反转掉，反转之后将head接在刚才记录的节点的后面

  1. 重要： 给【递归函数】一个明确的语义： 翻转当前链表
  2. 实现边界条件时的程序逻辑：空链表和只有一个节点的链表
  3. 假设递归函数调用返回结果是正确的，实现本层函数逻辑： f(n) = (f(n-1),1)

// Definition for singly-linked list.
#include <stdio.h>
#include <stdlib.h>

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 == NULL || head->next == NULL) return head;

		ListNode *tail = head->next;   // 先记录一下head的下一个节点
		ListNode *new_head = reverseList(head->next);       // 将head后面的部分反转
		head->next = tail->next;   // 把head的下一个节点接在空指针,因为反转后的tail的下一个节点为空指针
		tail->next = head;     // 把head接在反转后的尾节点后面

		return new_head;


	}
};

Leetcode-141.环形链表

给你一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

如果链表中存在环 ，则返回 true 。 否则，返回 false 。

示例 1：

在这里插入图片描述
输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

在这里插入图片描述
输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

在这里插入图片描述

输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

提示：

链表中节点的数目范围是 [0, 104]
-105 <= Node.val <= 105
pos 为 -1 或者链表中的一个 有效索引 。

进阶：

你能用 O(1)（即，常量）内存解决此问题吗？

题目解析：快慢指针

想象一个跑道，跑的快的人肯定可以套跑的慢的人一圈；
如果是直道，100米直道，跑的快的更快碰到终点。
设置两个指针，一个快指针，一个慢指针
如果有环：快指针会赶上慢指针，快指针和慢指针相等
如果没有环：快指针会先到达空指针


// Definition for singly-linked list.
#include <stdio.h>
#include <stdlib.h>


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

class Solution {
public:
	bool hasCycle(ListNode *head) {
		ListNode *p = head, *q = head;  // p是慢指针，q是快指针
		while (q && q->next)
		{
			p = p->next;   // p每次往后跑一步
			q = q->next->next;
			if (p == q) return true;   // 如果赶上了，证明有环
		}

		return false;
	}
};

测试结果

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

Leetcode-202. 快乐数

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：

对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
如果这个过程 结果为 1，那么这个数就是快乐数。
如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

示例 1：

输入：n = 19
输出：true
解释：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1

示例 2：

输入：n = 2
输出：false

提示：

1 <= n <= 231 - 1

题目解析：链表法

当前数字变换到下一个数字的过程，与链表结构的对应箭头关系对应：19->82->68->100->1
符合链表的特征
1当成链表中的空地址
问题变成：从19（头节点）开始，是否可以到达1（空地址）
也就是要判断这个链表是否有环，如果有环，则不是快乐数；如果没环，则是快乐数

所以数据结构不仅是真实的数据结构，更重要是其蕴含的内在的逻辑结构

class Solution {
public:
	bool isHappy(int n) {
		int p = n, q = n;  // p是慢， q是快
		while (q != 1)
		{
			p = getNext(p);  // p每次走一步
			q = getNext(getNext(q));   // q每次走两步
			if (p == q && p != 1) return false;  // p还不能等于1， 因为如果p=1， 那么往后走多少步都是1，这样q肯定能赶上p，会判断有环，即不是快乐数
			                                     // 举例：n = 10, p = 1, q = 1, p == q为真，那么判断有环，但实际是没有环的，所以要把p=1剔除
		}
		return true;

	}

	int getNext(int x)
	{
		int len = 0;
		while (x)
		{
			len += (x % 10) * (x % 10);
			x /= 10;
		}
		return len;
	}
};

Leetcode-61. 旋转链表

给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。

示例 1：

在这里插入图片描述
输入：head = [1,2,3,4,5], k = 2
输出：[4,5,1,2,3]

示例 2：

在这里插入图片描述
输入：head = [0,1,2], k = 4
输出：[2,0,1]

提示：

链表中节点的数目在范围 [0, 500] 内
-100 <= Node.val <= 100
0 <= k <= 2 * 109

题目解析：双指针等距移动法

第一步处理：由于k值可能超过链表的长度，所以先用k值对链表的长度取余，余数才是真正要移动的个数

一开始，p和q两个指针，p指向最后的空地址，q指向倒数第k-1个节点，那么此时p指针和q指针之间相差k+1个节点的距离。
此时再向前移动q指针到头节点，同步地p指针也保持相同距离往前移动，那么p所指向的节点就是距离头节点k+1个节点的距离
所以，一开始让p指针指向距离头节点k+1距离的节点，q指向头节点，然后让两个指针同步向后移动，直到p指针碰到空地址，此时q指针指向了要断开的地方的前一位。然后可以实行旋转操作

旋转操作：先让p指针回到要断开的地方，p = q->next；然后将q->next指向空地址；最后将p开始的小链表的最后一个节点指向头节点。


//  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:
	int getLength(ListNode *head)
	{
		int n = 0;
		for (ListNode *p = head; p; p = p->next) n += 1;
		return n;
	}
	ListNode* rotateRight(ListNode* head, int k) {
		if (head == nullptr) return head;
		int n = getLength(head);   // 获取链表的长度
		k %= n;                    // k对n取余
		if (k == 0) return head;
		ListNode *p = head, *q = head;
		for (int i = 0; i <= k; i++) p = p->next;   // 让p指针向后走k+1步
		while (p)
		{
			p = p->next;
			q = q->next;
		}
		// 此时p走到了空地址，q也走到可以断开链表的位置
		
		p = q->next;  // 回到断开的地方
		q->next = nullptr;
		// 可以使用q来遍历p后的链表
		q = p;
		while (q->next) q = q->next;
		q->next = head;

		return p;

	}
};

测试结果

在这里插入图片描述
在这里插入图片描述

题目解析：移1法

每次移动一个节点到头节点处，循环k次


//  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:
	int getLength(ListNode *head)
	{
		int n = 0;
		for (ListNode *p = head; p; p = p->next) n += 1;
		return n;
	}

	ListNode * moveOne(ListNode *head, int n)
	{
		ListNode *q = head, *p = head;
		for (int i = 0; i < n - 1; i++) p = p->next;     // p指向最后一个节点
		for (int i = 0; i < n - 2; i++) q = q->next;  // q指向倒数第二个节点
		q->next = nullptr;
		p->next = head;

		return p;


	}


	ListNode* rotateRight(ListNode* head, int k) {
		if (head == nullptr) return head;
		int n = getLength(head);   // 获取链表的长度
		k %= n;                    // k对n取余
		if (k == 0) return head;

		for (int i = 0; i < k; i++) head = moveOne(head, n);  // 每次只移动一个节点，移动k次


		return head;

	}
};

Leetcode-19. 删除链表的倒数第N个节点

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

示例 1：

在这里插入图片描述

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

示例 2：

输入：head = [1], n = 1
输出：[]

示例 3：

输入：head = [1,2], n = 1
输出：[1]

提示：

链表中结点的数目为 sz
1 <= sz <= 30
0 <= Node.val <= 100
1 <= n <= sz

题目解析：双指针等距移动法

关键：找到倒数第n+1个节点
技巧：当要删除倒数第n个节点，也就是头节点，那使用双指针的q指向哪个节点？所以这里需要使用虚拟头节点，将无头链表变成有头链表
删除操作：先将p指针向后移动n+1位，然后同时移动p和q指针，直到p碰到空地址，删除q的下一个节点即可


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* removeNthFromEnd(ListNode* head, int n) {
		ListNode newhead, *p = &newhead;
		newhead.next = head;   // 虚拟头节点

		ListNode *q = p;
		for (int i = 0; i <= n; i++) p = p->next;  // p移动n+1
		while (p)
		{
			p = p->next;
			q = q->next;
		}
		q->next = q->next->next;

		return newhead.next;

	}
};

测试结果

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

Leetcode-142. 环形链表II

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例 1：

在这里插入图片描述
输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

在这里插入图片描述
输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

在这里插入图片描述
输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。

提示：

链表中节点的数目范围在范围 [0, 104] 内
-105 <= Node.val <= 105
pos 的值为 -1 或者链表中的一个有效索引

进阶：

你是否可以使用 O(1) 空间解决此题？

题目解析：快慢指针

p是慢指针，q是快指针
假设环的前面的长度为a，当慢指针p走到交点处，q应该走到2a处，此时q和p同时在环里
经过多少轮，快指针能够追上慢指针？
由于每轮快指针都能追上一步慢指针，假设环的长度为x，只剩下x-a轮就能追上慢指针；
当快指针追上慢指针，慢指针走了x-a步
那么，快指针和慢指针相遇的地方，距离交点a的长度；而链表头节点距离环的起点也是a
此时找到了两个不同的点，距离环的起点都为a
此时把其中的一个指针设置回链表头节点，然后，p和q再一起往后走，当他们相遇的地方，就是环的起始点
在这里插入图片描述



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 *detectCycle(ListNode *head) {
		ListNode *p = head, *q = head;   

		while (q && q->next)
		{
			p = p->next;
			q = q->next->next;
			if (p == q) break;
		}
		// 此时p和q在环中相遇或者q为空地址或者q的下一个节点为空地址
		if (q == nullptr || q->next == nullptr) return nullptr;
		// 将其中一个指针置为头节点
		p = head;
		while (p != q) p = p->next, q = q->next;  // 重新出发，直到再次碰到，此时的指针指向环的开始

		return p;
	}
};

测试结果

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

Leetcode-92. 反转链表II

给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。

示例 1：

在这里插入图片描述
输入：head = [1,2,3,4,5], left = 2, right = 4
输出：[1,4,3,2,5]

示例 2：

输入：head = [5], left = 1, right = 1
输出：[5]

提示：

链表中节点数目为 n
1 <= n <= 500
-500 <= Node.val <= 500
1 <= left <= right <= n

进阶：

你可以使用一趟扫描完成反转吗？

题目解析：递归法

如果只看要反转的链表，相当于要反转一个普通的链表
大问题：反转链表的[left, right]
子问题：反转链表的[1, right - left + 1]
子问题：反转链表的[1, right - left ]
…
子问题：反转[1, 1]的链表，这个就不用反转了，就是边界条件

算法过程：

  1. 当前节点head还没递归到反转区域（left != 1），递归函数reverseBetween(head->next, left - 1, right - 1)得到反转后的链表，接到head当前节点的后面
    在这里插入图片描述
  2. 当前节点head递归到反转区域(left = 1)，递归函数reverseBetween(head->next, left, right - 1)得到反转后的链表，将head节点插入到反转区域的尾节点的后面
    在这里插入图片描述

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* reverseBetween(ListNode* head, int left, int right) {

		if (left == 1 && right == 1) return head;

		if (left != 1)   // 还没递归到待反转的区域
		{
			head->next = reverseBetween(head->next, left - 1, right - 1);
		}
		else { 
			ListNode *tail = head->next;   // 先记录反转后的尾节点，也就是当前节点的下一个节点
			ListNode *new_head;            // 反转完以后的头节点的地址
			new_head = reverseBetween(head->next, left, right - 1);   // 完成后半部分的反转
			// 将原来的头节点插入到反转区域的尾节点的后面
			head->next = tail->next;
			tail->next = head;
			head = new_head;
		}

		return head;
	}
};

测试结果

在这里插入图片描述
在这里插入图片描述

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/reverse-linked-list-ii

LAWKAWAI
关注
专栏目录
双链表详解(初始化、插入、删除、遍历)(数据结构与算法)
AII_IIA的博客
11-04 3013
同时，删除节点后必须确保释放相应的内存空间，以防止内存泄漏问题的发生。11. 双链表相较于单链表需要额外存储指向前一个节点的指针，因此会在空间上占用更多的内存。7. 双链表的每个节点包含三个部分：数据域、指向前一个节点的指针和指向下一个节点的指针。在双链表中删除节点的操作相对比较复杂，因为我们需要维护前驱节点和后继节点之间的指针连接。在双链表中插入节点需要更新前驱节点和后继节点的指针连接，操作相对比较复杂。将 p 结点的next指针，指向q结点的后继结点。程序设计如下：注意修改指针时要注意顺序！
Python数据结构之链表(1)-->单链表
weixin_30454481的博客
04-01 398
数据结构-链表 转载之(http://zhaochj.github.io/2016/05/12/2016-05-12-%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84-%E9%93%BE%E8%A1%A8/#) 什么是链表，我对这个概念非常陌生。 链表是实现了数据之间保持逻辑顺序，但存储空间不必按顺序的方法。可以用一个图来表示这种链表的数据结构： 　　　　　　　　　...
链表的结点个数统计及查找
2301_78772787的博客
11-02 697
在上述代码中，我们定义了一个变量cnt来存储节点个数，然后遍历链表并在每人节点处将cnt加1，最终返回count可得到链表的节点个数。要统计链表中的节点个数，只需要遍历整个链表，并在遍历的过程中计数即可。具体实现代码如下：(仍然使用C#)先定义一个整型函数(节点个数的返回值一定是整型变量)在main函数中调用定义一个ret并调用该函数。
17.计算链表节点个数 && 链表的查找
黄色的拉拉的博客
07-09 952
计算链表节点个数 && 链表的查找计算链表节点个数链表的查找示例 计算链表节点个数 int totalNodeNum(struct Test* phead) { int cnt=0; while(phead!=NULL) { cnt++; phead=phead->next; } return cnt; } 链表的查找 int searchNode(struct Test* phead,int data) { while(phead!=NULL) { i
链表节点个数及查找
weixin_50212958的博客
11-24 2004
链表节点个数 先定义一个整形函数，因为节点个数肯定是整型变量。 int huoqujiediannum(struct Test *head) { int cnt = 0; while(head != NULL){ cnt++; head = head->next; } printf("cnt++ = %d\n",cnt); return cnt; } 然后在main函数里面调用定义的函数。 int ret = huoqujied
leetcode25题：K 个一组翻转链表——链表困难题目详解
XHT117的博客
05-03 936
目录 题目 分析 代码实现 题目 给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。 k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。 你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。 提示： 链表中的节点数目为 n 1 <= k <= n <= 5000 0 <= Node.val <= 1000 进阶：你可以设...
Java题目详解——LeetCode160.相交链表
lil_ghost_的博客
10-24 530
我们看到这道题目肯定会先想：如何找到相交结点呢？或许这个问题可以转换为：如何使两条链表同时走到相交结点处？这时就能将该问题转换为一条链表比另一条链表遍历时 "先走几步" 的问题了。 据分析可得，如果两条链表有相交元素，那么他们从相交结点开始到链表结束，他们的结点数一定是相同的，不同的就是两条链表相交前的结点数。 我们知道了这点，就可以先分别求出链表A和链表B的总长度sizeA和sizeB，再使总长度相减，记为两条链表的长度差（d），如果他们相交，那么这个长
《算法和数据结构》题海战术篇
热门推荐
英雄哪里出来
09-12 5万+
刷了 3333 题 算法题 后的一点点经验总结 —— 题不是这么刷的！
【排序算法】归并排序——算法详解，题型举例，链表，数组
weixin_42157432的博客
04-04 442
「归并排序」是分治思想的典型应用，它包含这样三个步骤： 分解：待排序的区间为[l,r]，令m=l+((r-l)>>1),将区间分为[l,m],[m+1,r] 解决：使用归并排序递归地排序两个子序列 合并：把两个已经排好序的子序列[l,m]和[m+1,r]合并起来 在带排序序列长度为1的时候，递归开始【回升】，即默认长度为1时，序列时排好的。 ☆☆☆剑指 Offer 51. 数组中的逆序对 在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这
python算法题 链表反转详解
09-19
在计算机科学与编程领域中，链表是一种常见的数据结构，被广泛应用于各种场景之中。链表反转是链表操作中最基础且重要的操作之一，它不仅能够帮助理解链表的基本操作原理，还能够在实际应用中解决不少问题。本文将...
Python 数据结构之旋转链表
09-21
对于初学者来说，链表是一个非常重要的基础数据结构之一，它可以帮助我们理解数据结构的基本原理以及算法的设计思想。而“旋转链表”则是对链表进行的一种变形操作，即按照特定的方式重新排列链表中的元素顺序。 ##...
算法与数据结构 第五章 树与二叉树（详解）
m0_62205773的博客
05-06 3927
目录 一、判断题 二、选择题 在开始之前，先为大家推荐两篇介绍该章两个主要算法的的文章，供大家参考。 Huffman树：Huffman树 树，二叉树，森林的转化：树，二叉树，森林的转化 一、判断题 1、二叉树可以用二叉链表存储，树无法用二叉链表存储。F 解析：二叉树与树都可以用二叉链表作为存储结构，二者的关系是一棵树可以惟一对应一棵二叉树。 2、某二叉树的后序和中序遍历序列正好一样，则该二叉树中的任何结点一定都无左孩子。F 解析：某二叉树的后序和中序遍历序列正好一样，则该二叉树中的任何.
【数据结构】链表OJ特别篇 —— 面试情景带你深度剖析 环形链表系列问题 && 复制带随机指针的链表
StackFrame
11-09 1359
模拟面试情景详解：环形链表系列问题、复制带随机指针的链表
【数据结构-栈】力扣844. 比较含退格的字符串
sjsjs11的博客
09-23 452
使用了栈的方法，我们定义了两个新字符串res1和res2来记录s和t进行计算后的最终结果，最后看res1和res2是否相等。当s或t字符串中的字符不为#的时候，就将他推入到我们构造的新字符串中，如果字符为#，我们还要判断他是否为空，如果不为空的话，那么就将重构字符串的最后一个字符弹出。输入：s = “ab#c”, t = “ad#c”输入：s = “ab##”, t = “c#d#”解释：s 会变成 “c”，但 t 仍然是 “b”。输入：s = “a#c”, t = “b”
【数据结构】什么是二叉搜索(排序)树?
C/C++领域,数据结构,linux,MySQl学习者
09-20 1319
数据结构之二叉搜索树概念详解,内容包括:二叉搜索树的概念,二叉搜索树的操作(查找,插入,删除)逻辑详解及图示,二叉搜索树的应用以及二叉搜索树的性能分析。
数据结构之——单链表
m0_71974552的博客
09-23 1077
深入了解单链表：数据结构中的灵活利器
数据结构-C语言实现线性表的顺序存储结构
最新发布
m0_60984906的博客
09-23 291
数据结构与算法使用C语言实现线性表的顺序存储结构
数据结构—(java)反射，枚举，lambda表达式
2301_77993957的博客
09-20 1072
java的反射机制是指，在程序的运行状态中，对于任意一个类，可以获取这个类的全部信息（包括，类加载器（后面会学到），构造方法，成员属性，成员方法等。对于任意一个对象，我们也能够调用其属性与方法进行修改信息，这种动态地获取信息与动态地调用对象的机制，我们称为反射机制。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值