小细节处理

以下是简化版
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
bool map(int a,int b)
{
	return a>b;
}
struct Graph
{
	int v;
	list*adj;
	Graph(int v):v(v),adj(new list[v]){}
	void addedge(int w,int v)
	{
		adj[v].push_back(w);
		adj[w].push_back(v);
	}
	void remove(int a)
	{
		for(int i=0;ivisited(v,false);
		queuequeue;
		visited[start]=true;
		queue.push(start);
		while(!queue.empty())
		{
			int a=queue.front();
			cout<visited(v,false);
		stackstack;
		visited[start]=true;
		stack.push(start);
		while(!stack.empty())
		{
			int a=stack.top();
			cout<>n>>m;
	Graph g(n);
	int a,b;
	for(int i=0;i>a>>b;
		g.addedge(a,b);
	}
	int todelete;
	cin>>todelete;
	g.dfs(0);
	g.remove(todelete);
	g.BFS(0);
	return 0;


}

重载运算符：重载<运算符。

    bool operator<(const Edge&s)const{
        return w

字符串去空格：

void removeSpace(string &str)
{
    std::string::size_type index = 0;
    if(!str.empty())
    {
        while((index=str.find(' ',index))!=string::npos)
        {
            str.erase(index,1);
        }
    }
}

邻接表构建，深度广度，层次搜索：

#include
#include 
#include
#include
#include 
#include
using namespace std;
class Graph
{
    int V;//顶点个数
    list*adj;//邻接表 
    public:
    Graph(int V);//构造函数
    void addEdge(int v,int w);//添加边
    void DFS(int v,vector&visited);//深度优先搜索
    void BFS(int s);//广度优先搜索
    void removeVertex(int v);//删除节点
    void printDFS(int start);//输出深度优先搜索序列
    void printBFS(int start);//输出广度优先搜索序列
};
Graph::Graph(int V)//构造函数，将实参V传递给形参V，表示有V个顶点
{
    this->V = V;
    adj = new list[V];//邻接表有v个元素
}
void Graph::addEdge(int v,int w)
{
   adj[v].push_back(w);//添加w的边添加到v的邻接表中
    adj[w].push_back(v);//添加v的边到w的邻接表中
}
void Graph::DFS(int v,vector&visited)//邻接表的深度优先搜索实现
{
    visited[v]=true;//索引为v的元素设置为true，表示当前节点v已经被访问过。
    cout<::iterator i;
    for(i = adj[v].begin();i!=adj[v].end();i++)
    if(!visited[*i])
    DFS(*i,visited);
}
void Graph::BFS(int s)//邻接表的广度优先搜索实现
{
    vectorvisited(V,false);
    queuequeue;
    visited[s]=true;
    queue.push(s);
    while(!queue.empty())
    {
        s=queue.front();
        cout<visited(V,false);
    DFS(start,visited);
    cout<>n>>m;
    Graph g(n);
    int a,b;
    for(int i=0;i>a>>b;
        g.addEdge(a,b);
    }
    int toDelete;
    cin>>toDelete;
    g.printDFS(0);
    g.removeVertex(toDelete);
    g.printBFS(0);
    return 0;
}

字符串是否可迭代，（由相同元组组成）：

#include 
#include 
using namespace std;
int main()
{
	string str;
	cin>>str;
	int len=str.size();
	if(len==1)
	{
	cout<<"false"<

实现strStr():实现输入即输出

#include 
#include 
#include 
using namespace std;
void BF(string strfu,string strzi,queue&queue,int i)
{
	int j=0;
	while(i>strfu>>strzi)
    {
	queuequeue,Que;
	BF(strfu,strzi,queue,0);
	if(!queue.empty())
	cout<

从字符串后往前数n个（设字符串长度是lenstr）得到的字符是str.substr(lenstr-n).

#include 
#include 
#include 
using namespace std;
void ju(string str1,int lenstr1,string str2,int lenstr2)
{
    for(int i=lenstr1;i>0;i--)
    {
        string str=str1.substr(0,i);
        if(i>str1>>str2;
    int lenstr1=str1.size();
    int lenstr2=str2.size();
    ju(str1,lenstr1,str2,lenstr2);
    return 0;
}