C++作业容器二

 C++容器链表类

 头文件：list

 排序准则头文件：functional

#include<iostream>
#include<string>
#include<list>
using namespace std;
int main() 
{
    list<int> num;//链表容器对象创建
    num.push_back(3);
    num.push_back(4);
    num.push_back(5);
    num.push_back(6);//调用成员函数的方法进行尾插入数据


    return 0;
}

通过迭代器去做数据的访问

以及调用容器成员（方法）;

#include<iostream>
#include<string>
#include<list>
using namespace std;
int main() 
{
    list<int> num;//链表容器对象创建
    num.push_back(3);
    num.push_back(4);
    num.push_back(5);
    num.push_back(6);//调用成员函数的方法进行尾插入数据
    list<int>::iterator itr;//迭代器对象的创建
    for (itr= num.begin(); itr != num.end(); itr++) 
    {
        cout << *itr << "\t"; //不删除的方式去遍历数据
    }
    cout << endl;
    for (int v : num)//通过这种方式去打印数据也是可以的,
    {
        cout << v<<"\t";
    }
    cout << endl;
    cout << boolalpha << num.empty() << endl<<endl; //该方法判容器是否为空
    cout << "当前链表中的元素个数为" << num.size() << endl;

    return 0;
}

当然我们也可以删除的方式去遍历数据,也就是说我取出来一个数据后,删除掉该数据

#include<iostream>
#include<string>
#include<list>
using namespace std;
int main() 
{
    list<int> num;//链表容器对象创建
    num.push_back(3);
    num.push_back(4);
    num.push_back(5);
    num.push_back(6);//调用成员函数的方法进行尾插入数据
    list<int>::iterator itr;//迭代器对象的创建
    for (itr= num.begin(); itr != num.end(); itr++) 
    {
        cout << *itr << "\t"; //不删除的方式去遍历数据
    }
    cout << endl;
    for (int v : num)//通过这种方式去打印数据也是可以的,
    {
        cout << v<<"\t";
    }
    cout << endl;
    cout << boolalpha << num.empty() << endl<<endl; //该方法判容器是否为空
    cout << "当前链表中的元素个数为" << num.size() << endl;
    while (!num.empty()) //该成员函数返回值为容器为空放回turn,里面不为空返回假,所以取反
    {
        cout << num.front();//访问该容器第一个数据
        num.pop_front();//头部删除
    }
  
    return 0;
}

我们也可以通过find函数去做到指定位置查找或者插入 find函数的放回值应该是一个迭代器指向的类型值  insert函数插入方式为指定位置的前面插入,我们需要插入到后面的话，插入时位置find函数放回+1即可;

包括排序方式  less<int>()  默认是从小到大

个人认为返回是个地址值

#include<iostream>
#include<string>
#include<list>
using namespace std;
int main() 
{
    list<int> num;//链表容器对象创建
    num.push_back(3);
    num.push_back(4);
    num.push_back(5);
    num.push_back(6);//调用成员函数的方法进行尾插入数据
    list<int>::iterator itr;//迭代器对象的创建
    for (itr= num.begin(); itr != num.end(); itr++) 
    {
        cout << *itr << "\t"; //不删除的方式去遍历数据
    }
    cout << endl;
    for (int v : num)//通过这种方式去打印数据也是可以的,
    {
        cout << v<<"\t";
    }
    cout << endl;
    cout << boolalpha << num.empty() << endl<<endl; //该方法判容器是否为空
    cout << "当前链表中的元素个数为" << num.size() << endl;
    //while (!num.empty()) //该成员函数返回值为容器为空放回turn,里面不为空返回假,所以取反
    //{
    //    cout << num.front();//访问该容器第一个数据
    //    num.pop_front();//头部删除
    //}
    list<int>::iterator iter2;
    iter2 = find(num.begin(),num.end(),4);//查找的开始位置，查找的结束位置，查找的数据为？
    if (iter2== num.end())//end不是末尾元素的位置,是末尾元素的下一个,当两个地址相等,没有找到
    {
        cout << "该链表数据中,未发现查找的数据" << endl;
    } 
    else //反之我们找到了,可以进行插入啊 删除呀
    {
        num.insert(iter2,200);//插入的位置  插入的值  也可以删除掉原来的值
        num.insert(iter2, 400);
       // num.erase(iter2);
    }
    for (auto v : num)
    {
        cout << v << "\t";
    }
    cout << endl;
    num.reverse();//反转链表
    for (auto v : num) 
    {
        cout << v << "\t";
    }
    cout << endl;
    num.sort(less<int>());//排序准则 默认从小到大

    for (auto v : num) 
    {
        cout << v << "\t";
    }
    cout << endl;
    return 0;
}

相同元素的删除

void testDelett()
{
    list<int> listData = { 1,3,3,3,3,3,7,9 };//这种方式也是可以的
    for (int v: listData)
    {
        cout << v << "\t";
    }
    cout << endl;
    for (list<int> ::iterator istr=listData.begin(); istr!= listData.end();)//istr++
    { 
        if (*istr==3)//我们要查找的数据
        {
             //listData.erase(istr);这种写法有问题，因为istr地址已被删除
             //再去做istr++运算就直接报错,所以应该让放回的地址被迭代器去接受
            istr = listData.erase(istr);
            //链表数据被删除之后,位置也会变动
            //比如 链表第二个数据被删除,那么原来的第三个不就变成第二个了
            //所以说删除之后 迭代器接受的值 就是另一个元素的地址值了

        }
        else
        {
            istr++;
        }
    }
    for (int v : listData)
    {
        cout << v << "\t";
    }
}
int main() 
{
    testDelett();
}

容器最关键,也是最重要的一点实际上操作自定义类型（运算符重载）

class Fox
{
public:
    Fox(string name, int age, int num) :name(name), age(age), num(num) {}//构造函数走一走
    friend ostream&operator<<(ostream& out,Fox & FoxData)
    {
    
        cout << FoxData.name << " " << FoxData.age << FoxData.num;
        //友元函数无视类的权限,提供一个区域让类外能去访问类的私有数据
        return out;//放回一个这个ostream对象,可以做连续的输出
    }
    void printdata()
    {
        cout << name << "\t" << age << num;
    }
    bool operator<(const Fox&object) const
    {
        if (this->name< object.name)
        {
            return true;
        } 
        else
        {
            return false;
        }
    }
    string getname() const
    {
        return name;
    }
    int getage() const 
    {
        return age;
    }
    int getnum() const
    {
        return num;
    }
protected:
    string name;//名字
    int age;//年龄
    int num;//编号
};
bool CmpByage(const Fox&object1,const Fox&object2) //由于类外访问,我们需要提供公有接口
{
    if (object1.getage() < object2.getage())
    {
        return true;
    } 
    else 
    {
        return false;
    }
 }
bool CmpBynum(const Fox& object1, const Fox& object2) //由于类外访问,我们需要提供公有接口
{
    if (object1.getnum() < object2.getnum())
    {
        return true;
    } else {
        return false;
    }
}
void testMyData() 
{
    list<Fox> foxdata;
    foxdata.push_back(Fox("狐狸1",18,3));
    foxdata.push_back(Fox("狐狸2",7, 1));
    foxdata.push_back(Fox("狐狸3",1,2));
    list<Fox>::iterator iter;
    for (iter = foxdata.begin(); iter != foxdata.end(); iter++)
    {
        cout << *iter << endl; //输出自定义类型,需要重载一下<< 
    }
    for (Fox v: foxdata) //这里放回的是一个对象,因此可以调用每个对象的方法
    {
        v.printdata();//不想写<<运算符就用这种方法
        cout << endl;
    }
    string  tempname;
    int  tempage, tempnum;
    while (1)
    {
        cout << "请输入新狐狸的名字,年龄,编号" << endl;
        cin >> tempname >> tempage >> tempnum;
        foxdata.push_back(Fox(tempname, tempage, tempnum));//直接调用一下Fox的构造函数
        cout << "输入  停止输入,即可结束输入" << endl;
        cin >> tempname;
        if (tempname=="停止输入")
        {
            break;
        }
    }
    //涉及比较的问题,我们都需要一个排序准则,为我们自己写的数据类型排序
    foxdata.sort(less<Fox>());//类型是Fox,排序从小到大,方式为比较我们写的准则
    //我们发现通过类去重载运算符,只能实现单一性比较,比如我重载过一次通过年龄小于号比较
    //我们就不能再次重载小于号,所以我们可以通过函数的方式去标胶
    for (iter = foxdata.begin(); iter != foxdata.end(); iter++) 
    {
        cout << *iter << "\t"; //输出自定义类型,需要重载一下<< 
    }
    cout << endl;
    foxdata.sort(CmpByage);
    for (iter = foxdata.begin(); iter != foxdata.end(); iter++)
    {
        cout << *iter << "\t"; //输出自定义类型,需要重载一下<< 
    }
    cout << endl;
    foxdata.sort(CmpBynum);//可以实现同一个运算符多次重载
    for (iter = foxdata.begin(); iter != foxdata.end(); iter++) 
    {
        cout << *iter << "\t"; //输出自定义类型,需要重载一下<< 
    }
    cout << endl;
}
int main() 
{
    testMyData();
}

链表的数据操作基本就这些东西

2.栈 头文件stack  栈只要记住一个东西,先进去的东西,永远是最后一个出来的

一般来说可以用来处理一些特定的情况（处理二进制转换）

因为二进制短除法反向取余 就是某一个数的二进制形式

void teststack()
{
    stack<int> stacdata;
    for (int i = 0; i < 5; i++)
    {
        stacdata.push(i);//插入为  0 ~ 4
    }
    while (!stacdata.empty()) 
    {
        cout << stacdata.top() << "\t";
        stacdata.pop();
        //这里记得要删除,不管怎么取数据必须先进后出,
        // 如果弄骚操作（比如通过某种指针,去取其中的数据）,那么它就不能叫栈结构
    }

}
void numTobit(int num) //数字转二进制函数
{
    stack<int> mybin;
    while (num) 
    {
        mybin.push(num % 2);//取2的余只有0和1
        num = num / 2;
    }
    for (int i = mybin.size(); i < 8; i++) //如果不满足8位 
    {
        mybin.push(0);
    }
    while (!mybin.empty())//输出测试一下
    {
        cout << mybin.top();
        mybin.pop();
    }
    cout << endl;
}
int main() 
{
    teststack();
    numTobit(9);
}

3.队列 头文件是queue

 双向队列：可以从头到尾,也可以从尾到头先出

void testdeque() 
{
    deque<int> DeData;
    for (int i = 0; i < 5; i++)
    {
        DeData.push_back(i);//尾插入
        DeData.push_front(i);//头插入
        //4 3 2 1 0 0 1 2 3 4
    }
    while (!DeData.empty())//头部先出
    {
        cout << DeData.front();
        DeData.pop_front(); 
    }
    while (!DeData.empty())//当然也可以尾部先出
    {
        cout << DeData.back();
        DeData.pop_back();
    }

}
int main() 
{
    testdeque();
}

普通队列  头文件queue,与栈为对应关系,单队列为先进先出

void testqueue() 
{
    queue<int> QuData;
    for (int i = 0; i < 5; i++) 
    {
        QuData.push(i);
    
    }
    while (!QuData.empty())
    {
        cout << QuData.front();
        QuData.pop();
    }
}
int main() 
{
    testqueue();
}

优先队列  所谓优先队列，就是按照特殊的比较方式出队

void testpriority() 
{
    //priority_queue 第一个参数是类型
    //priority_queue 传入的是一个容器
    //priority_queue 第三个参数是排序准则
    priority_queue<int> data1;//默认创建,默认容器类型是vector
    priority_queue<int, vector<int>, less<int>> data2; //优先默认是从大到小排序
    //可以把less改成  greater<int>就是从小到大排序
  
    data2.push(18);
    data2.push(11);
    data2.push(7);
    data2.push(3);
  
   while (!data2.empty())
    {
        cout << data2.top()<<"\t";
        data2.pop();
    }
}
int main() 
{
    testpriority();
}