二叉树的简单实现

已于 2024-04-23 18:41:32 修改
阅读量993 收藏 37
点赞数 53
分类专栏： 数据结构 文章标签： 数据结构
于 2024-04-20 22:00:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangshishiwang/article/details/137976487
版权

目录

​编辑

一.树的概念及结构

1.1树的概念

1.2树的结构

​编辑二.二叉树的概念和结构

2.1二叉树的概念

2.2二叉树的性质

2.21二叉树的顺序储存

2.22二叉树的链式储存

2.3堆的实现

2.31堆的概念

三.二叉树链式结构的实现

3.1二叉树的遍历

四.二叉树的题目

现在我们讲一下关于二叉树的基本知识吧.

一.树的概念及结构

1.1树的概念

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它 叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。

  • 1有一个特殊的结点，称为根结点，根节点没有前驱结点
  • 2除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集 合Ti(1<= i <= m)又是一棵结构与树类似的子树。
  • 3每棵子树的根结点有且只有一个前驱，可以 有0个或多个后继
  • 4因此，树是递归定义的

https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=%E5%BC%95%E7%94%A8%E9%93%BE%E6%8E%A5http%3A%2F%2Ft.csdnimg.cn%2F33FzQ&pos_id=TY2yWyXG

  • 节点的度：一个节点含有的子树的个数称为该节点的度； 
  • 叶节点或终端节点：度为0的节点称为叶节点； 
  • 非终端节点或分支节点：度不为0的节点； 
  • 双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点； 
  • 孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点； 
  • 兄弟节点：具有相同父节点的节点互称为兄弟节点； 
  • 树的度：一棵树中，最大的节点的度称为树的度； 
  • 节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
  • 树的高度或深度：树中节点的最大层次； 
  • 节点的祖先：从根到该节点所经分支上的所有节点；
  • 子孙：以某节点为根的子树中任一节点都称为该节点的子孙。
  • 森林：由m（m>0）棵互不相交的多颗树的集合称为森林；（数据结构中的学习并查集本质就是森林

1.2树的结构

树的结构有孩子兄弟表示法,双亲表示法等等,但是一般孩子兄弟表示法是使用最广泛的

下面是孩子兄弟表示法的使用

typedef int DateType;
typedef struct TreeNode{
DateType x;
struct BinaryTreeNode*child;
struct BinaryTreeNode*bro;
}TreeNode;

https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=%E5%BC%95%E7%94%A8%E9%93%BE%E6%8E%A5http%3A%2F%2Ft.csdnimg.cn%2F33FzQ&pos_id=TY2yWyXG二.二叉树的概念和结构

2.1二叉树的概念

概念 一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子 树和右子树的二叉树组成。 二叉树的特点： 

1. 每个结点最多有两棵子树，即二叉树不存在度大于2的结点。

2. 二叉树的子树有左右之分，其子树的次序不能颠倒。

特殊的二叉树:满二叉树,完全二叉树:

满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。
完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。           
 

2.2二叉树的性质

  • 二叉树的左孩子是2*parent+1(child,parent是下标)
  • 右孩子是2*parent+2
  • 父母是(child-1)/2(因为有计算机有向下取整的特性)

2.21二叉树的顺序储存

顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。而现实中使用中只有堆才会使用数组来存储。二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。

2.22二叉树的链式储存

二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的 方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩 子和右孩子所在的链结点的存储地址 。链式结构又分为二叉链和三叉链，当前我们学习中一般都 是二叉链，后面课程学到高阶数据结构如红黑树等会用到三叉链。

   // 二叉链
   struct BinaryTreeNode
   {
    struct BinTreeNode* _pLeft; // 指向当前节点左孩子
    struct BinTreeNode* _pRight; // 指向当前节点右孩子
    BTDataType _data; // 当前节点值域
   }
   // 三叉链
   struct BinaryTreeNode
   {
    struct BinTreeNode* _pParent; // 指向当前节点的双亲
    struct BinTreeNode* _pLeft; // 指向当前节点左孩子
    struct BinTreeNode* _pRight; // 指向当前节点右孩子
    BTDataType _data; // 当前节点值域
   }；

2.3堆的实现

2.31堆的概念

如果有一个关键码的集合K = {k0，k1， k2，…，kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki <= K2i+1 且 Ki<= K2i+2 (Ki >= K2i+1 且 Ki >= K2i+2) i = 0，1，2…，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

图链接：https://blog.csdn.net/weixin_45796387/article/details/114994648

#include"Heap.h"
void AdjustDown(HPDataType* h, int n, int parent);

void HeapInit(Heap* ph){
	assert(ph);
	ph->size = ph->capacity = 0;
	ph->h = NULL;
}
void HeapInitArray(Heap* ph, HPDataType*a, int n)
{
	assert(ph);
	ph->h = (HPDataType*)malloc(sizeof(HPDataType) * n);
	if (ph->h==NULL)
	{
		printf("error");
		return;
	}
	memcpy(ph->h,a, sizeof(HPDataType)*n);
	ph->size = n;
	ph->capacity =  n;

	for (int i = (ph->size - 2) / 2; i >= 0; i--)
		
	{
		AdjustDown(ph->h, ph->size, i);
	}

}

void HeapDestroy(Heap* ph)
{
	assert(ph);
	free(ph->h);
	ph->h = NULL;
	ph->capacity = ph->size = 0;
	
	
}

void swap(HPDataType *a, HPDataType * b)
{
	HPDataType tem = *a;
	*a = *b;
	*b = tem;
}

void AdjustUP(HPDataType* h, int child)
{
	int parent = (child - 1) / 2;
	while (child>0)
	{
		if (h[parent] > h[child])
		{
			swap(h[parent], h[child]);
			child = parent;
			parent = (parent - 1) / 2;

	    }
		else
		{
			break;
		}
	}



}

void HeapPush(Heap* ph, HPDataType x)
{
	assert(ph);
	if (ph->size == ph->capacity)
	{
		int newcapacity = ph->capacity == 0 ? 4 : 2 * ph->capacity;
		HPDataType* tem = (HPDataType*)realloc(ph->h, newcapacity * sizeof(HPDataType));
		if (tem == NULL)
		{
			 
			perror("Memory allocation failed in HeapPush");
			return;
		}
		ph->capacity = newcapacity;
		ph->h = tem;
	}
	ph->h[ph->size] = x;
	ph->size++;
	AdjustUP(ph->h, ph->size - 1);
}
HPDataType HeapTop(Heap* ph)
{
	assert(ph);
	return ph->h[0];

}
void AdjustDown(HPDataType* h, int n,int parent)
{
	assert(h);
	int child = 2 * parent + 1;
	while (child < n) {
		if (child+1<n&&h[child] > h[child + 1])
			
		{
			child++;
		}
		if (h[child]<h[parent])
		{
			swap(h[child], h[parent]);
			parent = child;
			child = 2 * parent + 1;
		}
		else 
			break;
	}

}
//先直接来交换首尾巴,在删除调整,为什么不直接删除,这样的话,会出现父亲的兄弟变成自己的兄弟
void HeapPop(Heap* ph)
{
	assert(ph);
	assert(ph->size);
	swap(&ph->h[0], &ph->h[ph->size - 1]);
	ph->size--;
	AdjustDown(ph->h,ph->size,0);

}
bool HeapEmpty(Heap*ph)
{
	assert(ph);
	return ph->size == 0;

}

三.二叉树链式结构的实现

3.1二叉树的遍历

二叉树的遍历:二叉树的遍历分为几种,层序遍历,前序遍历,中序遍历,后序遍历,是一种基本的方式,按一定的搜索路线遍历每一个节点

  • NLR：前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
  • LNR：中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
  • LRN：后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。

                   

层序遍历：除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。设二叉树的 根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然 后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问 树的结点的过程就是层序遍历

typedef char BTDataType;

typedef struct BinaryTreeNode
{
	BTDataType _data;
	struct BinaryTreeNode* _left;
	struct BinaryTreeNode* _right;
}BTNode;




typedef BTNode* QDataType;
// 链式结构：表示队列 
typedef struct QListNode
{
	struct QListNode* _next;
	QDataType _data;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* _front;
	QNode* _rear;
}Queue;




BTNode* CreateBTNode(BTDataType x);
// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi);
// 二叉树销毁
void BinaryTreeDestory(BTNode** root);
// 二叉树节点个数
int BinaryTreeSize(BTNode* root);
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root);
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k);
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
// 二叉树前序遍历 
void BinaryTreePrevOrder(BTNode* root);
// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root);
// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root);







// 初始化队列 
void QueueInit(Queue* q);
// 队尾入队列 
void QueuePush(Queue* q, QDataType data);
// 队头出队列 
void QueuePop(Queue* q);
// 获取队列头部元素 
QDataType QueueFront(Queue* q);
// 获取队列队尾元素 
QDataType QueueBack(Queue* q);
// 获取队列中有效元素个数 
int QueueSize(Queue* q);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q);
// 销毁队列 
void QueueDestroy(Queue* q);



// 层序遍历
void BinaryTreeLevelOrder(BTNode* root);
// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root);



// 初始化队列 
void QueueInit(Queue* q)
{
	assert(q);
	q->_front = q->_rear = NULL;
}
// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode *newnode = ((QNode*)malloc(sizeof(QNode)));
	newnode->_data = data;
	newnode->_next = NULL;
	if (q->_rear == NULL)
	{
		q->_front = q->_rear = newnode;
	}
	else
	{
		q->_rear->_next = newnode;
		//q->_rear = q->_rear->_next;
		q->_rear = newnode;
	}
}
// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	if (q->_front == q->_rear)
	{
		free(q->_front);
		//free(q->_rear);
		q->_front = q->_rear = NULL;
	}
	else
	{
		QNode *cur = q->_front->_next;
		free(q->_front);
		q->_front = cur;
	}
}
// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->_front->_data;
}
// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->_rear->_data;
}
// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{
	assert(q);
	int size = 0;
	QNode* cur = q->_front;
	while (cur)
	{
		++size;
		cur = cur->_next;
	}
	return size;
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q)
{
	assert(q);
	return q->_front == NULL ? 1 : 0;
}
// 销毁队列 
void QueueDestroy(Queue* q)
{
	assert(q);
	QNode *cur = q->_front;
	while (cur)
	{
		QNode *next = cur->_next;
		free(cur);
		cur = next;
	}
	q->_front = q->_rear = NULL;
}






BTNode* CreateBTNode(BTDataType x)
{
	BTNode *node = (BTNode*)malloc(sizeof(BTNode));
	node->_data = x;
	node->_left = NULL;
	node->_right = NULL;
	return node;
}


// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi)
{
	if (a[*pi] == '#')
	{
		return NULL;
	}
	BTNode *node = (BTNode*)malloc(sizeof(BTNode));
	node->_data = a[*pi];
	++*pi;
	node->_left = BinaryTreeCreate(a, n, pi);
	++*pi;
	node->_right = BinaryTreeCreate(a, n, pi);
	return node;
}
// 二叉树销毁
void BinaryTreeDestory(BTNode** root)
{
	if (*root != NULL)
	{
		if ((*root)->_left) // 有左孩子
			BinaryTreeDestory(&(*root)->_left); // 销毁左孩子子树
		if ((*root)->_right) // 有右孩子
			BinaryTreeDestory(&(*root)->_right); // 销毁右孩子子树

		free(*root); // 释放根结点
		*root = NULL; // 空指针赋NULL
	}
}
// 二叉树节点个数
int BinaryTreeSize(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	return BinaryTreeSize(root->_left) + BinaryTreeSize(root->_right) + 1;
}
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	if (root->_left == NULL&&root->_right == NULL)
	{
		return 1;
	}
	return BinaryTreeLeafSize(root->_left) + BinaryTreeLeafSize(root->_right);
}
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
	if (root == NULL)
	{
		return 0;
	}
	if (k == 1)
	{
		return 1;
	}
	return BinaryTreeLevelKSize(root->_left, k - 1) + BinaryTreeLevelKSize(root->_right, k - 1);
}
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)
	{
		return NULL;
	}
	if (root->_data == x)
	{
		return root;
	}
	BTNode* ret=BinaryTreeFind(root->_left,x);
	if (ret != NULL)
	{
		return ret;
	}
	ret = BinaryTreeFind(root->_right, x);
	if (ret != NULL)
	{
		return ret;
	}
	return NULL;
}
// 二叉树前序遍历 
void BinaryTreePrevOrder(BTNode* root)
{
	if (root == NULL)
	{
		//printf("NULL  ");
		return;
	}
	printf("%c  ", root->_data);
	BinaryTreePrevOrder(root->_left);
	BinaryTreePrevOrder(root->_right);
}
// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root)
{
	if (root == NULL)
	{
		//printf("NULL  ");
		return;
	}
	BinaryTreeInOrder(root->_left);
	printf("%c  ", root->_data);
	BinaryTreeInOrder(root->_right);
}
// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root)
{
	if (root == NULL)
	{
		//printf("NULL  ");
		return;
	}
	BinaryTreePostOrder(root->_left);
	BinaryTreePostOrder(root->_right);
	printf("%c  ", root->_data);
}
// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
	{
		QueuePush(&q, root);
	}
	while (!QueueEmpty(&q))
	{
		BTNode *front = QueueFront(&q);
		QueuePop(&q);
		printf("%c  ", front->_data);
		if (front->_left)
		{
			QueuePush(&q, front->_left);
		}
		if (front->_right)
		{
			QueuePush(&q, front->_right);
		}
	}
}
// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
	{
		QueuePush(&q, root);
	}
	while (!QueueEmpty(&q))
	{
		BTNode *front = QueueFront(&q);
		QueuePop(&q);
		if (front == NULL)
		{
			break;
		}
		printf("%s ", front->_data);
		if (front->_left)
		{
			QueuePush(&q, front->_left);
		}
		if (front->_right)
		{
			QueuePush(&q, front->_right);
		}
	}
	while (!QueueEmpty(&q))
	{
		BTNode *front = QueueFront(&q);
		QueuePop(&q);
		if (front != NULL)
		{
			return 0;
		}
	}
	return 1;

}

四.二叉树的题目

创作不易希望收藏

wangshishiwang
关注
  • 53
    点赞
  • 踩
  • 37
    收藏
    觉得还不错? 一键收藏
  • 31
    评论
专栏目录
C语言实现二叉树遍历
daqiangdetianxia的博客
05-25 2406
一：实验目的 (1)掌握二叉树的数据类型描述方法及二叉树的特征 (2)掌握二叉树的链式存储结构的建立算法 (3 掌握二叉表上二叉树的基本运算的实现 二：实验内容 （1）用递归实现二叉树的前序，中序，后序的3种遍历 （2）用非递归实现二叉树的前序，中序，后序3种遍历 三：实验要求 （1）根据实验内容编写程序，上机调试并获得运行结果。 四：程序清单、调试和测试结果及分析 #include<stdio.h> #include<stdlib.h> #define datatype in
简单完全二叉树的实现
zzzypp的专栏
02-05 1391
完全二叉树的自定义实现
二叉树简单实现（C语言版）
2301_79813267的博客
12-30 1146
对于这棵树，是不是可以看成左子树+右子树+树根，也就是左子树+右子树+1，左子树是不是也可以继续看成左子树+右子树+树根，即左子树+右子树+1，右子树同理，所以我们因此就实现了递归。要解决这个问题，关键是在于要知道什么是叶子节点，是不是它的左右子叶都是NULL，那么递归是不是就好理解了，如果为NULL，0个叶，如果左右子叶都是NULL，它为子叶。求第K层节点个数，这是不是也是一个递归的题目，当K==1时，是不是就是一个节点，当k>1时，是不是可以依次递减。
java实现简单二叉树
99Savage
07-09 641
二叉树
二叉树的实现
nan1010894558的博客
11-11 603
主要代码; /**************************************************** @Title: 数据结构实验 @Name: 遍历二叉树及其应用 @Object: [实验目的] 实现二叉树的二叉链表存储结构； 实现先序、中序和后序遍历二叉树； 遍历二叉树的应用:计算叶子结点
二叉树简单实现
03-21
适用于初学者，代码简单易懂，没有太多的库函数，实现了前序遍历，后序遍历，中序遍历以及层次遍历
二叉树实现简易计算器
10-10
### 二叉树实现简易计算器 #### 概述 本文档介绍了一个利用二叉树来实现简易计算器的程序。此程序能够处理用户通过键盘输入的中缀表达式，并将其转换为二叉表达式树，进而通过后序遍历计算出表达式的值。此外，...
JS二叉树的简单实现方法示例
10-20
JavaScript实现二叉树涉及的概念主要包括了二叉树的定义、遍历、插入、删除、查找、排序等基本操作。在实际编程中，通过定义一个节点类（Node）以及一个二叉搜索树类（BST）来实现这些操作。 首先，定义一个节点类...
图解大顶堆的构建、排序过程
sagima_sdu的博客
08-12 511
开始，
【长度最小的子数组】python刷题记录
m0_73629042的博客
08-12 250
【代码】【长度最小的子数组】python刷题记录。
深入理解MySQL索引：原理、数据结构与优化策略
乙壳虫的博客
08-16 632
索引类似于一本书的目录，它可以帮助我们快速定位到需要的内容。没有索引时，MySQL 需要遍历整个表来找到目标记录，而索引通过构建特定的结构，可以加速查找的过程。索引的主要作用是提高数据库查询效率，减少数据库检索的行数，从而提升查询速度。B-Tree 索引：这是 MySQL 中最常见的索引结构，适用于大多数场景。B-Tree 是平衡树的一种，能够保持数据有序，从而加快查找速度。哈希索引（Hash Index）：通过将键映射为固定大小的哈希值来加速查找，适用于精确查找。
知识改变命运 数据结构【洗牌算法(顺序表)】
2402_84062064的博客
08-13 284
a：这个类里面包括一个String类型的数据和int数据类型的数据分别存储花色和牌号b：创建一个构造方法对牌号和花色赋值·c：进行toString重写a：创造一个数组里面包含了四种花色b：利用for循环对花色与牌号结合 然后赋值给牌中。
数据结构----链表
新手嵌入式学习的博客
08-16 1003
数据结构顺序表中单向链表（包括有头单向链表，无头单向链表，单向循环链表）
C语言基础编程题：第 k 小整数（C语言版，采用冒泡排序）
我就知道你会来，我们一起进步吧！
08-13 281
现有n个正整数，要求出这 n 个正整数中的第k个最小整数(相同大小的整数只计算一次)。第一行为 n 和 k;第二行开始为 n 个正整数的值，整数间用空格隔开。n< 10000，k< 1000，正整数均小于 30000.第k个最小整数的值;若无解，则输出NO RESULT。
【数据结构篇】~顺序表
最新发布
2301_81806517的博客
08-16 447
【数据结构篇】~顺序表
uva1586分子量（Molar Mass,ACM/ICPC Danang 2007）
2301_80844586的博客
08-14 227
然后代码具体要考虑i++每次进行i++自动i++这样避免算完字母后碰到数字然后会多算一次字母。就是一位算数字后i++如果【i+2】就是匹配到两位数的话再次i++；这样可以有效避免数字越界（你可以好好思考一下）如果都没有就是1直接定义1即可。第一个是有四个字母然后把for循环中匹配到的字母进行确认到z里面后面进行。第二的大逻辑就行下面的if那个三大判断条件第一个是一位数并且是。也是改了小两天，然后说一下核心代码逻辑两大块的核心。就是没有数字的就是1的。
每日OJ_牛客HJ75 公共子串计算
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
08-12 541
每日OJ_牛客HJ75 公共子串计算（求最大公共子串，使用递推实现 假设 x(i)：字符串第i个字符 y(j)：字符串第j个字符 dp[i][j]：以x(i)，y(j)结尾的最大子串长度。比如：x: "abcde" y:"bcdae" dp[2][1]：以x(2)，y(1)结尾的最大子串长度即：x遍历到"abc"，y遍历 到"bc"，都以字符'c'结尾时最大公共子串为"bc"）
数据结构之红黑树
我要学编程的博客
08-16 592
红黑树的概念、性质、插入、验证； AVL树和红黑树的比较
评论 31
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值