关于树的算法题（C++）

最新推荐文章于 2024-02-08 14:02:08 发布
最新推荐文章于 2024-02-08 14:02:08 发布
阅读量685 收藏 9
点赞数 2
分类专栏： 数据结构与算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39953502/article/details/82716797
版权

前段时间总结了一下关于树的算法，上传到博客，以后方便查看。

目录

二叉树的下一个节点

二叉树的镜像

对称二叉树

树的子结构

二叉树的路径

打印二叉树

重建二叉树

二叉搜索树第K大的节点

二叉搜索树变成双向链表

二叉搜索树的后序遍历

序列化二叉树

平衡二叉树

二叉树的下一个节点

/*
二叉树的下一个节点
给定一颗二叉树和其中一个节点，找到中序遍历的下一个节点，树中有指向左、右两个子树的指针，还有
指向父节点的指针
*/

Struct TreeNode{
	int val;
	TreeNode* left;
	TreeNode* right;
	TreeNode* parent;
	TreeNode(int x) : val(x), left(NULL), rihgt(NULL), parent(NULL){}
};


class Solution{
public:
	TreeNode* getNext(TreeNode* node){
		if(node == NULL){
			return NULL;
		}
		if(node->right != NULL){           //判断节点的右子树是否为空
			TreeNode* next = node->right;
			while(next->left != NULL){
				next = next->left;
			}
			return next;
		}
		while(node->parent != NULL){       //判断父节点是否为空
			TreeNode* next = node->parent;
			if(next->left == node){
				return next;
			}
			node = next;
		}
		return NULL;
	}
}

二叉树的镜像

/*
二叉树的镜像
操作给定的二叉树，将其变换为源二叉树的镜像。
*/

struct  TreeNode{
	int val;
	TreeNode* left;
	TreeNode* right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

class Solution
{
public:
	Solution();
	~Solution();
	
	// 递归版本
	void MirrorRecur(TreeNode* node){
		if(node == NULL){
			return;
		}
		TreeNode* tmp = node->left;
		node->left = node->right;
		node->right = tmp;
		MirrorRecur(node->left);
		MirrorRecur(node->right);
	}


	// 非递归版本
	void MirrorNonrecur(TreeNode* node){
		if(node == NULL){
			return;
		}
		stack<TreeNode*> tmp;
		tmp.push(node);
		while(!tmp.empty()){
			TreeNode* cur = tmp.top();
			tmp.pop();
			if(cur->left != NULL || cur->right != NULL){
				TreeNode* tmp = cur->left;
				cur->left = cur->right;
				cur->right = tmp;
			}
			if(cur->right != NULL){
				tmp.push(cur->right);
			}
			if(cur->left != NULL){
				tmp.push(cur->left);
			}
		}
	}
};

对称二叉树

/*
对称二叉树
实现一个函数，判断一颗二叉树是不是对称二叉树
*/

class Solution
{
public:
	Solution();
	~Solution();
	
	// 递归版本
	bool isSymRecur(TreeNode* node){
		if(node == NULL){
			return true;
		}
		return isSymCore(node->left, node->right);
	}
	bool isSymRecurCore(TreeNode* node1, TreeNode* node2){
		if(node1 == NULL && node2 == NULL){
			return true;
		}
		if(node1 == NULL || node2 == NULL || node1->val != node2->val){
			return false;
		}
		return isSymCore(node1->left, node2->right) && isSymCore(node1->rihgt, node2->left);
	}


	// 非递归版本
	bool isSymNonrecur(TreeNode* node){
		if(node == NULL){
			return true;
		}
		stack<TreeNode*> s1;
		stack<TreeNode*> s2;
		s1.push(node);
		s2.push(node);
		while(!s1.empty() && s2.empty()){
			TreeNode* cur1 = s1.top();
			s1.pop();
			TreeNode* cur2 = s2.top();
			s2.pop();
			if(cur1 == NULL && cur2 == NULL){
				continue;
			}
			if(cur1 == NUL || cur2 == NULL || cur1->val != cur2->val){
				return false;
			}
			s1.push(cur1->rihgt);
			s1.push(cur1->left);
			s2.push(cur2->left);
			s2.push(cur2->right);
		}
		if(s1.empty() && s2.empty()){
			return true;
		}
		return false;
	}

};

树的子结构

/*
树的子结构
输入两棵二叉树A、B，判断B是不是A的子结构（ps：我们约定空树不是任意一个树的子结构)
*/

class Solution
{
public:
	Solution();
	~Solution();
	
	// 递归版本
	bool hasSubtreeRecur(TreeNode* node1, TreeNode* node2){
		if(node1 == NULL || node2 == NULL){
			return false;
		}
		return isSubtreeRecur(node1, node2)
			|| hasSubtreeRecur(node1->left, node2)
			|| hasSubtreeRecur(node1->right, node2);
	}
	bool isSubtreeRecur(TreeNode* node1, TreeNode* node2){
		if(node2 == NULL){
			return true;
		}
		if(node1 == NULL){
			return false;
		}
		if(node1->val == node2->val){
			return isSubtreeRecur(node1->left, node2->left) 
			&& isSubtreeRecur(node1->right, node2->right);
		}
		return false;
	}

	// 非递归版本
	bool hasSubtreeNonrecur(TreeNode* node1, TreeNode* node2){
        if(node1 == NULL || node2 == NULL){
            return false;
        }
        queue<TreeNode*> tmp;
        tmp.push(node1);
        while(!tmp.empty()){
            TreeNode* cur = tmp.front();
            tmp.pop();
            bool target = false;
            if(cur->val == node2->val){
                target = isSubtree(cur, node2);
            }
            if(target){
                return true;
            }
            if(cur->left){
                tmp.push(cur->left);
            }
            if(cur->right){
                tmp.push(cur->right);
            }
        }
        return false;
    }
    
    bool isSubtreeNonrecur(TreeNode* node1, TreeNode* node2){
        stack<TreeNode*> s1;
        stack<TreeNode*> s2;
        s1.push(node1);
        s2.push(node2);
        while(!s1.empty() && !s2.empty()){
            TreeNode* cur1 = s1.top();
            s1.pop();
            TreeNode* cur2 = s2.top();
            s2.pop();
            if(cur2 == NULL){
                continue;
            }
            if(cur1 == NULL || cur1->val != cur2->val){
                return false;
            }
            s1.push(cur1->right);
            s1.push(cur1->left);
            s2.push(cur2->right);
            s2.push(cur2->left);
        }
        if(s2.empty()){
            return true;
        }
        return false;
    }
};

二叉树的路径

/*
二叉树中的和为某一值的路径
输入一棵二叉树和一个整数，打印二叉树中节点值的和为输入整数的路径。从树根节点往下直到叶节点
形成一条路径。
*/

class Solution
{
public:
	Solution();
	~Solution();
	

	vector<vector<int> > findPath(TreeNode* root, int num){
		vector<vector<int> > all;
		if(root ==  NULL){
			return all;
		}
		vector<int> path;
		findPathCore(root, all, path, num);
		return all;
	}

	void findPathCore(TreeNode* root, vector<vector<int> >& all, vector<int>& path, 
		int num){
		if(num < root->val){
			return;
		}
		path.push_back(root->val);
		if(num == root->val && root->left == NULL && root->right == NULL){
			all.push_back(path);
			path.pop_back();
			return;
		}
		if(root->left){
			findPathCore(root->left, all, path, num - root->val);
		}
		if(root->right){
			findPathCore(root->right, all, path, num - root->val);
		}
		path.pop_back();
	}
};

打印二叉树

/*
从上到下打印二叉树
从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。
*/

class Solution
{
public:
	Solution();
	~Solution();
	
	vector<vector<int> > print(TreeNode* root){
		vector<vector<int> > all;
		if(root == NULL){
			return all;
		}
		queue<TreeNode*> tmp;
		tmp.push(root);
		while(!tmp.empty()){
			vector<int> path;
			int size = tmp.size();
			for(int i = 0; i < size; i++){
				TreeNode* cur = tmp.front();
				tmp.pop();
				path.push_back(cur->val);
				if(cur->left){
					tmp.push(cur->left);
				}
				if(cur->right){
					tmp.push(cur->right);
				}
			}
			all.push_back(path);
		}
		return all;
	}
};

重建二叉树

/*
重建二叉树
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。
*/

class Solution
{
public:
	Solution();
	~Solution();
	
	TreeNode* reBuildBinaryTree(vector<int> pre, vector<int> vin){
		if(pre.size() == 0 || pre.size() != vin.size()){
			return NULL;
		}
	 	vector<int> preL, preR, vinL, vinR;
	 	int tar = 0;
	 	while(pre[0] != vin[tar]){
	 		tar++;
	 	}
	 	for(int i = 0; i < tar; i++){
	 		preL.push_back(pre[i + 1]);
	 		vinL.push_back(vin[i]);
	 	}
	 	for(int i = tar + 1; i < pre.size(); i++){
	 		preR.push_back(pre[i]);
	 		vinL.push_back(vin[i]);
	 	}
	 	TreeNode* cur = new TreeNode(pre[0]);
	 	cur->left = reBuildBinaryTree(preL, vinL);
	 	cur->right = reBuildBinaryTree(preR, vinR);
	 	return cur;
	}
};

二叉搜索树第K大的节点

/*
二叉搜索树的第K大的节点
给定一棵二叉搜索树，请找出其中的第k小的结点
*/

class Solution
{
public:
	Solution();
	~Solution();
	

	TreeNode* kthNodeRecur(TreeNode* root, int k){
		if(root == NULL || k <= 0){
			return NULL;
		}
		return kthNodeRecurCore(root, k);
	}

	TreeNode* kthNodeRecurCore(TreeNode* root, int& k){
		if(root == NULL || k <= 0){
			return NULL;
		}
		TreeNode* target = NULL;
		if(root->left){
			target = kthNodeRecurCore(root->left, k);
		}
		if(target == NULL){
			k--;
			if(k == 0){
				target = root;
			}
		}
		if(target == NULL && root->right){
			target = kthNodeRecurCore(root->right, k);
		}
		return target;
	}

	TreeNode* kthNodeNonrecur(TreeNode* root, int k){
		if(root == NULL || k <= 0){
			return NULL;
		}
		stack<TreeNode*> tmp;
		TreeNode* cur = root;
		while(cur != NULL || !tmp.empty()){
			if(cur != NULL){
				tmp.push(cur);
				cur = cur->left;
			}
			else{
				cur = tmp.top();
				tmp.pop();
				k--;
				if(k == 0){
					return cur;
				}
				cur = cur->right;
			}
		}
		return NULL;
	}
};

二叉搜索树变成双向链表

/*
二叉搜索树和双向链表
输入二叉搜索树，将二叉搜索树转换成一个排序的双向链表
*/

class Solution
{
public:
	Solution();
	~Solution();
	

	TreeNode* convertRecur(TreeNode* root){
		if(root == NULL){
			return;
		}
		TreeNode* pre = NULL;
		convertRecurCore(root, pre);
		while(root->left != NULL){
			root = root->left;
		}
		return root;
	}

	void convertRecurCore(TreeNode* root, TreeNode* &pre){
		if(root == NULL){
			return;
		}
		convertRecurCore(root->left, pre);
		root->left = pre;
		if(pre != NULL){
			pre->right = root;
		}
		pre = root;
		convertRecurCore(root->right, pre);
	}


	TreeNode* convertNonrecur(TreeNode* root){
		if(root == NULL){
			return NULL;
		}
		stack<TreeNode*> tmp;
		TreeNode* cur = root;
		TreeNode* pre = NULL;
		while(cur != NULL || !tmp.empty()){
			if(cur != NULL){
				tmp.push(cur);
				cur = cur->left;
			}
			else{
				cur = tmp.top();
				tmp.pop();
				cur->left = pre;
				if(pre != NULL){
					pre->right = cur;
				}
				pre = cur;
				cur = cur->right;
			}
		}
		while(root->left != NULL){
			root = root->left;
		}
		return root;
	}
};

二叉搜索树的后序遍历

/*
二叉搜索树的后序遍历序列
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历结果
*/

class Solution
{
public:
	Solution();
	~Solution();
	

	bool verifySquenceOfBST(vector<int> sequence){
		if(sequence.size() == 0){
			return false;
		}
		return verifySquenceOfBSTCore(sequence, 0, sequence.size() - 1);
	}

	bool verifySquenceOfBSTCore(vector<int> sequence, int start, int end){
		if(start < 0 || end >= sequence.size() || start > end){
			return false;
		}
		int i = start; 
		while(sequence[i] < sequence[end]){
			i++;
		}
		for(int j = i; j < end; j++){
			if(sequence[j] < sequence[size]){
				return false;
			}
		}
		return verifySquenceOfBSTCore(sequence, start, i - 1) && 
			verifySquenceOfBSTCore(sequence, i, end - 1);

	}

};

序列化二叉树

/*
序列化二叉树
实现两个函数，分别序列化和反序列化二叉树
*/

class Solution
{
public:
	Solution();
	~Solution();
	

	char* serialize(TreeNode* root){
		if(root == NULL){
			return NULL;
		}
		string str;
		serializeCore(root, str);
		char* tmp = new char[str.size() + 1];
		for(int i = 0; i < str.size(); i++){
			tmp[i] = str[i];
		}
		tmp[str.size()] = '\0';
		return tmp;
	}

	void serializeCore(TreeNode* root, string& str){
		if(root == NULL){
			str += '#';
			return;
		}
		str += to_string(root->val);
		str += ',';
		serializeCore(root->left, str);
		serializeCore(root->right, str);
	}


	TreeNode* deserialize(char* str){
		if(str == NULL){
			return NULL;
		}
		return deserializeCore(str);
	}
	TreeNode* deserializeCore(char* &str){
		if(*str == '#'){
			str++;
			return NULL;
		}
		int num = 0;
		while(*str != '/0' && *str != ','){
			num = num * 10 + (*str - '0');
			str++;
		}
		TreeNode* tmp = new TreeNode(num);
		if(*str == '\0'){
			return tmp;
		}
		else{
			str++;
		}
		tmp->left = deserializeCore(str);
		tmp->right = deserializeCore(str);
		return tmp;
	}
};

二叉树的深度

/*
二叉树的深度
输入一棵二叉树的根节点，求该树的深度
*/

class Solution
{
public:
	Solution();
	~Solution();
	
	int getTreeDepthRecur(TreeNode* node){
		if(node == NULL){
			return 0;
		}
		int left = getTreeDepthRecur(node->left);
		int right = getTreeDepthRecur(node->right);
		return (left > right) ? (left + 1) : (right + 1);
	}


	int getTreeDepthNonrecur(TreeNode* node){
		if(node == NULL){
			return 0;
		}
		queue<TreeNode*> tmp;
		tmp.push(node);
		int depth;
		while(!tmp.empty()){
			depth++;
			int size = tmp.size();
			for(int i = 0; i < size; i++){
				TreeNode* cur = tmp.front();
				tmp.pop();
				if(cur->left){
					tmp.push(cur->left);
				}
				if(cur->right){
					tmp.push(cur->right);
				}
			}
		}
		return depth;
	}
};

平衡二叉树

/*
平衡二叉树
输入一颗二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树任意节点的左右子树深度相差
不超过1，那么它就是一颗平衡二叉树。
*/

class Solution
{
public:
	Solution();
	~Solution();
	
	bool isBalanced(TreeNode* root){
		if(root == NULL){
			return false;
		}
		int depth = 0;
		return isBalanced(root, depth);
	}
	bool isBalanced(TreeNode* root, int &depth){
		if(root == NULL){
			depth = 0;
			return true;
		}
		int left = 0, right = 0;
		if(isBalanced(root->left, left) && isBalanced(root->right, right)){
			int diff = left - right;
			if(abs(diff) <= 1){
				depth = left > right ? (left + 1) : (right + 1);
				return true;
			}
		}
		return false;
	}
};

 

Meng
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 字典树详解(含例题)
jerry20183的博客
02-03 4317
C++ 字典树详解(含例题) 字典树的定义 顾名思义，就是一个像字典一样的树，谢谢观看 我们想要熟练的运用字典树，首先肯定要知道什么样的结构才会被称之为字典树吧。 字典树是一种树形结构，典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较———百度百科 从上面的百度百科的一段定义中，我们知道了字典树是：利用字符串的公共前缀来减少复杂度；用于统计，排序和保存大量字符串的数据结构
c++图与树算法题
Python自学记录
03-18 283
图与树 图结构：节点、边 分类：有向、无向 特殊的图：二叉树、普通树、堆 树的定义   树是由一个集合以及在该集合上定义的一种关系构成的，集合中的元素称为树的结点，所定义的关系称为父子关系。父子关系在树的结点之间建立了一个层次结构，在这种层次结构中有一个结点具有特殊的地位，这个结点称为该树的根结点。 数据结构中有很多树的结构，其中包括二叉树、二叉搜索树、2-3树、红黑树等等，本文着重介绍二叉树。 ...
哈夫曼编码与解码-二叉树的应用
Galaxy
05-09 911
哈夫曼编码与解码 【问题描述】读入n个字符所对应的权值，自底向上构造一棵哈夫曼树，自顶向下生成每一个字符对应的哈夫曼编码，并依次输出。另，求解某字符串的哈夫曼编码，求解某01序列的译码。 【输入形式】输入的第一行包含一个正整数n，表示共有n个字符需要编码。其中n不超过100。第二行中有n个用空格隔开的正整数，分别表示n个字符的权值，依次按照abcd…的默认顺序给出。然后是某字符串和某01序列。 【输出形式】前n行，每行一个字符串，表示对应字符的哈夫曼编码。然后是某字符串的哈夫曼编码，某01序列的译码。 【注
二叉树常见题目及C++实现
李滚滚的博客
05-06 1935
文章目录题目一 实现二叉树先序中序后序遍历，包括递归和非递归实现题目二：如何直观地打印一颗二叉树题目三：在二叉树中找到某一个节点的后继节点 题目一 实现二叉树先序中序后序遍历，包括递归和非递归实现   关于三种遍历方式的递归在数据结构的课本上应该写的很清楚，理解起来很简单，不多做总结。   通过看视频多了一点理解，在二叉树的递归遍历中，因为递归实现本质上是个系统栈，所以每个节点都会访问到三次，包括...
7-30目录树 C++题解 思路清晰
qq_43481884的博客
09-03 1244
目录数据结构的设计算法设计1.建树2.输出3.合并总结 题目链接 在ZIP归档文件中，保留着所有压缩文件和目录的相对路径和名称。当使用WinZIP等GUI软件打开ZIP归档文件时，可以从这些信息中重建目录的树状结构。请编写程序实现目录的树状结构的重建工作。 输入格式： 输入首先给出正整数N（≤104 ），表示ZIP归档文件中的文件和目录的数量。随后N行，每行有如下格式的文件或目录的相对路径和名称（每行不超过260个字符）： 路径和名称中的字符仅包括英文字母（区分大小写）； 符号“\”仅作为路径分隔符出现；
数据结构——B-树（c++）
weixin_48560325的博客
05-18 2552
简介 在计算机科学中，B树（英语：B-tree）是一种自平衡的树，能够保持数据有序。这种数据结构能够让查找数据、顺序访问、插入数据及删除的动作，都在对数时间内完成。B树，概括来说是一个一般化的二叉查找树（binary search tree），可以拥有多于2个子节点。与自平衡二叉查找树不同，B树为系统大块数据的读写操作做了优化。B树减少定位记录时所经历的中间过程，从而加快存取速度。B树这种数据结构可以用来描述外部存储。这种数据结构常被应用在数据库和文件系统的实现上。 定义 一颗m阶B-T...
C++ Trie树算法
struct_GS的博客
08-12 1183
什么是Trie树： 又称单词查找树，字典树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希树高。 至于Trie树长什么样子呢？ ...
C++实现哈夫曼树算法
08-19
C++实现哈夫曼树算法 C++实现哈夫曼树算法是对哈夫曼树数据结构的实现，哈夫曼树是一种特殊的二叉树，它的每个叶子节点都带有一个权值，所有叶子节点的权值之和为1，哈夫曼树的构建是基于哈夫曼编码的原理。下面是...
决策树算法的C++实现
05-08
本项目提供了一个C++实现决策树算法的实例，其中输入的数据集存放在`Tree1`文件夹内。 决策树的基本思想是通过构建一棵树形结构来模拟一系列的决策过程。每个内部节点代表一个特征或属性测试，每个分支代表一个测试...
C++ 面试算法题.zip
01-20
这份"C++面试算法题.zip"文件显然包含了一份详尽的资源，旨在帮助C++和C程序员提升技能，顺利通过大厂的面试。以下是根据标题、描述以及标签所推测出的一些核心知识点： 1. **C++基础语法**：包括但不限于变量、...
C++ 小白入门leetcode (三）——tree 树 简单题目 详细解析
www_z_dd的博客
03-14 841
Tree C++ 100. 相同的树 给定两个二叉树，编写一个函数来检验它们是否相同。 如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。 一： class Solution { public: static string s; bool isSameTree(TreeNode* p, TreeNode* q) { if(p==NULL&a...
965. Univalued Binary Tree
GGGGITFKBJG的主页
12-30 103
965. 单值二叉树 如果二叉树每个节点都具有相同的值，那么该二叉树就是单值二叉树。 只有给定的树是单值二叉树时，才返回true；否则返回 false。 示例 1： 输入：[1,1,1,1,1,null,1] 输出：true 示例 2： 输入：[2,2,2,5,2] 输出：false 提示： 给定树的节点数范围是[1, 100]。 每个节点的值都是整数，范围为[0, ...
【LeetCode】C++ ：简单题 - 树 572. 另一个树的子树
weixin_44566432的博客
01-11 96
572. 另一个树的子树 难度简单424 给定两个非空二叉树s和t，检验s中是否包含和t具有相同结构和节点值的子树。s的一个子树包括s的一个节点和这个节点的所有子孙。s也可以看做它自身的一棵子树。 示例 1: 给定的树 s: 3 / \ 4 5 / \ 1 2 给定的树 t： 4 / \ 1 2 返回true，因为 t 与 s 的一个子树拥有相同的结构和节点值。 示例 2: 给定的树 s： ...
链表经典算法题
Frank的博客
10-03 1683
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。
【数据结构】链表经典算法题集锦
林慢慢的博客
09-12 9576
前言：本章将分享十一道来自LeetCode/牛客网中的经典链表算法题来介绍数据结构中链表在算法题中的应用。 文章目录1.删除链表元素思路分析：题解：2.反转链表思路分析：题解：3.链表中间结点思路分析（快慢指针法）：题解：4.链表中倒数第K个结点思路分析（快慢指针法）：题解：5.合并两个有序链表思路分析：题解：6.链表分割思路分析：题解：7.链表的回文结构(第2题和第3题的综合)思路分析：题解：8.相交链表思路分析：题解：9.环形链表I思路分析：题解：10.环形链表II思路分析：题解：11.复制带随机指针
【数据结构与算法-链表经典例题汇总】
是小武呀
03-01 1668
【数据结构与算法-链表经典例题汇总】典例1、链表逆序-a（easy）典例1、链表逆序-b（medium）典例2、求两个链表的交点-（easy）典例3、链表求环 - （medium）典例4、链表划分- (medium)典例5、复杂链表的深度拷贝 - (hard)典例6、排序链表的合并a-两个（easy）典例6、排序链表的合并b-多个（hard） 典例1、链表逆序-a（easy） 题目描述： 思路：依次遍历链表的节点，每遍历一个节点就逆置一个节点 。 LeetCode提交OJ测试链接: OJ
六道链表经典算法题，带你体验链表算法魅力
最新发布
2301_80157147的博客
02-08 977
给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点这道题读完题目的话很多人的思路是遍历链表，根据节点个数，然后返回中间节点但今天我们讲的思路称之为快慢指针既然是快慢指针，那么一定有两个指针，并且两个指针的前进速度也不相同所以在这里，快指针一次前进两个节点，慢指针一次前进一个节点这样的话，当节点是奇数时，快指针的next指向NULL时，慢指针刚好在中间位置当节点是偶数是，当快指针指向为NULL时，慢指针也在第二个中间节点这样代码就完成了。
链表的经典算法题
Alaskan_Husky的博客
11-19 138
链表是常见的数据结构之一，有许多经典的算法问题涉及到链表。将链表反转，即将原链表的每个节点的指针方向反向。判断链表中是否存在环，即链表是否形成了一个闭环。将两个有序链表合并成一个有序链表。删除有序链表中的重复元素，使每个元素只出现一次。删除链表中倒数第N个节点。找到链表的中间节点，如果有两个中间节点，返回第二个。交换链表中相邻的节点，返回新的头节点。判断链表是否是回文结构，即链表从前往后和从后往前读是相同的。找到环形链表的起始节点。找到两个链表相交的起始节点。
链表经典算法题总结(一)
zag666的博客
06-14 736
136. 只出现一次的数字 给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。 说明：算法应该具有线性时间复杂度，不使用额外空间来实现. 示例 1: 输入: [2,2,1] 输出: 1 示例 2: 输入: [4,1,2,1,2] 输出: 4 思路： 不需要额外空间的方法，就往位运算上想 相同的数异或为0 任何数与0异或为任何数 异或运算满足交换律和结合律 题解： class Solution { public int singleNumber(
二叉排序树算法实现C++
01-01
以下是一个用C++实现的二叉排序树算法的示例： ```cpp #include using namespace std; // 树节点类定义 class TNode { public: int data; TNode* left, * right; TNode(int d) :left(nullptr), right(nullptr)...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值