steven/TinySTL
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

bug fix && change some names

Browse Source
This commit is contained in:
邹晓航
2015-02-10 15:32:38 +08:00
parent 833201262e
commit 7072a46050
2 changed files with 76 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files

67
TinySTL/Detail/Graph.impl.h
View File

@@ -3,25 +3,25 @@
namespace TinySTL{ namespace TinySTL{
namespace Detail{ namespace Detail{
template<class Index, class Value, class EqualFunc> template<class Index, class Value, class EqualFunc>
typename graph<Index, Value, EqualFunc>::node& typename graph<Index, Value, EqualFunc>::node_type&
graph<Index, Value, EqualFunc>::new_node(const Index& index, const Value& val){ graph<Index, Value, EqualFunc>::new_node(const Index& index, const Value& val){
auto ptr = nodeAllocator::allocate(); auto ptr = nodeAllocator::allocate();
nodeAllocator::construct(ptr, node(index, val)); nodeAllocator::construct(ptr, node_type(index, val));
return *ptr; return *ptr;
} }
template<class Index, class Value, class EqualFunc> template<class Index, class Value, class EqualFunc>
void graph<Index, Value, EqualFunc>::del_node(node *p){ void graph<Index, Value, EqualFunc>::del_node(node_type *p){
nodeAllocator::destroy(p); nodeAllocator::destroy(p);
nodeAllocator::deallocate(p); nodeAllocator::deallocate(p);
} }
template<class Index, class Value, class EqualFunc> template<class Index, class Value, class EqualFunc>
typename graph<Index, Value, EqualFunc>::node& typename graph<Index, Value, EqualFunc>::node_type&
graph<Index, Value, EqualFunc>::get_node(const Index& index){ graph<Index, Value, EqualFunc>::get_node(const Index& index){
for (auto& pair : nodes_){ for (auto& pair : nodes_){
if (equal_func(pair.first.first, index)) if (equal_func(pair.first.first, index))
return pair.first; return pair.first;
} }
return node(); return node_type();
} }
template<class Index, class Value, class EqualFunc> template<class Index, class Value, class EqualFunc>
void graph<Index, Value, EqualFunc>::cleanup(){ void graph<Index, Value, EqualFunc>::cleanup(){
@@ -40,9 +40,9 @@ namespace TinySTL{
return false; return false;
} }
template<class Index, class Value, class EqualFunc> template<class Index, class Value, class EqualFunc>
typename graph<Index, Value, EqualFunc>::node_sets typename graph<Index, Value, EqualFunc>::nodes_set_type
graph<Index, Value, EqualFunc>::empty_node_set(){ graph<Index, Value, EqualFunc>::empty_node_set(){
return node_sets(); return nodes_set_type();
} }
template<class Index, class Value, class EqualFunc> template<class Index, class Value, class EqualFunc>
bool graph<Index, Value, EqualFunc>::empty()const{ bool graph<Index, Value, EqualFunc>::empty()const{
@@ -80,22 +80,22 @@ namespace TinySTL{
return size_; return size_;
} }
template<class Index, class Value, class EqualFunc> template<class Index, class Value, class EqualFunc>
typename graph<Index, Value, EqualFunc>::node_sets typename graph<Index, Value, EqualFunc>::nodes_set_type
graph<Index, Value, EqualFunc>::adjacent_nodes(const Index& index){ graph<Index, Value, EqualFunc>::adjacent_nodes(const Index& index){
node_sets s; nodes_set_type s;
for (auto it = begin(index); it != end(index); ++it){ for (auto it = begin(index); it != end(index); ++it){
s.push_back(*it); s.push_back(*it);
} }
return s; return s;
} }
template<class Index, class Value, class EqualFunc> template<class Index, class Value, class EqualFunc>
typename graph<Index, Value, EqualFunc>::node_sets typename graph<Index, Value, EqualFunc>::nodes_set_type
graph<Index, Value, EqualFunc>::adjacent_nodes(const node& n){ graph<Index, Value, EqualFunc>::adjacent_nodes(const node_type& n){
return adjacent_nodes(n.first); return adjacent_nodes(n.first);
} }
template<class Index, class Value, class EqualFunc> template<class Index, class Value, class EqualFunc>
void graph<Index, Value, EqualFunc>::DFS(const Index& index, visiter_func_type func){ void graph<Index, Value, EqualFunc>::DFS(const Index& index, visiter_func_type func){
node *start = &(get_node(index)); node_type *start = &(get_node(index));
Unordered_set<Index, std::hash<Index>, EqualFunc> visited(7); Unordered_set<Index, std::hash<Index>, EqualFunc> visited(7);
auto nodes = adjacent_nodes(start->first); auto nodes = adjacent_nodes(start->first);
@@ -108,14 +108,14 @@ namespace TinySTL{
} }
template<class Index, class Value, class EqualFunc> template<class Index, class Value, class EqualFunc>
void graph<Index, Value, EqualFunc>::BFS(const Index& index, visiter_func_type func){ void graph<Index, Value, EqualFunc>::BFS(const Index& index, visiter_func_type func){
node *start = &(get_node(index)); node_type *start = &(get_node(index));
Unordered_set<Index, std::hash<Index>, EqualFunc> visited(7); Unordered_set<Index, std::hash<Index>, EqualFunc> visited(7);
auto nodes = adjacent_nodes(start->first); auto nodes = adjacent_nodes(start->first);
func(*start); func(*start);
visited.insert(start->first); visited.insert(start->first);
do{ do{
node_sets temp; nodes_set_type temp;
for (auto it = nodes.begin(); it != nodes.end(); ++it){ for (auto it = nodes.begin(); it != nodes.end(); ++it){
if (visited.count(it->first) == 0){//has not visited if (visited.count(it->first) == 0){//has not visited
func(*it); func(*it);
@@ -136,14 +136,19 @@ namespace TinySTL{
oss << "[" << oit->first << "," << oit->second << "]" << ":"; oss << "[" << oit->first << "," << oit->second << "]" << ":";
auto eit = end(oit->first); auto eit = end(oit->first);
for (auto iit = begin(oit->first); iit != eit; ++iit){ for (auto iit = begin(oit->first); iit != eit; ++iit){
oss << "[" << iit->first << ", " << iit->second << "]" << "-"; oss << "[" << iit->first << ", " << iit->second << "]" << "->";
} }
oss << "[nil,nil]" << std::endl << std::setw(4) << "|" << std::endl; oss << "[nil]" << std::endl << std::setw(4) << "|" << std::endl;
} }
oss << "[nil,nil]" << std::endl; oss << "[nil]" << std::endl;
str.append(oss.str().c_str()); str.append(oss.str().c_str());
return str; return str;
} }
template<class Index, class Value, class EqualFunc>
typename graph<Index, Value, EqualFunc>::equal_func_type
graph<Index, Value, EqualFunc>::get_equal_func()const{
return equal_func;
}
//******************************************************************************** //********************************************************************************
template<class Index, class Value, class EqualFunc> template<class Index, class Value, class EqualFunc>
inner_iterator<Index, Value, EqualFunc>& inner_iterator<Index, Value, EqualFunc>::operator ++(){ inner_iterator<Index, Value, EqualFunc>& inner_iterator<Index, Value, EqualFunc>::operator ++(){
@@ -193,11 +198,11 @@ namespace TinySTL{
template<class Index, class Value, class EqualFunc> template<class Index, class Value, class EqualFunc>
directed_graph<Index, Value, EqualFunc>::directed_graph():graph(){} directed_graph<Index, Value, EqualFunc>::directed_graph():graph(){}
template<class Index, class Value, class EqualFunc> template<class Index, class Value, class EqualFunc>
void directed_graph<Index, Value, EqualFunc>::add_node_helper(const Index& index, const node_sets& nodes){ void directed_graph<Index, Value, EqualFunc>::add_node_helper(const Index& index, const nodes_set_type& nodes){
if (nodes.empty()) if (nodes.empty())
return; return;
//find node n's list //find node n's list
list<typename graph::node>* l; list<typename graph::node_type>* l;
for (auto& pair : nodes_){ for (auto& pair : nodes_){
if (equal_func(pair.first.first, index)) if (equal_func(pair.first.first, index))
l = &(pair.second); l = &(pair.second);
@@ -210,36 +215,42 @@ namespace TinySTL{
} }
} }
template<class Index, class Value, class EqualFunc> template<class Index, class Value, class EqualFunc>
void directed_graph<Index, Value, EqualFunc>::add_node(const node& n, const node_sets& nodes){ void directed_graph<Index, Value, EqualFunc>::add_node(const node_type& n, const nodes_set_type& nodes){
if (!is_contained(n.first)){ if (!is_contained(n.first)){
nodes_.push_front(make_pair(n, list<typename graph::node>())); nodes_.push_front(make_pair(n, list<typename graph::node_type>()));
++size_; ++size_;
} }
add_node_helper(n.first, nodes); add_node_helper(n.first, nodes);
} }
template<class Index, class Value, class EqualFunc> template<class Index, class Value, class EqualFunc>
void directed_graph<Index, Value, EqualFunc>::add_node(const Index& index, const node_sets& nodes){ void directed_graph<Index, Value, EqualFunc>::add_node(const Index& index, const nodes_set_type& nodes){
add_node_helper(index, nodes); add_node_helper(index, nodes);
} }
template<class Index, class Value, class EqualFunc> template<class Index, class Value, class EqualFunc>
void directed_graph<Index, Value, EqualFunc>::delete_node(const Index& index){ void directed_graph<Index, Value, EqualFunc>::delete_node(const Index& index){
for (auto oit = nodes_.begin(); oit != nodes_.end();){ for (auto oit = nodes_.begin(); oit != nodes_.end();){
if (equal_func((oit->first).first, index))
oit = nodes_.erase(oit);
else{
auto& l = oit->second; auto& l = oit->second;
if (equal_func((oit->first).first, index)){
for (auto iit = l.begin(); iit != l.end(); ++iit){
del_node(&(*iit));
}
del_node(&(oit->first));
oit = nodes_.erase(oit);
}else{
for (auto iit = l.begin(); iit != l.end();){ for (auto iit = l.begin(); iit != l.end();){
if (equal_func(iit->first, index)) if (equal_func(iit->first, index)){
del_node(&(*iit));
iit = l.erase(iit); iit = l.erase(iit);
else }else{
++iit; ++iit;
} }
}
++oit; ++oit;
} }
} }
} }
template<class Index, class Value, class EqualFunc> template<class Index, class Value, class EqualFunc>
void directed_graph<Index, Value, EqualFunc>::delete_node(const node& item){ void directed_graph<Index, Value, EqualFunc>::delete_node(const node_type& item){
delete_node(item.first); delete_node(item.first);
} }
} }

66
TinySTL/Graph.h
View File

@@ -2,6 +2,7 @@
#define _GRAPH_H_ #define _GRAPH_H_
#include "Allocator.h" #include "Allocator.h"
#include "Iterator.h"
#include "List.h" #include "List.h"
#include "String.h" #include "String.h"
#include "Unordered_set.h" #include "Unordered_set.h"
@@ -28,35 +29,35 @@ namespace TinySTL{
typedef Index index_type; typedef Index index_type;
typedef Value value_type; typedef Value value_type;
typedef EqualFunc equal_func_type; typedef EqualFunc equal_func_type;
typedef pair<Index, Value> node; typedef pair<Index, Value> node_type;
typedef vector<node> node_sets; typedef vector<node_type> nodes_set_type;
typedef inner_iterator<Index, Value, EqualFunc> inner_iterator; typedef allocator<node_type> nodeAllocator;
typedef std::function<void(node_type&)> visiter_func_type;
typedef outter_iterator<Index, Value, EqualFunc> iterator; typedef outter_iterator<Index, Value, EqualFunc> iterator;
typedef allocator<node> nodeAllocator; typedef inner_iterator<Index, Value, EqualFunc> inner_iterator;
typedef std::function<void(node&)> visiter_func_type;
public: public:
graph() :size_(0){}; graph() :size_(0){};
virtual ~graph(){ cleanup(); }; virtual ~graph(){ cleanup(); };
//node can be not in the graph //node can be not in the graph
virtual void add_node(const node& item, const node_sets& nodes) = 0; virtual void add_node(const node_type& item, const nodes_set_type& nodes) = 0;
//node of the index must in the graph //node of the index must in the graph
virtual void add_node(const Index& index, const node_sets& nodes) = 0; virtual void add_node(const Index& index, const nodes_set_type& nodes) = 0;
virtual void delete_node(const node& item) = 0; virtual void delete_node(const node_type& item) = 0;
virtual void delete_node(const Index& index) = 0; virtual void delete_node(const Index& index) = 0;
void DFS(const Index& index, visiter_func_type func); void DFS(const Index& index, visiter_func_type func);
void BFS(const Index& index, visiter_func_type func); void BFS(const Index& index, visiter_func_type func);
node& new_node(const Index& index, const Value& val); node_type& new_node(const Index& index, const Value& val);
void del_node(node *p); void del_node(node_type *p);
node& get_node(const Index& index); node_type& get_node(const Index& index);
bool is_contained(const Index& index); bool is_contained(const Index& index);
inline static node_sets empty_node_set(); inline static nodes_set_type empty_node_set();
node_sets adjacent_nodes(const Index& index); nodes_set_type adjacent_nodes(const Index& index);
node_sets adjacent_nodes(const node& n); nodes_set_type adjacent_nodes(const node_type& n);
inline bool empty()const; inline bool empty()const;
inline size_t size()const; inline size_t size()const;
@@ -65,9 +66,10 @@ namespace TinySTL{
inline iterator begin(); inline iterator begin();
inline iterator end(); inline iterator end();
equal_func_type get_equal_func()const;
string to_string(); string to_string();
protected: protected:
list<pair<node, list<node>>> nodes_; list<pair<node_type, list<node_type>>> nodes_;
equal_func_type equal_func; equal_func_type equal_func;
size_t size_; size_t size_;
protected: protected:
@@ -75,19 +77,22 @@ namespace TinySTL{
}; };
template<class Index, class Value, class EqualFunc = equal_to<Index>> template<class Index, class Value, class EqualFunc = equal_to<Index>>
class inner_iterator{ class inner_iterator :public iterator<bidirectional_iterator_tag,
typename graph<Index, Value, EqualFunc>::node_type>{
public: public:
friend class graph < Index, Value, EqualFunc > ; friend class graph < Index, Value, EqualFunc > ;
typedef graph<Index, Value, EqualFunc>* cntrPtr; typedef graph<Index, Value, EqualFunc>* cntrPtr;
typedef graph<Index, Value, EqualFunc> graph_type; typedef graph<Index, Value, EqualFunc> graph_type;
typedef typename list<typename graph_type::node>::iterator inner_it_type; typedef typename list<typename graph_type::node_type>::iterator inner_it_type;
public: public:
explicit inner_iterator(cntrPtr c = nullptr, inner_it_type iit = inner_it_type()) explicit inner_iterator(cntrPtr c = nullptr, inner_it_type iit = inner_it_type())
:container_(c), inner_it_(iit){} :container_(c), inner_it_(iit){}
inner_iterator& operator ++(); inner_iterator& operator ++();
const inner_iterator operator ++(int); const inner_iterator operator ++(int);
typename graph_type::node& operator*(){ return *inner_it_; }
typename graph_type::node* operator ->(){ return &(operator*()); } typename graph_type::node_type& operator*(){ return *inner_it_; }
typename graph_type::node_type* operator ->(){ return &(operator*()); }
private: private:
cntrPtr container_; cntrPtr container_;
inner_it_type inner_it_; inner_it_type inner_it_;
@@ -100,22 +105,25 @@ namespace TinySTL{
const inner_iterator<Index, Value, EqualFunc>& rhs); const inner_iterator<Index, Value, EqualFunc>& rhs);
}; };
template<class Index, class Value, class EqualFunc = equal_to<Index>> template<class Index, class Value, class EqualFunc = equal_to<Index>>
class outter_iterator{ class outter_iterator :public iterator<bidirectional_iterator_tag,
typename graph<Index, Value, EqualFunc>::node_type>{
public: public:
friend class graph < Index, Value, EqualFunc >; friend class graph < Index, Value, EqualFunc >;
typedef graph<Index, Value, EqualFunc>* cntrPtr; typedef graph<Index, Value, EqualFunc>* cntrPtr;
typedef graph<Index, Value, EqualFunc> graph_type; typedef graph<Index, Value, EqualFunc> graph_type;
typedef typename list<pair<typename graph_type::node, list<typename graph_type::node>>>::iterator outter_it_type; typedef typename list<pair<typename graph_type::node_type, list<typename graph_type::node_type>>>::iterator outter_it_type;
private: private:
cntrPtr container_; cntrPtr container_;
outter_it_type outter_it_; outter_it_type outter_it_;
public: public:
explicit outter_iterator(cntrPtr c = nullptr, outter_it_type oit = outter_it_type()) explicit outter_iterator(cntrPtr c = nullptr, outter_it_type oit = outter_it_type())
:container_(c), outter_it_(oit){} :container_(c), outter_it_(oit){}
outter_iterator& operator ++(); outter_iterator& operator ++();
const outter_iterator operator ++(int); const outter_iterator operator ++(int);
typename graph_type::node& operator*(){ return outter_it_->first; }
typename graph_type::node* operator ->(){ return &(operator*()); } typename graph_type::node_type& operator*(){ return outter_it_->first; }
typename graph_type::node_type* operator ->(){ return &(operator*()); }
public: public:
template<class Index, class Value, class EqualFunc> template<class Index, class Value, class EqualFunc>
friend bool operator ==(const outter_iterator<Index, Value, EqualFunc>& lhs, friend bool operator ==(const outter_iterator<Index, Value, EqualFunc>& lhs,
@@ -126,20 +134,20 @@ namespace TinySTL{
}; };
}//end of namespace Detail }//end of namespace Detail
//<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ //directed graph
template<class Index, class Value, class EqualFunc = equal_to<Index>> template<class Index, class Value, class EqualFunc = equal_to<Index>>
class directed_graph :public Detail::graph < Index, Value, EqualFunc > { class directed_graph :public Detail::graph < Index, Value, EqualFunc > {
public: public:
directed_graph(); directed_graph();
~directed_graph(){} ~directed_graph(){}
//node n -> every node in the nodes set //node n -> every node_type in the nodes set
void add_node(const node& n, const node_sets& nodes) override final; void add_node(const node_type& n, const nodes_set_type& nodes) override final;
void add_node(const Index& index, const node_sets& nodes) override final; void add_node(const Index& index, const nodes_set_type& nodes) override final;
void delete_node(const node& item) override final; void delete_node(const node_type& item) override final;
void delete_node(const Index& index) override final; void delete_node(const Index& index) override final;
private: private:
void add_node_helper(const Index& index, const node_sets& nodes); void add_node_helper(const Index& index, const nodes_set_type& nodes);
}; };
} }