#include<iostream>
#include"string"
using namespace std;

template<typename T>
void mySwap(T &a,T &b) {
    T temp = a;
    a = b;
    b = temp;
}

class Person {
public:
    Person(string name,int age) {

        m_Name = name;
        m_Age = age;
    }

    bool operator< (Person p) {
        if (this->m_Age > p.m_Age)
        {
            return false;
        }
    /*  else //默认true
        {
            return true;
        }*/
    }
    bool operator> (Person p) {
        if (this->m_Age < p.m_Age)
        {
            return false;
        }
    }
    string getName() {
        return m_Name;
    }

    int getAge() {
        return m_Age;
    }

private:
    string m_Name;
    int m_Age;
};

template<class T>  //手撸一个从大到小的选择排序 排序内容为数组，等会重载> < 运算符来排序类属性的数组
void selectSort(T arr[],int arrLength) {
    //选择排序
    for (size_t i = 0; i < arrLength; i++)  //外层循环主要作用推index 和内层循环的范围
    {
        int max = i; //assume the maxium Num is the index "i"
        //内层循环全部遍历找到最大的数的index 
        for (size_t j = i +1 ;j < arrLength; j++)
        {
            if (arr[j] > arr[max]) //制定排序规则这里选最大的，这里只是为了确定下标。后期换数据在后面操作
            {
                max = j; //这时 max下标定义为j。确定了最大的数的下标
            }
            //出了内层循环，带着最大数的下标 max 出来，这时候该交换数据了
        }
        if (max != i) {
            mySwap(arr[i], arr[max]);
        }
    }
}

template<class T>
//void bubbleSort(T arr[],int arrLength) { //这是虚假的冒泡排序。。就是选择排序的变种。掉价诶！
//  //冒泡排序
//  for (size_t i = 0; i < arrLength; i++)
//  {
//      for (int j = i; j < arrLength; j++) {  //内层将
//          
//          if (arr[i] < arr[j] ) //判断大小
//          {
//              mySwap(arr[i], arr[j]); //交换顺序
//          }
//      }
//  }
//}
void bubbleSort(T arr[],int arrLength) {
    for (size_t i = 0; i < arrLength - 1; i++)
    {
        for (int j = 0; j < arrLength - i-1;j++) {

            //判断大小，把小的往后面挪
            if (arr[j] < arr[j+1]) //交换位置函数。不如直接用mySwap()
            {
            /*  T temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;*/
                mySwap(arr[j], arr[j + 1]);
            }
        }
    }
}

template<typename T>  //这里体现函数模板不是万能的，这里如果要传入对象的数据类型，那么最好重新写一下这个函数（要么重新写要么重载）。
void printArr(T arr[],int arrLength) {

    for (size_t i = 0; i < arrLength; i++)
    {
        cout << " " << arr[i];
    }
    cout << endl;
}

void printClass(Person p[],int length) {
    for (size_t i = 0; i < length; i++)
    {
        cout << "姓名：" << p[i].getName() << "  年龄：" << p[i].getAge() << endl;
    }
}

void test() {
    char testChar[] = "abcdefgh";
    int testInt[] = { 3,5,7,8,34,1242,64,1,54,1,1 };
    Person personArr[] = {
        {"张三" ,18},{"李四" ,26},{"赵6",10},{"老李",19}
    };
    int len = sizeof(personArr) / sizeof(personArr[0]);
    //bubbleSort(personArr,4);
    selectSort(personArr, len);
    //printArr(testChar, len);
    printClass(personArr, len);
}

void main() {
    test();
    //Person personArr[] = {
    //  {"张三" ,18},{"李四" ,26},{"赵6",10},{"老李",19}
    //};
    //cout << "输出结果"  << (personArr[0] < personArr[1]) << endl;
}

Summary

• 冒泡排序：外层循环和内层循环都是从数组的头部开始遍历，内层循环将排序规则下的局部最（大/小）的数 抬 到数组最后面。循环条件 内层循环: for(j = 0; j < length - i - 1;j ++) 这里可以看出 内循环是减少已固定最大/最小的数之后剩下的再进行遍历。
• 选择排序：原理：假定最大值/最小的" index "，在内层循环每一个值和假定的" index "进行比较，如果符合条件就更新index 下标。最后出了内层循环就进行数组2个元素的替换。 核心思想：从前面往后面 取 最大/最小值。所以，index 索引会随着 i 的增加而往后移动。（有点像指针的感觉了）。最大值下标：int max = i; 内层循环: for(j = i + 1; j < length;j ++)

选择排序和冒泡排序的区别

• 选择排序不用每一个都交换位置，能节约系统资源。（其实选择排序也能每一个元素都交换顺序，像一个变种的冒泡排序）

• 我理解为选择排序可以用 “取” 这个词，而冒泡排序可以用 “抬” 这个词，一个是往自己脚底下搬，一个是往数组最后面扔。