stl01

最新推荐文章于 2024-10-13 16:55:28 发布
yeyesea
最新推荐文章于 2024-10-13 16:55:28 发布
阅读量178
点赞数
文章标签：算法 c++
本文链接：https://blog.csdn.net/qq_41758919/article/details/119989403
版权
#include<iostream>
#include<vector>
#include<algorithm>//标准算法头文件
using namespace std;
void myprint(int val) {
	cout << val << endl;
}
void test01() {

	vector<int>v;
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);
	/*vector<int>::iterator itBegin = v.begin();
	vector<int>::iterator itEnd = v.end();
	while (itBegin != itEnd) {
		cout << *itBegin << endl;
		itBegin++;
	
	}*/
	/*for (vector<int>::iterator it=v.begin(); it != v.end(); it++) {
		cout << *it << endl;
	}*/
	for_each(v.begin(), v.end(), myprint);

}
int main() {
	
	test01();

}



#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
class Person {
public://方法
	Person(string name,int age) {
		/*m_Name = name;
		m_Age = age;*/
		this->m_Name = name;
		this->m_Age = age;
	}

public://属性
	string m_Name;
	int m_Age;
};


void test01() {
	vector<Person>v;
	Person p1("aa", 10);
	Person p2("bb", 20);
	Person p3("cc", 30);
	Person p4("dd", 40);
	Person p5("ee", 50);
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);
	/*for_each(vector<Person>::iterator it = v.begin(); it != v.end(); it++) {
	
	}*/
	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++) {
	
		/*cout << "姓名：" << (*it).m_Name << endl;
		cout << "年龄" << (*it).m_Age << endl;*/
		cout << "姓名：" << it->m_Name << endl;
		cout << "年龄：" << it->m_Age << endl;
	
	}
}

void test02() {
	vector<Person*>v;
	Person p1("aa", 10);
	Person p2("bb", 20);
	Person p3("cc", 30);
	Person p4("dd", 40);
	Person p5("ee", 50);
	v.push_back(&p1);
	v.push_back(&p2);
	v.push_back(&p3);
	v.push_back(&p4);
	v.push_back(&p5);
	for (vector<Person *>::iterator it=v.begin(); it != v.end(); it++) {
		cout << "姓名：" << (*it)->m_Name << endl;
		cout << "年龄：" << (*it)->m_Age << endl;
	}




}
int main() {
	test02();




	system("pause");
	return 0;

}





#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
void test01() {
	vector<vector<int>>v;
	vector<int> v1;
	vector<int> v2;
	vector<int> v3;
	vector<int> v4;
	for (int i = 0; i < 4; i++) {
		v1.push_back(i + 1);
		v2.push_back(i + 2);
		v3.push_back(i + 3);
		v4.push_back(i + 4);

	}
	v.push_back(v1);
	v.push_back(v2);
	v.push_back(v3);
	v.push_back(v4);
	for (vector<vector<int>>::iterator it = v.begin(); it != v.end(); it++) {
		for (vector<int>::iterator it0 = (*it).begin(); it0 != (*it).end(); it0++) {
			cout << *it0;
		}
		cout << endl;
	}


}


int main() {
	test01();



	system("pause");
	return 0;
}








#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
using namespace std;
int main() {
	string s = "12345678";
	//增
	/*s.replace(0, 0, "0");*/

	//删
	/*s.replace(3, 2,"");*/

	//改
	s.replace(1, 2, "66");
	cout << s << endl;
	system("pause");
	return 0;
}








#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
using namespace std;

void myprint(vector<int>&v) {
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << (*it) << " ";
	}
	cout << endl;
}



void test01() {
	vector<int>v1;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);//直接装
	}
	myprint(v1);
	
	vector<int>v2(v1.begin(), v1.end());//截取一段
	myprint(v2);

	vector<int>v3(10, 8);//十个8
	myprint(v3);

	vector<int>v4(v3);//拷贝赋值
	myprint(v4);


}





int main() {
	test01();

	system("pause");
	return 0;
}




#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
void myprint(vector<int>&v) {
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << (*it) << " ";
	}

	cout << endl;

}
void test01() {
	vector<int>v1;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
	}
	vector<int>v2,v3,v4;

	v2 = v1;
	v3.assign(v1.begin(), v1.end());
	v4.assign(10, 8);

	myprint(v1);
	myprint(v2);
	myprint(v3);
	myprint(v4);
}


int main() {
	test01();





	system("pause");
	return 0;
}




#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;

void myprint(vector<int>&v) {
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << (*it) << " ";
	}
	cout << endl;

}



void test01() {
	vector<int>v1;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
	}
	myprint(v1);
	if (v1.empty()) {
		cout << "v1为空" << endl;
	}
	else {
		cout << "v1不为空" << endl;
		cout << v1.capacity()<< endl;
		cout << v1.size() << endl;
	}
	v1.resize(2);
	myprint(v1);
	cout << v1.capacity() << endl;
}




int main() {

	test01();





	system("pause");
	return 0;
}



#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;

void myprint(vector<int>&v) {
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}



void test01() {
	vector<int>v1;
	v1.push_back(10);
	v1.push_back(20);
	v1.push_back(30);
	v1.push_back(40);
	v1.push_back(50);
	
	v1.pop_back();
	v1.insert(v1.begin(), 8);
	v1.insert(v1.begin(), 10, 8);//vector<int>的删除要提供迭代器
	v1.erase(v1.begin());
	v1.erase(v1.begin(), v1.end());
	v1.clear();
	myprint(v1);
}



int main() {
	test01();





	system("pause");
	return 0;
}

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;


void myprint(vector<int>&v) {
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}


void test01() {
	vector<int>v1;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
	}
	for (int i = 0; i < v1.size(); i++) {
		/*cout << v1[i] << " ";*/
		cout << v1.at(i) << " ";
	}
	cout << endl;
	cout << v1.front() << endl;
	cout << v1.back() << endl;
}

void test02() {
	vector<int>v1;
	v1.assign(5, 0);
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(0);
	v1.push_back(0);
	myprint(v1);
	while (v1.front() == 0) {
		v1.erase(v1.begin());
	}
	while (v1.back() == 0) {
		v1.pop_back();
	}
	myprint(v1);


}

int main() {
	test02();




	system("pause");
	return 0;
}




#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;

void myprint(vector<int>&v) {
	for (vector<int>::iterator it=v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}


void test01() {
	vector<int>v1,v2;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
	}
	for (int i = 10; i > 0; i--) {
		v2.push_back(i);
	}
	cout << "交换前" << endl;
	myprint(v1);
	myprint(v2);
	cout << "交换后" << endl;
	v1.swap(v2);
	myprint(v1);
	myprint(v2);

}

void test02() {
	vector<int>v1;
	for (int i = 0; i < 10000; i++) {
		v1.push_back(i);
	}
	cout << "v1的容量" << v1.capacity() << endl;
	cout << "v1的大小" << v1.size() << endl;

	v1.resize(2);
	cout << "v1的容量" << v1.capacity() << endl;
	cout << "v1的大小" << v1.size() << endl;
	
	vector<int>(v1).swap(v1);
	cout << "v1的容量" << v1.capacity() << endl;
	cout << "v1的大小" << v1.size() << endl;


	v1.push_back(3);
	cout << "v1的容量" << v1.capacity() << endl;
	cout << "v1的大小" << v1.size() << endl;
}


int main() {
	
	test02();


	system("pause");
	return 0;
}




#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;

void myprint(vector<int>&v) {
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
}


void test01() {
	vector<int>v;
	int num = 0;
	int *p = NULL;
	for (int i = 0; i < 10000; i++) {
		v.push_back(i);
		if (p != &v[0]) {
			p = &v[0];
			num++;
		}
	}
	cout << num << endl;
}
void test02() {
	vector<int>v;
	v.reserve(10000);
	int num = 0;
	int* p = NULL;
	for (int i = 0; i < 10000; i++) {
		v.push_back(i);
		if (p != &v[0]) {
			p = &v[0];
			num++;
		}
	}
	cout << num << endl;
}
int main() {
	test02();





	system("pause");
	return 0;
}


#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<deque>
using namespace std;

void myprint(deque<int>&d) {
	for (deque<int>::iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}
void test01() {
	deque<int>d1;
	for (int i = 0; i < 10; i++) {
		d1.push_back(i);
	}
	myprint(d1);
	deque<int>d2(d1.begin(), d1.end());//区间的方式赋值
	myprint(d2);

	deque<int>d3(10, 8);
	myprint(d3);

	deque<int>d4(d3);
	myprint(d4);
}


int main() {
	test01();





	system("pause");
	return 0;
}


#include<iostream>
#include<string>
#include<vector>
#include<deque>
#include<algorithm>
using namespace std;
void myprint(deque<int>&d) {
	for (deque<int>::iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

void test01() {
	deque<int>d1,d2,d3,d4;
	for (int i = 0; i < 10; i++) {
		d1.push_back(i);
	
	}
	myprint(d1);

	d2 = d1;
	myprint(d2);//赋值

	d3.assign(d1.begin(), d1.end());
	myprint(d3);

	d4.assign(10, 8);
	myprint(d4);
	

}
int main() {
	test01();



	system("pause");
	return 0;
}


#include<iostream>
#include<string>
#include<vector>
#include<deque>
#include<algorithm>
using namespace std;

void myprint(deque<int>&d) {
	for (deque<int>::iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}
void test01() {
	deque<int>d1;
	for (int i = 0; i < 10; i++) {
		d1.push_back(i);
	}
	cout << d1.empty() << endl;
	cout << d1.size() << endl;
	d1.resize(20,1);
	myprint(d1);

}
void test02() {
	deque<int>d1,d2;
	for (int i = 0; i < 10; i++) {
		d1.push_back(i);
		d2.push_back(i);
	}
	d1.push_front(9);
	d1.pop_back();
	d1.pop_front();
	d1.insert(d1.begin(), 9);
	d1.insert(d1.begin(), 10, 8);
	d1.insert(d1.begin(), d2.begin(), d2.end());
	d1.erase(d1.begin());
	d1.erase(d1.begin(), d1.end());
	d1.clear();
	myprint(d1);

}
int main() {
	test02();





	system("pause");
	return 0;
}



#include<iostream>
#include<string>
#include<vector>
#include<deque>
#include<algorithm>
using namespace std;

void myprint(deque<int>&d) {
	for (deque<int>::iterator it = d.begin(); it != d.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

void test01() {
	deque<int>d1;
	for (int i = 0; i < 10; i++) {
		d1.push_back(i);
	}

	cout << d1[0] << endl;
	cout << d1.at(0) << endl;
	cout << d1.front() << endl;
	cout << d1.back() << endl;
	d1.front() = 9;
	sort(d1.begin(), d1.end());
	myprint(d1);
}



int main() {
	test01();


	system("pause");
	return 0;
}



#include<iostream>
#include<string>
#include<vector>
#include<deque>
#include<algorithm>
#include<ctime>
using namespace std;

class Person {

public:
	Person(string name, double score) {
		this->m_Name = name;
		this->m_Score = score;
	}


	string m_Name;
	double m_Score;
};

void myprint(vector<Person>& v) {
	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++) {
		cout << "姓名:" << (*it).m_Name << "  分数：" << (*it).m_Score << endl;
	}

}

void createPerson(vector<Person>& v) {
	string nameSeed = "ABCDE";
	for (int i = 0; i < 5; i++) {
		string name = "选手";
		name += nameSeed[i];
		double score = 0;
		Person p(name, score);
		v.push_back(p);
	}

}
void setScore(vector<Person>& v) {

	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++) {
		cout << "请对" << (*it).m_Name << "打分" << endl;
		deque<double>d;
		for (int i = 0; i < 10; i++) {

			double a=rand()%41+60;
		
			d.push_back(a);
		}
		sort(d.begin(), d.end());
		d.pop_front();
		d.pop_back();
		double sum = 0;
		for (int i = 0; i < d.size(); i++) {
			sum += d[i];
		}
		(*it).m_Score = sum /8;
	}



}


int main() {
	srand((unsigned int)time(NULL));
	vector<Person>v;
	createPerson(v);
	setScore(v);
	myprint(v);





	system("pause");
	return 0;
}





#include<iostream>
#include<string>
#include<vector>
#include<deque>
#include<stack>
#include<algorithm>
using namespace std;



//堆容器
void test01() {
	stack<int>s;
	cout << s.empty() << endl;
	s.push(1);
	s.push(2);
	s.push(3);
	cout << s.size() << endl;
	
	s.pop();
	cout << s.top() << endl;
}
int main() {
	test01();






	system("pause");
	return 0;
}





#include<iostream>
#include<string>
#include<vector>
#include<deque>
#include<stack>
#include<queue>
#include<algorithm>
using namespace std;


void test01() {
	queue<int>q,q1;
	cout << q.empty() << endl;
	q.push(10);
	q.push(20);
	q.push(30);
	q.push(40);
	cout << q.size() << endl;
	q.pop();
	q1 = q;
	cout << q.front() << endl;
	cout << q.back() << endl;


}

int main() {
	test01();




	system("pause");
	return 0;
}



#include<iostream>
#include<string>
#include<vector>
#include<deque>
#include<stack>
#include<queue>
#include<list>
#include<algorithm>
using namespace std;
bool myCompare(int v1, int v2) {
	return v1>v2; 
}
void myprint(list<int>&l) {
	for (list<int>::iterator it = l.begin(); it != l.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

void test01() {
	list<int>l;
	list<int>l1(10, 8);
	list<int>l2(l1);
	list<int>l3(l1.begin(), l1.end());
	l.push_front(0);
	l.push_back(1);
	cout << l.front() << endl;
	cout << l.back() << endl;
	cout << l.empty() << endl;
	cout << l.size() << endl;
	myprint(l3);
}
void test02() {
	list<int>l,l1,l2;
	l.assign(10, 8);
	l1 = l;
	l2.assign(l.begin(), l.end());
	l.swap(l1);
	l.resize(15,9);
	myprint(l);
}

void test03() {
	list<int>l,l1;
	l.push_back(10);
	l.push_back(20);
	l.push_back(30);
	l.push_front(5);
	l1 = l;
	l.pop_back();
	l.pop_front();
	l.insert(l.begin(), 9);
	l.insert(l.begin(), 10, 8);
	l.insert(l.begin(), l1.begin(), l1.end());
	l.remove(10);
	l.reverse();
	l.sort(myCompare);
	myprint(l);
	l.erase(l.begin());
	l.erase(l.begin(), l.end());
	l.clear();
	



}
void test04() {



}
int main() {
	test03();




	system("pause");
	return 0;
}




#include<iostream>
#include<string>
#include<vector>
#include<deque>
#include<stack>
#include<queue>
#include<list>
#include<algorithm>
#include <cstdlib>
#include<ctime>

using namespace std;

class Person {

public:
	Person(string name, int age, int height) {
		this->m_Name = name;
		this->m_Age = age;
		this->m_Height = height;
	}
public:
	string m_Name;
	int m_Age;
	int m_Height;

};

void createPerson(list<Person>&l) {
	string nameSeed = "ABCDE";
	for (int i = 0; i < 5; i++) {
		string name = "同学";
		name += nameSeed[i];
		int age = rand() % 11 + 10;
		int height = rand() % 31 + 150;
		Person p(name, age, height);
		l.push_back(p);
	}


}
void myprint(list<Person>& l) {
	for (list<Person>::iterator it = l.begin(); it != l.end(); it++) {
		cout << "姓名：" << (*it).m_Name << "  年龄：" << (*it).m_Age << "  身高：" << (*it).m_Height << endl;
	}



}
bool myCompare(Person& p1, Person& p2) {
	if (p1.m_Age == p2.m_Age) {
		return p1.m_Height > p2.m_Height;
	}
	return p1.m_Age < p2.m_Age;
}
void test01() {
	list<Person>l;
	createPerson(l);
	l.sort(myCompare);
	myprint(l);
}
int main() {
	test01();



	system("pause");
	return 0;
}




#include<iostream>
#include<string>
#include<vector>
#include<deque>
#include<stack>
#include<queue>
#include<list>
#include<set>//自动去重,自动排序，类似于集合

#include<algorithm>
using namespace std;
void myprint(set<int>&s) {
	for (set<int>::iterator it = s.begin(); it != s.end(); it++) {
		cout << (*it) << " ";
	}
	cout << endl;
}
void test01() {
	set<int>s,s1;
	s.insert(30);
	s.insert(20);
	s.insert(10);
	s.insert(40);
	s.insert(20);
	s1 = s;
	s1.swap(s);
	myprint(s1);
	cout << s.empty() << endl;
	cout << s.size() << endl;
}
void test02() {
	set<int>s;
	s.insert(10);
	s.insert(20);
	s.insert(30);
	s.insert(40);
	s.erase(20);
	set<int>::iterator pos = s.find(90);
	if (pos != s.end()) {
		cout << "查找到了" << endl;
	}
	else {
		cout << "没查找到" << endl;
	}
	cout << s.count(10) << endl;
	myprint(s);
	s.erase(s.begin());
	s.erase(s.begin(), s.end());
	s.clear();

}

void test03() {
	set<int>s;
	s.insert(10);
	
	pair<set<int>::iterator, bool> ret = s.insert(10);
	if (ret.second) {
		cout << "插入成功" << endl;
	}
	else {
		cout << "插入失败" << endl;
	}

}

void test04() {
	multiset<int>ms;
	ms.insert(10);
	ms.insert(20);
	ms.insert(10);
	cout << ms.count(10) << endl;

}



int main() {
	test04();





	system("pause");
	return 0;
}




#include<iostream>
#include<string>
#include<vector>
#include<deque>
#include<stack>
#include<queue>
#include<list>
#include<set>
#include<algorithm>
using namespace std;

class myCompare {
public:
	 bool operator()(int v1,int v2)const {
		return v1 > v2;
	}
};


void myprint(set<int>&s) {
	for (set<int>::iterator it = s.begin(); it != s.end(); it++) {
		cout << (*it) << " ";
	}
	cout << endl;
}

void myprint1(set<int,myCompare>&s) {
	
	cout << endl;
}

void test01() {
	pair<int, int> p(10, 20);
	cout << p.first << endl;
	pair<string, string>p1("孙悟空", "猴子"),p2;
	cout << p1.first << "是"<<p1.second<<endl;
	p2 = p1;
	cout << p2.first << endl;
}

void test02() {
	set<int>s1;
	s1.insert(10);
	s1.insert(20);
	s1.insert(30);
	s1.insert(40);
	s1.insert(50);
	myprint(s1);
	

	set<int,myCompare>s2;
	s2.insert(10);
	s2.insert(20);
	s2.insert(30);
	s2.insert(40);
	s2.insert(50);
	for (set<int, myCompare>::iterator it = s2.begin(); it != s2.end(); it++) {
		cout << (*it) << " ";
	}

}

int main() {
	test02();




	system("pause");
	return 0;
}





#include<iostream>
#include<string>
#include<vector>
#include<deque>
#include<stack>
#include<queue>
#include<list>
#include<set>
#include<algorithm>
using namespace std;

class Person {
public:

	Person(string name,int age) {
		this->m_Name = name;
		this->m_Age = age;
	}

public:
	string m_Name;
	int m_Age;
};


class myCompare {
public:
	bool operator()(Person p1, Person p2)const {
		return p1.m_Age > p2.m_Age;
	}
};
void test01() {
	set<Person,myCompare>s;
	Person p1("选手A", 18);
	Person p2("选手B", 12);
	Person p3("选手C", 15);
	Person p4("选手D", 11);
	s.insert(p1);
	s.insert(p2);
	s.insert(p3);
	s.insert(p4);
	for (set<Person,myCompare>::iterator it = s.begin(); it != s.end();it++) {
		cout << "姓名：" << (*it).m_Name << " 年龄：" << (*it).m_Age << endl;
	}
}

int main() {
	test01();



	system("pause");
	return 0;
}





#include<iostream>
#include<string>
#include<vector>
#include<deque>
#include<stack>
#include<queue>
#include<list>
#include<set>
#include<map>
#include<algorithm>
using namespace std;
class myCompare {
public:
	bool operator()(int v1, int v2)const {
		return v1 > v2;
	}
};
void myprint(map<int,int>&m) {
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++) {
		cout << (*it).first << " " << (*it).second << endl;
	}
	cout << endl;
}

void myprint1(map<int, int,myCompare>& m) {
	for (map<int, int,myCompare>::iterator it = m.begin(); it != m.end(); it++) {
		cout << (*it).first << " " << (*it).second << endl;
	}
	cout << endl;
}


void test01() {
	map<int, int>m;//能够自动排序，去重，支持对组
	
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(4, 40));
	m.insert(pair<int, int>(3, 30));
	m.insert(pair<int, int>(1, 10));
	
	myprint(m);
	map<int, int>m1(m),m2;
	
	m2 = m;
	myprint(m2);
	cout << m.empty() << endl;
	cout << m.size() << endl;
	m.swap(m1);
}
void test02() {
	map<int, int>m;
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));
	m.insert(pair<int, int>(4, 40));
	myprint(m);
	m.erase(3);
	myprint(m);
	m.erase(m.begin());
	myprint(m);
	m.erase(m.begin(), m.end());
	myprint(m);
	m.clear();
	


}
void test03() {
	map<int, int>m;
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));
	m.insert(pair<int, int>(4, 40));

	map<int,int>::iterator pos=m.find(1);
	cout << m.count(1) << endl;

}
void test04() {
	map<int, int,myCompare>m;
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));
	m.insert(pair<int, int>(4, 40));
	myprint1(m);
}
int main() {
	test04();





	system("pause");
	return 0;
}