Stl on ZRJ | 学习笔记

比较字符串形式的版本号

Tue, 15 Sep 2015 20:54:34 +0800

版本号是一个字符串，主要考虑以下三种用例，点分的个数一致还好，不一致需要注意

#include <boost/algorithm/string.hpp>
#include <algorithm>
#include <vector>
#include <string>

bool version_less_than(std::string str_version_a, std::string str_version_b)
{
    std::vector<std::string> vec_version_a, vec_version_b;
    boost::split(vec_version_a, str_version_a, boost::is_any_of("."));
    boost::split(vec_version_b, str_version_b, boost::is_any_of("."));
    return std::lexicographical_compare(vec_version_a.begin(), vec_version_a.end(), vec_version_b.begin(), vec_version_b.end());
}

int main() {
    {
        std::string str_version_a = "4.1.1", str_version_b = "4.1.2";
        printf("%d\n", version_less_than(str_version_a, str_version_b));
    }
    {
        std::string str_version_a = "4.1", str_version_b = "4.1.2";
        printf("%d\n", version_less_than(str_version_a, str_version_b));
    }
    {
        std::string str_version_a = "4.1.1", str_version_b = "4.1";
        printf("%d\n", version_less_than(str_version_a, str_version_b));
    }
    return 0;
}

运行结果

1
1
0

另外，对于比较，只需要通过一个小于比较运算，就可以满足小于，大于的比较，等于的比较可以通过两次小于比较来达成

-————————————

2015-9-16 09:33:20 发现上面的方法是有问题的，看这个用例

#include <boost/algorithm/string.hpp>
#include <algorithm>
#include <vector>
#include <string>

bool version_less_than(std::string str_version_a, std::string str_version_b)
{
    std::vector<std::string> vec_version_a, vec_version_b;
    boost::split(vec_version_a, str_version_a, boost::is_any_of("."));
    boost::split(vec_version_b, str_version_b, boost::is_any_of("."));
    return std::lexicographical_compare(vec_version_a.begin(), vec_version_a.end(), vec_version_b.begin(), vec_version_b.end());
}

int main() {
    {
        std::string str_version_a = "4.1.10", str_version_b = "4.1.2";
        printf("%d\n", version_less_than(str_version_a, str_version_b));
    }
    return 0;
}

输出

问题的本质还是拿字符串当做数字来比较了，这么改

#include <boost/algorithm/string.hpp>
#include <boost/lexical_cast.hpp>
#include <algorithm>
#include <vector>
#include <string>

bool version_less_than(std::string str_version_a, std::string str_version_b) {
    std::vector<std::string> vec_str_version_a, vec_str_version_b;
    boost::split(vec_str_version_a, str_version_a, boost::is_any_of("."));
    boost::split(vec_str_version_b, str_version_b, boost::is_any_of("."));
    std::vector<int> vec_int_version_a, vec_int_version_b;
    std::transform(vec_str_version_a.begin(), vec_str_version_a.end(), std::back_inserter(vec_int_version_a), boost::lexical_cast<int, std::string>);
    std::transform(vec_str_version_b.begin(), vec_str_version_b.end(), std::back_inserter(vec_int_version_b), boost::lexical_cast<int, std::string>);
    return std::lexicographical_compare(vec_int_version_a.begin(), vec_int_version_a.end(), vec_int_version_b.begin(), vec_int_version_b.end());
}

int main() {
    {
        std::string str_version_a = "4.1.1", str_version_b = "4.1.2";
        printf("%d\n", version_less_than(str_version_a, str_version_b));
    }
    {
        std::string str_version_a = "4.1", str_version_b = "4.1.2";
        printf("%d\n", version_less_than(str_version_a, str_version_b));
    }
    {
        std::string str_version_a = "4.1.1", str_version_b = "4.1";
        printf("%d\n", version_less_than(str_version_a, str_version_b));
    }
    {
        std::string str_version_a = "4.1.10", str_version_b = "4.1.2";
        printf("%d\n", version_less_than(str_version_a, str_version_b));
    }    
    return 0;
}

固然可以实现，但是感觉就笨重了好多，查了一下，leetcode 上面是有这个题的，https://leetcode.com/problems/compare-version-numbers/，按照 acm 流的写法，肯定就是自己手解字符串了，就像这样，http://ask.julyedu.com/question/114

std::next_permutation

Sun, 21 Jun 2015 10:44:40 +0800

std 中有一个 next_permutation 的算法，见这里，http://en.cppreference.com/w/cpp/algorithm/next_permutation，这个页面上面有一个实现

template<class BidirIt>
bool next_permutation(BidirIt first, BidirIt last)
{
    if (first == last) return false;
    BidirIt i = last;
    if (first == --i) return false;
 
    while (1) {
        BidirIt i1, i2;
 
        i1 = i;
        if (*--i < *i1) {
            i2 = last;
            while (!(*i < *--i2))
                ;
            std::iter_swap(i, i2);
            std::reverse(i1, last);
            return true;
        }
        if (i == first) {
            std::reverse(first, last);
            return false;
        }
    }
}

相关说明在这里，http://fisherlei.blogspot.com/2012/12/leetcode-next-permutation.html，但是对着上面的实现看的老费劲，大师写的东西果然晦涩难懂，表达力是强，但是奈何吾辈愚钝啊

遂改写了一个等价的，长这样

template<class BidiIterator>
bool next_permutation(BidiIterator first, BidiIterator last) {	
	if (std::distance(first, last) <= 1) {
		return false;
	}
	BidiIterator pivot = last-1;
	while (1) {
		pivot--;
		if (*pivot < *(pivot+1)) {	
			BidiIterator change = last-1;
			while (*change < *pivot) {
				change--;
			}
			std::iter_swap(pivot, change);
			std::reverse(pivot+1, last);
			return true;
		}
		if (pivot == first) {
			std::reverse(first, last);
			return false;
		}
	}
}

STL set 的一些实现差异

Wed, 18 Dec 2013 11:32:18 +0800

侯捷大师在 STL 源码剖析中说道，set 的迭代器的值是不可改变的，这个本来很好理解，但是我神奇的在 visual studio 2005 上发现，神奇的事情总是会发生

#include <stdio.h>
#include <map>
#include <string>
#include <set>

int main() {
    std::set<int> setInt;
    setInt.insert(1);
    setInt.insert(2);
    for (std::set<int>::iterator it = setInt.begin(); it != setInt.end(); it++)
    {
        printf("%d\n", *it);
    }
    {
        std::set<int>::iterator it = setInt.begin();
        *it = 4;
        it++;
        *it = 3;
    }
    for (std::set<int>::iterator it = setInt.begin(); it != setInt.end(); it++)
    {
        printf("%d\n", *it);
    }
    return 0;
}

居然顺利的编译通过，而且可以跑，看看输出

1
2
4
3
请按任意键继续. . .

照理说，set 的底下是红黑树的话，这里应该是会违反红黑树的大小排序原则的。。

甚至改成这样

#include <stdio.h>
#include <map>
#include <string>
#include <set>

int main() {
    std::set<int> setInt;
    setInt.insert(1);
    setInt.insert(2);
    for (std::set<int>::iterator it = setInt.begin(); it != setInt.end(); it++)
    {
        printf("%d\n", *it);
    }
    {
        std::set<int>::iterator it = setInt.begin();
        *it = 4;
        it++;
        *it = 4;
    }
    for (std::set<int>::iterator it = setInt.begin(); it != setInt.end(); it++)
    {
        printf("%d\n", *it);
    }
    return 0;
}

也可以。。好吧，set 的原则也被破坏了。。

来看 gcc 4.1 的编译输出

StlContainerTest.cpp:25:2: warning: no newline at end of file
StlContainerTest.cpp: In function 'int main()':
StlContainerTest.cpp:16: error: assignment of read-only location
StlContainerTest.cpp:18: error: assignment of read-only location

这个才是符合预期的嘛，M$ 这样会坑死人啊。。

STL map 的一个问题

Thu, 25 Jul 2013 22:16:52 +0800

先看看这个代码

#include <iostream>
#include <map>
#include <vector>

using namespace std;

int main() {
    map<int, vector<int> > map_a, map_b;
    map_a[0].push_back(0);
    map_b[0] = map_a[0];
    map_b[0].push_back(0);
    cout<<map_a[0].size()<<endl;
    return 0;
}

会输出 1 还是 2 呢，如果按照 map 存 vector 的引用来理解，应该是输出 2 的。

而实际是输出 1 的。

看看这个

#include <iostream>
#include <map>
#include <vector>

using namespace std;

int main() {
    map<int, vector<int> > map_a, map_b;
    map_a[0].push_back(0);
    cout<<&map_a[0]<<endl;
    map_b[0] = map_a[0];
    cout<<&map_b[0]<<endl;
    map_b[0].push_back(0);
    cout<<&map_b[0]<<endl;
    cout<<map_a[0].size()<<endl;
    return 0;
}

栈结构练习

Fri, 14 Sep 2012 11:12:03 +0800

今天从刘汝佳的书上看到一个简单的栈的题目

有n节车厢从A方向驶入车站，按进站顺序编号1～n。现让这些火车按照某种特定的顺序进入B方向的铁轨并驶出车站。为了重组车厢，可以借助中转站C。C是一个可以停放任意多节车厢的车站，但由于末端封顶，驶入C的车厢必须按照相反的顺序驶出C。对于每个车厢，一旦从A移入C，就不能再回到A了；一旦从C移入B，就不能回到C了请编程判断判断：按给定的出站顺序，火车能否出站

用 c++ 的 stl 写的话是这样

#include <cstdio>
#include <stack>

using namespace std;

int main()
{
	int n;
	while (scanf("%d", &n) == 1)
	{
		int *target = new int[n+1];
		for (int i=1; i<=n; i++)
		{
			scanf("%d", &target[i]);
		}
		stack<int> s;
		int a=1, b=1, ok=1;
		while (b < n)
		{
			if (a == target[b])
			{
				a++;
				b++;
			}
			else if ( !s.empty() && s.top()==target[b])
			{
				s.pop();
				b++;
			}
			else if (a < n)
			{
				s.push(a);
				a++;
			}
			else
			{
				ok = 0;
				break;
			}
		}
		delete[] target;
		target = NULL;
		if (ok)
		{
			printf("Yesn");
		}
		else
		{
			printf("Non");
		}
	}
	return 0;
}

输入输出

5
1 2 3 4 5
Yes
5
5 4 1 2 3
No
6
6 5 4 3 2 1
Yes

二叉树的遍历

Sat, 08 Sep 2012 17:01:31 +0800

参考 http://blog.csdn.net/acdnjjjdjkdckjj/article/details/6237970 写了二叉树的遍历，（基本上就是照抄的，囧），抄的时候感慨，stl 真是个好东西啊，另外，在三种次序遍历的实现上，递归的精巧发挥的淋漓尽致啊，还有就是非递归的遍历，设计真的好巧妙

#include <iostream>
#include <queue>
#include <stack>

using namespace std;

class Tree
{
public:
	char data;
	Tree *left;
	Tree *right;
	void create(Tree *&node);
	void preOrderVisit(Tree *node);
	void inOrderVisit(Tree *node);
	void lastOrderVisit(Tree *node);
	void levelOrderVisit(Tree *node);
	void notRecursionPreOrderVisit(Tree *node);
	void notRecursionInorderVisit(Tree *node);
	void notRecursionLastOrderVisit(Tree *node);
};

void Tree::create(Tree *&node)
{
	char ch;
	cin>>ch;
	if (ch == '0')
	{
		node = NULL;
	}
	else
	{
		node = new Tree();
		node->data = ch;
		create(node->left);
		create(node->right);
	}
}

void Tree::preOrderVisit(Tree *node)
{
	if (node)
	{
		cout<<node->data<<' ';
		preOrderVisit(node->left);
		preOrderVisit(node->right);
	}
}

void Tree::inOrderVisit(Tree *node)
{
	if (node)
	{
		inOrderVisit(node->left);
		cout<<node->data<<' ';
		inOrderVisit(node->right);
	}
}

void Tree::lastOrderVisit(Tree *node)
{
	if (node)
	{
		lastOrderVisit(node->left);
		lastOrderVisit(node->right);
		cout<<node->data<<' ';
	}
}

void Tree::levelOrderVisit(Tree *node)
{
	if ( ! node)
	{
		return;
	}
	queue<Tree *> q;
	q.push(node);
	while ( ! q.empty())
	{
		Tree *tmp = q.front();
		cout<<tmp->data<<' ';
		q.pop();
		if (tmp->left)
		{
			q.push(tmp->left);
		}
		if (tmp->right)
		{
			q.push(tmp->right);
		}
	}
}

void Tree::notRecursionPreOrderVisit(Tree *node)
{
	stack<Tree *> s;
	Tree *t = node;
	while (!s.empty() || t)
	{
		if (t)
		{
			cout<<t->data<<' ';
			s.push(t);
			t = t->left;
		}
		else
		{
			t = s.top();
			s.pop();
			t = t->right;
		}
	}
}

void Tree::notRecursionInorderVisit(Tree *node)
{
	stack<Tree *> s;
	Tree *t = node;
	while (!s.empty() || t)
	{
		if (t)
		{
			s.push(t);
			t = t->left;
		}
		else
		{
			t = s.top();
			s.pop();
			cout<<t->data<<' ';
			t = t->right;
		}
	}
}

void Tree::notRecursionLastOrderVisit(Tree *node)
{
	stack<Tree *> s;
	Tree *t = node;
	Tree *pre = NULL;
	while(!s.empty() || t)
	{
		while (t)
		{
			s.push(t);
			t = t->left;
		}
		t = s.top();
		if (t->right==NULL || t->right==pre)
		{
			cout<<t->data<<' ';
			pre = t;
			t = NULL;
			s.pop();
		}
		else
		{
			t = t->right;
		}
	}
}

int main()
{
	Tree *t = NULL;
	t->create(t);
	t->preOrderVisit(t);
	cout<<endl;
	t->inOrderVisit(t);
	cout<<endl;
	t->lastOrderVisit(t);
	cout<<endl;
	t->levelOrderVisit(t);
	cout<<endl;
	t->notRecursionPreOrderVisit(t);
	cout<<endl;
	t->notRecursionInorderVisit(t);
	cout<<endl;
	t->notRecursionLastOrderVisit(t);
	cout<<endl;
	return 0;
}

输入输出

124005003600700
1 2 4 5 3 6 7
4 2 5 1 6 3 7
4 5 2 6 7 3 1
1 2 3 4 5 6 7
1 2 4 5 3 6 7
4 2 5 1 6 3 7
4 5 2 6 7 3 1