标准库STL算法Algorithm

已于 2025-01-21 21:31:01 修改
阅读量417 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构与算法 文章标签： 算法 数据结构
于 2018-11-08 16:55:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/WSTONECH/article/details/83862326
本文详细解析了求解二叉树最小深度的两种算法：递归法和层序遍历法。递归法通过判断左右子树的深度来确定最小深度，而层序遍历法则采用广度优先搜索策略，逐层遍历直至找到首个叶子节点。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

​

Non-modifying sequence operations

Modifying sequence operations

​Partitions

Sorting

​Binary search

Merge

Heap

Min/max

Other

​        The header <algorithm> defines a collection of functions especially designed to be used on ranges of elements.

        A range is any sequence of objects that can be accessed through iterators or pointers, such as an array or an instance of some of the STL containers. Notice though, that algorithms operate through iterators directly on the values, not affecting in any way the structure of any possible container (it never affects the size or storage allocation of the container).

Non-modifying sequence operations

存在：all_of 、any_of、 none_of

    vector<int>nums{ 1,2,3,4,5,6,7,8,9 };
	std::cout << boolalpha;
	{
		//bool all_of (InputIterator first, InputIterator last, UnaryPredicate pred)		
		bool bGreaterZero = std::all_of(nums.begin(), nums.end(), [](int i) { return i > 0; });
		std::cout << "nums全部大于0:" << bGreaterZero << std::endl;

		//bool any_of (InputIterator first, InputIterator last, UnaryPredicate pred)
		bool bExistEven = std::any_of(nums.begin(), nums.end(), [](int i) { return (i & 1) == 0; });
		std::cout << "nums存在偶数:" << bExistEven << std::endl;

		//bool none_of (InputIterator first, InputIterator last, UnaryPredicate pred)
		bool bNoExistOdd = std::none_of(nums.begin(), nums.end(), [](int i) { return (i & 1) == 1; });
		std::cout << "nums不存在奇数:" << bNoExistOdd << std::endl;
	}

/*
nums全部大于0:true
nums存在偶数:true
nums不存在奇数:false
*/

遍历：for_each

Function for_each(InputIterator first, InputIterator last, Function fn)

for_each(nums.begin(), nums.end(), [](int num) {std::cout << " " << num << " "; });

//1  2  3  4  5  6  7  8  9

查找：find、find_if、find_if_not

// InputIterator find (InputIterator first, InputIterator last, const T& val) find first equals val
	{
		auto iter = std::find(nums.begin(), nums.end(), 4);
		if (iter != nums.end())
		{
			std::cout << std::endl << "找到nums中：" << *iter << std::endl;
		}
	}

	//InputIterator find_if (InputIterator first, InputIterator last, UnaryPredicate pred) find first
	{
		auto iter = std::find_if(nums.begin(), nums.end(), [](int num) { return num % 3 == 0; });
		std::cout << "nums中第一个3的倍数：" << *iter << std::endl;
	}

	//InputIterator find_if_not (InputIterator first, InputIterator last, UnaryPredicate pred)
	{
		//第一个不满足pred（返回false）的元素
		auto iter = std::find_if_not(nums.begin(), nums.end(), [](int num) { return (num & 1) == 1; });
		std::cout << "nums中第一个偶数：" << *iter << std::endl;
	}

/*
找到nums中：4
nums中第一个3的倍数：3
nums中第一个偶数：2
*/

查找序列匹配 :find_first_of find_end

//寻找最先匹配的序列
	{
		vector<int>nums1{ 1,2,3,4,5,6,7,6,5,1,2,3,4 };
		vector<int>nums2{ 1,2,3,4 };
		auto it = std::find_first_of(nums1.begin(), nums1.end(), nums2.begin(), nums2.begin() + 3);
		if (it != nums1.end())
		{
			std::cout << "nums中最先完全匹配123的起始下标:" << (it - nums1.begin()) << endl;
		}
		auto it2 = std::find_first_of(nums1.begin(), nums1.end(), nums2.begin(), nums2.begin() + 3, [](int i, int j) { return i == j + 1; });
		if (it2 != nums1.end())
		{
			std::cout << "nums中最先匹配123每个+1的起始下标:" << (it2 - nums1.begin()) << endl;
		}
	}

//nums中最先完全匹配123的起始下标:0
//nums中最先匹配123每个+1的起始下标:1
	//寻找最后匹配的序列
	{
		vector<int>nums1{ 1,2,3,4,5,6,7,6,5,1,2,3,4 };
		vector<int>nums2{ 1,2,3,4 };
		auto it = std::find_end(nums1.begin(),nums1.end(), nums2.begin(), nums2.begin()+3);
		if (it != nums1.end())
		{
			std::cout << "nums中最后完全匹配123的起始下标:" << (it - nums1.begin()) << endl;
		}
		auto it2 = std::find_end(nums1.begin(), nums1.end(), nums2.begin(), nums2.begin() + 3, [](int i, int j) { return i == j + 1; });
		if (it2 != nums1.end())
		{
			std::cout << "nums中最后匹配123每个+1的起始下标:" << (it2 - nums1.begin()) << endl;
		}
	}

//nums中最后完全匹配123的起始下标:9
//nums中最后匹配123每个+1的起始下标:10

寻找两个连续相等的element 可添加pred:  adjacent_find

	//ForwardIterator adjacent_find (ForwardIterator first, ForwardIterator last)
	{
		vector<int>nums{ 0,2,3,4,5,6,6,7,7,8,16 };
		auto iter = std::adjacent_find(nums.begin(),nums.end());
		if (iter != nums.end())
		{
			std::cout << "nums中第一次出现两个现需相等的数是:" << *iter << endl;
		}
		auto iter2 = std::adjacent_find(nums.begin(), nums.end(), [](int i, int j) { return  i * 2 == j; });
		if (iter2 != nums.end())
		{
			std::cout << "nums中第一次出现连续两个数2倍关系是:" << *iter2 <<" "<< *(iter2+1)<< endl;
		}
	}
//nums中第一次出现两个现需相等的数是:6
//nums中第一次出现连续两个数2倍关系是:8 16

计数：count、 count_if

{
		vector<int>nums{ 0,2,3,4,5,6,6,6,7,8,16 };
		int count = std::count(nums.begin(), nums.end(), 6);
		std::cout << "nums中6的数量:"<<count << endl;

		//count_if(InputIterator first, InputIterator last, UnaryPredicate pred)
		int count2 = std::count_if(nums.begin(), nums.end(), [](int i) { return i % 2 == 0; });
		std::cout << "nums中偶数个数:" << count2 << endl;
}
//nums中6的数量:3
//nums中偶数个数:8

序列比较：mismatch、equal、is_permutation（两个序列等长）

//pair<InputIterator1, InputIterator2>
	//mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
	//first2之后的元素必须和first1-last1元素一样多
	//序列不匹配起始位置
	{
		
		vector<int>nums1{ 0,2,3,4,5,6,6,6,7,8,16 };
		vector<int>nums2{ 0,2,3,4,5,6,9,5,7,8,16 };
		std::pair<std::vector<int>::iterator, std::vector<int>::iterator> mypair;
		mypair = std::mismatch(nums1.begin(), nums1.end(), nums2.begin());
		std::cout << "序列不匹配从nums1:" << *mypair.first << "序列不匹配从nums2:" << *mypair.second << endl;
	}

//序列不匹配从nums1:6序列不匹配从nums2:9
	// bool equal ( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2 )
	//序列等长
	{
		vector<int>nums1{ 0,2,3,4,5,6,6,6,7,8,16 };
		vector<int>nums2{ 0,2,3,4,5,6,7,5,7,8,16 };
		bool bEqual = std::equal(nums1.begin(), nums1.end(), nums2.begin());
		std::cout << "序列nums1 ==  nums2：" << bEqual << endl;

		bool bEqual2 = std::equal(nums1.begin(), nums1.end(), nums2.begin(), [](int i, int j) {return std::abs(i - j) < 3; });
		std::cout << "序列nums1与nums2各个位置元素绝对值差距小于3：" << bEqual2 << endl;
	}

//序列nums1 ==  nums2：false
//序列nums1与nums2各个位置元素绝对值差距小于3：true
// bool is_permutation (InputIterator1 first1, InputIterator1 last1,InputIterator2 first2)
	//等长序列
	{
		vector<int>nums1{ 0,2,3,4,5,6,6,6,7,8,16 };
		vector<int>nums2{ 3,6,7,4,5,6,0,2,16,6,8 };
		bool bPermuation = std::is_permutation(nums1.begin(), nums1.end(), nums2.begin());
		std::cout << "序列nums1和nums2是不同的排列：" << bPermuation << endl;
	}
//序列nums1和nums2是不同的排列：true

搜索子序列：search、search_n

//搜索第一个完全相等序列
	//ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1,ForwardIterator2 first2, ForwardIterator2 last2)
	{
		vector<int>nums1{ 0,2,3,4,5,6,7,6,6,7,8,16 };
		vector<int>nums2{ 4,5,6 };
		auto it = std::search(nums1.begin(),nums1.end(),nums2.begin(),nums2.end());
		if (it != nums1.end())
		{
			std::cout << "序列nums1中匹配nums2开始位置和值" << it - nums1.begin() << "value:" << *it << endl;
		}

		auto it2 = std::search(nums1.begin(), nums1.end(), nums2.begin(), nums2.end(), [](int i, int j) { return i - j == 1; });
		if (it2 != nums1.end())
		{
			std::cout << "序列nums1中匹配nums2+1开始位置和值" << it2 - nums1.begin() << "value:" << *it2 << endl;
		}
	}


	//ForwardIterator search_n (ForwardIterator first, ForwardIterator last,Size count, const T& val，BinaryPredicate pred)
	{
		vector<int>nums{ 0,2,4,4,5,6,7,6,6,7,8,16 };
		auto it = std::search_n(nums.begin(), nums.end(), 2, 6);
		if (it != nums.end())
		{
			std::cout << "序列nums中找到2个6起始位置:" << it - nums.begin() << endl;
		}
		int n = 8;//谓词BinaryPredicate pred 第一个为序列值第二个为val
		auto it2 = std::search_n(nums.begin(), nums.end(), 2, n, [](int i, int j) { return i * 2 == j; });
		if (it != nums.end())
		{
			std::cout << "序列nums中找到2个4起始位置:" << it2 - nums.begin() << endl;
		}
	}

//序列nums1中匹配nums2开始位置和值3value:4
//序列nums1中匹配nums2+1开始位置和值4value:5
//序列nums中找到2个6起始位置:7
//序列nums中找到2个4起始位置:2

Modifying sequence operation

打印的仿函数

auto printVec = [](vector<int>nums,bool withStep = false) { 
		for (auto it : nums)
		{ 
			if (withStep)
			{
				cout << "["<<it << "]";
			}
			else {
				cout << it << " ";
			}
		} 
		cout << endl; 
	};

	auto printSet = [](set<int>nums, bool withStep = false) {
		for (auto it : nums)
		{
			if (withStep)
			{
				cout << "[" << it << "]";
			}
			else {
				cout << it << " ";
			}
		}
		cout << endl;
	};

	auto printVecStr = [](vector<string>nums, bool withStep = false) {
		for (auto it : nums)
		{
			if (withStep)
			{
				cout << "[" << it << "]";
			}
			else {
				cout << it << " ";
			}
		}
		cout << endl;
	};

拷贝：copy、copy_n、 copy_if、 copy_backward

//OutputIterator copy (InputIterator first, InputIterator last, OutputIterator result)
	{
		vector<int>nums{ 1,2,3,4,5,6,7,8 };
		vector<int>nums_copy(nums.size());
		std::copy(nums.begin(), nums.end(), nums_copy.begin());
		printVec(nums_copy);
	}

	// OutputIterator copy_n (InputIterator first, Size n, OutputIterator result)
	{
		vector<int>nums{ 1,2,3,4,5,6,7,8 };
		vector<int>nums_copy(nums.size()/2);
		std::copy_n(nums.begin(), nums.size() / 2, nums_copy.begin());
		printVec(nums_copy);
	}

	// OutputIterator copy_if (InputIterator first, InputIterator last,OutputIterator result, UnaryPredicate pred)
	{
		vector<int>nums{ 1,2,3,4,5,6,7,8 };
		vector<int>nums_copy(nums.size(),0);
		//返回拷贝完之后拷贝最后一个元素的下一个迭代器
		auto it = std::copy_if(nums.begin(), nums.end(), nums_copy.begin(), [](int n) { return (n & 1) == 0; });
		nums_copy.resize(it - nums_copy.begin());// shrink container to new size
		printVec(nums_copy);
	}
	//从后往前拷贝 先拷贝最后一个 迭代器均往前
	//BidirectionalIterator2 copy_backward ( BidirectionalIterator1 first,BidirectionalIterator1 last,BidirectionalIterator2 result )
	{
		vector<int>nums{ 1,2,3,4,5,6,7,8 };
		nums.resize(12, 0);
		//返回拷贝完之后拷贝序列的第一个元素迭代器
		auto it = std::copy_backward(nums.begin(), nums.begin() + 8, nums.end());
		vector<int>nums_copy(nums.end() - it,0);
		std::copy(it, nums.end(), nums_copy.begin());
		printVec(nums);
		printVec(nums_copy);
	}

移动：move、move_backward

//OutputIterator move(InputIterator first, InputIterator last, OutputIterator result)
	//The value of the elements in the [first,last) is transferred to the elements pointed by result. 
	//After the call, the elements in the range [first,last) are left in an unspecified but valid state.
	{
		std::vector<std::string> foo = { "air","water","fire","earth" };
		std::vector<std::string> bar(4);

		// moving ranges: size不变 元素被移动变为有效的初始值
		std::move(foo.begin(), foo.end(), bar.begin());

		std::cout << "foo contains " << foo.size() << " elements:";
		printVecStr(foo, true);//size仍然是4单已经没有特定的元素

		std::cout << "bar contains " << bar.size() << " elements:";
		printVecStr(bar, true);

		// moving container: size = 0
		std::cout << "Moving container...\n";
		foo = std::move(bar);

		std::cout << "foo contains " << foo.size() << " elements:";
		printVecStr(foo, true);
		std::cout << "bar contains " << bar.size() << " elements:";//0
		printVecStr(bar, true);
	}

	//BidirectionalIterator2 move_backward ( BidirectionalIterator1 first,BidirectionalIterator1 last,BidirectionalIterator2 result )
	//从后往前顺序移动
	{
		std::vector<string> elems = { "air","water","fire","earth" };
		elems.resize(10);
		// insert new element at the beginning:
		std::move_backward(elems.begin(), elems.begin() + 4, elems.begin() + 10);
		elems[0] = "ether";
		printVecStr(elems,true);
	}

交换：swap

//swap
	{
		//值替换
		int x = 10, y = 20;                              // x:10 y:20
		std::swap(x, y);                              // x:20 y:10

		//容器替换
		std::vector<int> foo(4, x), bar(6, y);       // foo:4x20 bar:6x10
		std::swap(foo, bar);                          // foo:6x10 bar:4x20
		printVec(foo);
		printVec(bar);	

		//set
		set<int>a = { 1,2,3,4 };
		set<int>b = {5,6,7,8,9};
		swap(a, b);
		printSet(a);
		printSet(b);
	}

转换：transform 

//OutputIterator transform (InputIterator first1, InputIterator last1,OutputIterator result, UnaryOperator op)
	{
		std::vector<int> nums1{1,2,3,4,5};
		std::vector<int> nums2(nums1.size(),-1);
		std::transform(nums1.begin(), nums1.end(), nums2.begin(), [](int n) { return std::pow(n,2); });
		printVec(nums2);
	}

 替换：replace、replace_if

//void replace(ForwardIterator first, ForwardIterator last,const T& old_value, const T& new_value)
	{	
		int myints[] = { 10, 20, 30, 30, 20, 10, 10, 20 };
		std::vector<int> myvector(myints, myints + 8);            // 10 20 30 30 20 10 10 20
		std::replace(myvector.begin(), myvector.end(), 20, 99); // 10 99 30 30 99 10 10 99
		printVec(myvector);

		string str1 = "abcdefgfedcba";
		replace(str1.begin(), str1.end(), 'g', 'G');
		cout << str1 << endl;
	
	}

	// void replace_if (ForwardIterator first, ForwardIterator last,UnaryPredicate pred, const T& new_value)
	{
		string str = "abcDEFgUSNiHyNiHgIMug";
		std::replace_if(str.begin(), str.end(), [](char c) { 
			if (c >= 'A' && c <= 'Z')
			{
				return true;
			}
			return false;
		},'a'
		);
		cout << str << endl;
	}

拷贝同时替换:replace_copy、replace_copy_if 

// OutputIterator replace_copy (InputIterator first, InputIterator last,OutputIterator result, const T& old_value, const T& new_value)
	{
		int myints[] = { 10, 20, 30, 30, 20, 10, 10, 20 };
		std::vector<int> myvector(8);
		std::replace_copy(myints, myints + 8, myvector.begin(), 20, 99);
		printVec(myvector);
	}

	//OutputIterator replace_copy_if (InputIterator first, InputIterator last,OutputIterator result, UnaryPredicate pred,const T& new_value)
	{
		std::vector<int> foo, bar;

		// set some values:
		for (int i = 1; i<10; i++) foo.push_back(i);          // 1 2 3 4 5 6 7 8 9

		bar.resize(foo.size());   // allocate space
		std::replace_copy_if(foo.begin(), foo.end(), bar.begin(), [](int n) { return (n & 1) == 1; }, 0);
		printVec(bar);
	}

 填充：fill、fill_n

// void fill (ForwardIterator first, ForwardIterator last, const T& val)
	{
		std::vector<int> myvector(8,0);                       // myvector: 0 0 0 0 0 0 0 0
		std::fill(myvector.begin(), myvector.begin() + 4, 5);   // myvector: 5 5 5 5 0 0 0 0
		std::fill(myvector.begin() + 3, myvector.end() - 2, 8);   // myvector: 5 5 5 8 8 8 0 0
		printVec(myvector);
	}

	//OutputIterator fill_n (OutputIterator first, Size n, const T& val)
	{
		std::vector<int> myvector(8, 10);        // myvector: 10 10 10 10 10 10 10 10
		std::fill_n(myvector.begin(), 4, 20);     // myvector: 20 20 20 20 10 10 10 10
		std::fill_n(myvector.begin() + 3, 3, 33);   // myvector: 20 20 20 33 33 33 10 10
		printVec(myvector);
	}

 自定义填充：generate、generate_n


	//void generate ( ForwardIterator first, ForwardIterator last, Generator gen )
	{
		std::srand(unsigned(std::time(0)));
		std::vector<int> myvector(8);
		std::generate(myvector.begin(), myvector.end(), []() { return (rand() % 100); });
		printVec(myvector);
	}

	//void generate_n ( OutputIterator first, Size n, Generator gen )
	{
		vector<int>myvector(10,-1);
		std::srand(unsigned(std::time(0)));
		std::generate_n(myvector.begin(), 9, []() { return (rand() % 100); });
		printVec(myvector);
	}

 移除：remove、remove_if

   ForwardIterator remove (ForwardIterator first, ForwardIterator last, const T& val)
   实际不是删除只是元素的重新排列 ,符合条件的元素移动到容器后面,返回移动后边界迭代器。

{
		vector<int>myvector = { 10,20,30,30,20,10,10,20 };      // 10 20 30 30 20 10 10 20
		auto pend = std::remove(myvector.begin(), myvector.end(), 20);         // 10 30 30 10 * *
		//remove实际只是将符合条件的元素移动到后面 并非真正删除
		vector<int>resultVector(pend - myvector.begin());
		copy(myvector.begin(), pend, resultVector.begin());
		printVec(resultVector);//10 30 30 10 10

		//可以配合erase进行真正删除
		myvector.erase(pend, myvector.end());
		printVec(myvector);//10 30 30 10 10


		vector<int>myvector2 = { 10,21,30,31,20,11,10,23 };  
		auto iter = remove_if(myvector2.begin(), myvector2.end(), [](int num) { return (num & 1) == 0; });
		myvector2.erase(iter, myvector2.end());
		printVec(myvector2);
	}

去重：unique移除连续的重复元素，（非连续的重复不去除，全部去重最好先排序） 

ForwardIterator unique (ForwardIterator first, ForwardIterator last)
移除连续的重复元素 返回指向第一个重复元素的迭代器 如果要去重最好先排序 

{
		vector<int>myvector = { 10,20,30,30,20,10,10,20 };
		vector<int>myvector2(myvector);
		auto iter = std::unique(myvector.begin(), myvector.end());
		myvector.erase(iter,myvector.end());
		printVec(myvector);//10 20 30 20 10 20


		//排序后相等的元素会紧邻 unique后完成全局去重
		std::sort(myvector2.begin(), myvector2.end());
		auto iter2 = std::unique(myvector2.begin(), myvector2.end());
		myvector2.resize(iter2 - myvector2.begin());
		printVec(myvector2);
	}

 逆序：reverse

// void reverse (BidirectionalIterator first, BidirectionalIterator last) 逆序
	{
		vector<int>myvector = { 10,20,30,40,50,60,70,80 };
		reverse(myvector.begin(), myvector.end());
		printVec(myvector);
	}

 环移: rotate 循环移动first到last之间元素 使得middle重新在first位置
 void rotate (ForwardIterator first, ForwardIterator middle,ForwardIterator last)

	{
		vector<int>myvector{ 1,2,3,4,5,6,7,8 };
		rotate(myvector.begin(), myvector.begin() + 3, myvector.end());
		printVec(myvector);//4 5 6 7 8 1 2 3

		vector<int>myvector2{ 1,2,3,4,5,6,7,8 };
		rotate(myvector2.begin()+1, myvector2.begin() + 3, myvector2.begin()+7);
		printVec(myvector2);//1,4,5,6,7,2,3,8

	}

 洗牌算法：
    Knuth - Durstenfeld Shuffle 算法：一个拥有n个元素的初始序列，
    将最后一个数和该序列的前 n 个数中的随机一个数进行交换（如果随机结果是和第n个数交换，相当于没换），
    然后倒数第二个数和该序列的前 n - 1 个数中的随机一个数进行交换，以此类推，直到将该序列第一个数操作完，
    就完成了洗牌，该算法保证了每个元素在每个位置的概率都是相等的，时间复杂度为O(N)
    
void random_shuffle (RandomAccessIterator first, RandomAccessIterator last,RandomNumberGenerator& gen)
    {
        iterator_traits<RandomAccessIterator>::difference_type i, n;
        n = (last-first);
        for (i=n-1; i>0; --i) {
        swap (first[i],first[gen(i+1)]);
        }
    }

random_shuffle 

{
		std::srand(unsigned(std::time(0)));
		std::vector<int> myvector = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
		// using built-in random generator:
		std::random_shuffle(myvector.begin(), myvector.end());

		printVec(myvector);
		// 自定义随机数生成器
		std::random_shuffle(myvector.begin(), myvector.end(), [](int i) {return std::rand() % i; });
		printVec(myvector);
	}


    shuffle 与random_shuffle相同 C++11引入 后续建议用这个
    C++11中的<random>头文件中提供了很多生成随机数的工具，需要搭配生成器和分布器来使用
    template <class RandomAccessIterator, class URNG>
    void shuffle (RandomAccessIterator first, RandomAccessIterator last, URNG&& g)
    {
        for (auto i=(last-first)-1; i>0; --i) {
        std::uniform_int_distribution<decltype(i)> d(0,i);
        swap (first[i], first[d(g)]);
        }
    }
    

shuffle 

{
		std::vector<int> vec{ 1, 2, 3, 4, 5, 6 };
		std::mt19937 gen(std::random_device{}());
		//mt19937 名字看起来有点怪，但它是常用的生成器，
		//mt表示它基于Mersenne Twister算法，19937源于产生随的机数的周期长可达到2^19937-1
		std::shuffle(vec.begin(), vec.end(), gen);
		printVec(vec);
	}

​Partitions

Sorting


​Binary search

Merge

Heap

Min/max

Other

【LeetCode】—— 二叉树的深度
chenxiyuehh的博客
04-10 406
一、LeetCode104题 二叉树的最大深度 1.1 题目描述 定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。 示例： 给定二叉树 [3,9,20,null,null,15,7]， 3 / \ 9 20 / \ 15 7 返回它的最大深度 3 。 ...
C++之STL的algorithm（6）之排序算法（sort、merge）整理
ULTRAmanTAROACE的博客
04-04 1833
C++之STL的algorithm（6）之排序算法（sort、reverse、merge）整理
leetcode 104 二叉树的最大深度
qq_43460108的博客
08-23 205
给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。 示例： 给定二叉树 [3,9,20,null,null,15,7]， 3 / 9 20 / 15 7 返回它的最大深度 3 。 递归 /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * Tr
leetcode刷题/二叉树 二叉树的深度
公仔面
07-26 280
二叉树的深度 104. 二叉树的最大深度 题意: 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。 示例： 给定二叉树 [3,9,20,null,null,15,7]， 3 / \ 9 20 / \ 15 7 解题思路: 运用递归,只需要逐个判断每个节点的层数的最大值即可 代码: if (root == nullptr) return 0; return max(m
leetcode求二叉树深度
devcy的博客
05-08 286
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。 非递归写法：层次遍历 import java.util.Queue; import java.util.LinkedList; public class Solution { public int TreeDepth(TreeNode pRoot) { ...
leetcode 剑指 Offer 68 - I. 二叉搜索树的最近公共祖先
qq_724027324的博客
02-27 104
利用二叉树的特性：左子树<根节点<右子树 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ class Solution { public: Tree
boost-STL.rar_Boost_C++标准库_STL_c 标准库_chm
09-21
Boost.STL是Boost库的一个重要组成部分，它是对C++标准库STL（Standard Template Library）的扩展和增强，旨在提供更高效、功能更丰富的容器、迭代器、算法和函数对象。Boost库本身是一个开源的C++库集合，其目标是...
stl常用算法(Algorithms)介绍(stl排序算法、非变序型队列)
09-04
STL（Standard Template Library，标准模板库）是C++编程语言中的一个重要组成部分...无论是排序还是查询，STL算法都能提供强大且灵活的支持。在实际编程中，根据需求选择合适的算法，可以极大地优化代码性能和可读性。
C++精选代码库。包含常用STL容器模拟实现、algorithm算法头文件函数demo
03-08
1. **数组（Array）**：虽然C++标准库中没有直接提供数组容器，但C++11引入了`std::array`，它是固定大小的数组，提供了安全的访问和操作。 2. **向量（Vector）**：`std::vector`是一个动态数组，可以自动调整大小...
基于STL的演讲比赛流程管理系统+STL（标准模板库）+演讲比赛管理，选手信息，比赛流程，随机数生成，用户交互，记录查看与清除
最新发布
02-15
基于STL的演讲比赛流程管理系统是通过C++语言中的标准模板库（STL）来实现的一个程序原型，它主要面向小型演讲比赛的组织和管理，提供了包括选手信息管理、比赛流程安排、分数统计、记录查看与清除等在内的一系列...
二叉树的深度_leetcode树之二叉树的深度
weixin_39568653的博客
12-14 129
序本文主要记录一下leetcode树之二叉树的深度题目输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点(含根、叶节点)形成树的一条路径，最长路径的长度为树的深度。例如：给定二叉树 [3,9,20,null,null,15,7]， 3 / 9 20 / 15 7返回它的最大深度 3 。提示： 节点总数 <= 10000注意：本题与主站...
leetcode-二叉树的最大深度
能
12-22 304
给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。 示例： 给定二叉树 [3,9,20,null,null,15,7]， 3 / \ 9 20 / \ 15 7 返回它的最大深度 3 。 代码 /** * Definition for a binary tree node. ...
LeetCode： 104. 二叉树的最大深度（包含递归模板）
梦~'
07-16 687
题目： 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明:叶子节点是指没有子节点的节点。 示例： 给定二叉树 [3,9,20,null,null,15,7]， 3 / \ 9 20 / \ 15 7 返回它的最大深度3 。 链接：https://leetcode-cn.com/problems/maximum-depth-of-binary-tree 时间复杂度： O(N) 每个结...
(LeetCode-树-1) 二叉树的深度
weixin_34205826的博客
04-03 106
二叉树的最大深度 给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶节点的最长路径上的节点数。 给出二叉树 [3,9,20,null,null,15,7]， 3 / \ 9 20 / \ 15 7 返回最大深度为 3 。 分析:1.采用递归遍历左右子树2.结果为最大树木的层数加一 int...
1.二叉树的深度
gtjsjj的博客
06-08 222
题目描述 输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。 解题思路 1.首先判断根节点是否为空，为空则返回0. 2.根节点不为空： 1）有左节点无右节点：深度=左节点深度+1.（这个1是根节点）。即深度=max(左节点，0)+1 2）有右节点无左节点：深度=右节点深度+1.即深度=max(0，右节点)+1 3）左右节点都有：深度=max(左节点，右节点)+1 java代码 public class Solution {
二叉树的最大深度 - LeetCode
小老弟的博客
07-23 350
给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。 示例： 给定二叉树 [3,9,20,null,null,15,7]，返回它的最大深度 3 解放： 深度优先搜索属于图算法的一种，英文缩写为DFS即Depth First Search.其过程简要来说是对每一个可能的分支路径深入到不能再深入为止 PHP /** * D...
leetcode之二叉树类之二叉树深度系列-----104/111/110/108/109 二叉树最大/最小深度/AVL树的判断和由有序序列生成(牵扯分治相关，OJ105/106)
u010246947的专栏
10-15 804
leetcode之二叉树类之二叉树深度系列-----104/111/110/108/109 二叉树最大/最小深度/AVL树的判断和由有序序列生成(牵扯分治相关，OJ105/106)
leetcode--二叉树的最大深度
navylhjjlh的博客
04-13 472
leetcode--二叉树的最大深度
leetcode记录 二叉树的最大深度
u012904680的博客
07-06 343
给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。说明: 叶子节点是指没有子节点的节点。示例：给定二叉树 [3,9,20,null,null,15,7]， 3 / \ 9 20 / \ 15 7返回它的最大深度 3 。 思路：递归/**  * Definition for a binary tree node.  * s...
C++ STL变异算法深入解析与实践应用
- 包含必要的头文件，例如 #include <algorithm>，因为STL算法都在此命名空间下。 - 实例化容器，并初始化其中的元素。 - 调用相应的算法函数。 - 显示调用算法后的结果，以验证算法的正确性。 通过实际编码，读者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值