周学习总结

学到的新知识：
1.了解了STL（Standard Template Library，标准模板库)
2.cin的输入速度不如scanf，但是加上ios::sync_with_stdio(false);会使cin的输入速度有效提高
3.头文件不再担心记不住，万能头文件#include <bits/stdc++.h>
4.新的string数据类型，更方便字符串的输入输出和变换；string数据类型遇到空格就结束输入，使用getline(输入工具,输入对象)，换行符为结束标志；empty()判断是否为空，是返回1，否返回0；size()，返回string字符串长度；
5.数据结构：栈(stack)
定义：stack<data_type> stack_name;
操作函数：
empty()——表示栈内是否为空 (s.empty() )
size()——返回栈内元素个数 (s.size() )
top()——返回栈顶元素值 (s.top() )
pop()——移除栈顶元素(s.pop(); )
push(data_type a)——向栈顶压入（输入）一个元素 a (s.push(a); )
由此可见，栈（stack）具有后进后出的特点
6.数据结构：队列(queue)
定义：queue <data_type> queue_name;
操作函数：
empty()——表示queue是否为空 (q.empty() )
size()——返回queue内元素个数 (q.size() )
front()——返回queue内的第一个元素 (q.front() )
back()——返回queue内的最后一个元素(q.back() )
pop()——移除queue中的第一个元素(q.pop(); )
push(data_type a)——将一个元素a置入queue中，a为最后一个元素(q.push(a); )
由此可见，队列（queue）具有后进前出的特点
7.数据结构：动态数组(vector)
定义：vector <data_type> vector_name;
操作函数：
empty()——表示vector是否为空 (v.empty() )
size()——返回vector内元素个数 (v.size() )
push_back(data_type a)—— 将元素a插入最尾端
pop_back() ——将最尾端元素删除
v[i]—— 类似数组取第i个位置的元素(v[0] )
vector_name.back()——返回vector_name的最后一个元素
vector_name.front()——返回vector_name的第一个元素
vector_name.clear()——清空vector_name中的元素
8.排序函数-sort
sort(begin, end);
sort(begin, end, cmp);
对于排序准则cmp可自己进行定义
例如：
bool cmp(int a, int b){return a>b;}
stable_sort()可以对vector的某个成员进行排序，而且可保证相等元素的原本相对次序在排序后保持不变
9.数据结构：优先队列（priority_queue）
定义：priority_queue <data_type> priority_queue_name;
例如：priority_queue q;
操作函数：
q.push(elem)—— 将元素elem置入优先队列
q.top() ——返回优先队列的下一个元素
q.pop() ——移除一个元素
q.size() ——返回队列中元素的个数
q.empty() ——返回优先队列是否为空
优先队列（priority_queue）具有自动排序的功能，结合函数pop()和top()可实现自动排序，降序
10.去重函数（unique（））
这里的去除并非真正意义的erase，而是将重复的元素放到容器的末尾，返回值是去重之后的尾地址；unique针对的是相邻元素，所以对于顺序顺序错乱的数组成员，或者容器成员，需要先进行排序
11.使用预处理宏可以进行简化操作，节约时间
12.生成排列
bool next_permutation(begin, end);
改变区间内元素的顺序，产生下一个排列（随机排列）
bool prev_permutation(begin, end);
产生前一个排列
end为最后一个元素的下一个位置
13.upper_bound 和 lower_bound
upper_bound(begin, end, value);
返回>value的元素的第一个位置
lower_bound(begin, end, value);
返回>=value的元素的第一个位置
使用函数upper_bound 和 lower_bound可以返回出一段数字中相同数字的个数
14.set 和 multiset
set不允许两个元素有相同的键值，但multiset可以
定义：set <data_type> set_name;
例如：set s;//默认由小到大升序排列
如果想按照自己的方式排序，可以重载小于号

struct new_type
{
int x, y;
bool operator<(const new_type &a)const
     {
     if(x!=a.x) return x<a.x;
     else return y<a.y;
     }
}
	set <new_type> s;

操作函数：
s.insert(elem)——安插一个elem副本，返回新元素位置
s.erase(elem)——移除与elem元素相等的所有元素，返回被移除的元素个数
s.erase(pos)——移除迭代器pos所指位置上的元素，无返回值
s.clear()——移除全部元素，将整个容器清空
s.size()——返回容器大小
s.empty()——返回容器是否为空
s.count(elem)——返回元素值为elem的元素的个数
s.lower_bound(elem)——返回 元素值>=elem的第一个元素位置
s.upper_bound(elem)——返回元素值>elem的第一个元素的位置
以上位置均为一个迭代器
s.begin()——返回一个双向迭代器，指向第一个元素
s.end()——返回一个双向迭代器，指向最后一个元素的下一个位置
迭代器举例：

multiset <int> :: iterator pos;
for(pos=s.begin(); pos!=s.end();pos++)
		... ...

15.map和multimap
map不允许两个元素有相同的键值，但multimap可以
定义：map <data_type1, data_type2> map_name;
例如：map <string, int> m;//默认按string由小到大排序
函数操作：
m.size()——返回容器大小
m.empty()——返回容器是否为空
m.count(key)——返回键值等于key的元素的个数
m.lower_bound(key)——返回键值等于key的元素的第一个可安插的位置
m.upper_bound(key)——返回键值等于key的元素的最后一个可安插的位置
m.begin()——返回一个双向迭代器，指向第一个元素
m.end()——返回一个双向迭代器，指向最后一个元素的下一个位置
m.clear()——将整个容器清空。
m.erase(elem)——移除键值为elem的所有元素，返回个数，对 于map来说非0即1
m.erase(pos)——移除迭代器pos所指位置上的元素
直接元素存取：
m[key] = value；
查找的时候如果没有键值为key的元素，则安插一个键值为key的新元素，实值为默认(一般0)
m.insert(elem)——插入一个元素elem
a)运用value_type插入

map<string, float> m;
		m.insert(map<string, float>:: value_type ("Robin", 22.3));

b) 运用pair<>

m.insert(pair<string, float>("Robin", 22.3));

c) 运用make_pair()

m.insert(make_pair("Robin", 22.3));

16.menset函数
作用是将某一块内存中的内容全部设置为指定的值， 这个函数通常为新申请的内存做初始化工作
例如：void *memset(void *s, int ch, size_t n);
含义是将s中当前位置后面的n个字节用ch替换并返回s
感悟：
string数据类型似乎完胜与数组，数组似乎没有什么使用的必要了，之前对一组字符串进行倒序输出时所使用的繁琐的代码，使用string似乎只需要几行就完成了
对我来说感觉作用最大的是sort()函数，用sort()函数进行排序简单快捷，在本周的程序设计课上的一道题便用sort函数进行了对类中元素的排序

#include <iostream>
#include <cmath>
#include<algorithm>
using namespace std;
class point
{
    double x,y;
    public:
    void setxy(){cin>>x>>y;}
    double getx(){return x;}
    double gety(){return y;}
};
double d(point a,point b)
{
    return sqrt(pow(a.getx()-b.getx(),2)+pow(a.gety()-b.gety(),2));
}
bool cmp1(point a,point b)
{
    if(a.getx()!=b.getx())
    return a.getx()<b.getx();
      else  return a.gety()<b.gety();
}
bool cmp2(point a,point b)
{
    return a.gety()>b.gety();
}
int main()
{
    int i;
    point p[4];
    for(i=0;i<4;i++)
    {
        cout<<"请输入第"<<i+1<<"个坐标点：";
        p[i].setxy();
    }
    sort(p,p+4,cmp1);
    if(p[0].getx()==p[1].getx())
        sort(p+2,p+4,cmp2);
    if(fabs(d(p[0],p[1])-d(p[2],p[3])<=1e-8)
       &&fabs(d(p[1],p[2])-d(p[0],p[3]))<=1e-8
       &&fabs(d(p[0],p[2])-d(p[1],p[3]))<=1e-8)
        if(fabs(d(p[1],p[2])-d(p[2],p[3]))<=1e-8)
        cout<<"四个点构成正方形";
    else cout<<"四个点构成长方形";
    else cout<<"四个点构成其他四边形";
    return 0;
}

该代码是输入4个坐标点，对坐标点所组成的图形进行判断，用四条边和对角线的长度关系判断四个点所组成的图形，这样难免会有一个缺点，在输入点坐标时，需要依次按照顺时针或者逆时针输入点的坐标才能正确进行判断，但如果对输入的四个点进行排序后再进行判断，就解决了这个缺点。
在我目前的了解来看，stack、queue、vector、priority_queue这几种数据结构并没有较大差别，在使用条件并不苛刻时，拥有自动排序的priority_queue似乎就更胜一筹。
map和multimap也是成功的替代了二重数组，比二重数组更加的简便快捷。
stl中大部分进行操作的都是变量的地址，而不是变量本身，进行操作时往往需要结合*或&进行操作。
其实到现在还没有明白一个问题，那些可以自动排列的，例如priority_queue、map、multimap、set 、 multiset等对string类型的汉字是如何进行自动排列的。