30.algorithm排序小结

• 如果容器中是类,如果要调用sort则需要重载操作符 "<"
• 包含头文件

   #define _CRT_SECURE_NO_WARNINGS
   #include <vector>
   #include <list>
   #include <algorithm>
   #include <iostream>
   #include <algorithm>
   #include <string>
   #include <iterator>
   using namespace std;

• 通过结构体vector对象数组与仿函数对对象进行排序

   //vector结构体排序
   struct student
   {
       int score;
       char name[];
       student(int s, char *n)
       {
           score = s;
           strcpy(name, n);
       }
       //需要重载小于运算符来对vector数组进行排序
       bool operator <(const student &s2)
       {
           if (this->score > s2.score)
           {
               return ;
           }
           else
           {
               return ;
           }
       }
   };
  
   void main1()
   {
       vector<student> mylist{ {,""},{,""},{,""},{ ,"" } };
       //取前两名
       partial_sort(mylist.begin(), mylist.begin() + , mylist.end());
  
       for (auto i : mylist)
       {
           cout << i.name <<"  " << i.score << endl;
       }
  
       cin.get();
   }

• sort()对数组进行排序,以及取出前三名

   //数组的sort
       {
           vector<int> mylist{ ,,,,, };
           sort(mylist.begin(), mylist.end());
           for (auto i : mylist)
           {
               cout << i << endl;
           }
       }
       cout << endl;
  
       //只取一部分(比如对一串数据只取前三名)
       {
           vector<int> mylist{ ,,,,, };
           partial_sort(mylist.begin(), mylist.begin() + , mylist.end());
           for (auto i : mylist)
           {
               cout << i << endl;
           }
       }

• 全排列,一直对调,随机打乱,一直到升序的时候不能再打乱

   //全排列
       //一直对调,随机打乱,一直到升序的时候不能再打乱
       {
           int a[] = { ,,,, };
           int count = ;
           do
           {
               for (auto i : a)
               {
                   cout << i;
               }
               cout << endl;
               count++;
           } while (prev_permutation(a, a + ));
           cout << count << endl;
       }

• 全排列随机对调,直到降序不能再打乱

   int a[] = { ,,,, };
           int count = ;
           do
           {
               for (auto i : a)
               {
                   cout << i;
               }
               cout << endl;
               count++;
               //如果有序,则返回值是零
           } while (next_permutation(a, a + ));
           cout << count << endl;

• 自动对字符串进行排序

   char *s1 = "book";
           char *s2 = "hello";
           bool res = lexicographical_compare(s1, s1 + strlen(s1), s2, s2 + strlen(s2));
           if (res)
           {
               cout << "s1在s2前面" << endl;
           }
           else
           {
               cout << "s1在s2后面" << endl;
           }

• 分块排序,小的向左,大 的向右

   //分块排序
       {
           int a[] = { ,,,,,,,,,,,,,, };
           //以a+8为中心,小于向左,大于向右
           nth_element(a, a + , a + );
           for_each(a, a + , [](int x) {cout << x << endl; });
       }

• 求最大最小

   {
           //求最大值最小值
           int a = max({ ,,,, });
           int b = min({ ,,,, });
           auto it = minmax({ ,,,, });
           cout << a << endl;
           cout << it.first << endl;
           cout << it.second << endl;
       }

• 判断是全满足还是部分满足还是都不满足

   //all_of  全部满足
       //any_of  至少有一个满足
       //none_of 都不满足
       {
           vector<int> myint{ ,,,, };
           bool isit = all_of(myint.begin(), myint.end(), [](int i)->bool {return i %  != ; });
           //类似还有 any_of none_of
           if (isit)
           {
               cout << "OK" << endl;
           }
           else
           {
               cout << "NOT OK" << endl;
           }
       }

• 条件拷贝

   //copy_if 条件拷贝
       {
           vector<int> v1{ ,,,, };
           vector<int> v2(v1.size());
           auto it = copy_if(v1.begin(), v1.end(), v2.begin(),[](int i) {return i % ; });
           //压缩容器
           v1.resize(distance(v2.begin(), it));
       }

• 部分排序以后复制到另外一个容器对副本进行操作(局部排序)

   void main22()
   {
       //数组的sort
       {
           vector<int> mylist{ ,,,,, };
           int a[]{  };
           partial_sort_copy(mylist.begin(), mylist.end(), a, a + );
       }
       cin.get();
   }

• 容器二分查找

   void main3()
   {
       int a[] = { ,,,,,,,,, };
       //默认从小到大
       sort(a, a + , [](int a, int b) {return a < b; });
       for (auto i : a)
       {
           cout << i << endl;
       }
  
       //取数组中的最小值
       cout << *min_element(a, a + ) << endl;
       //取数组中的最大值
       cout << *max_element(a, a + ) << endl;
  
       //二分查找(必须从小到大)
       auto it = binary_search(a, a + , );
       if (it)
       {
           cout << "find" << endl;
       }
       else
       {
           cout << "not find" << endl;
       }
       cin.get();
   }

• max min操作

   //取max
   void main4()
   {
       int num1 = max(, );
       int num2 = min(, );
       cout << max((char *)"", (char *)"", [](const char *str1, const char *str2)->bool {return strcmp(str1, str2) < ; });
  
       cin.get();
   }

• 两个容器归并排序

   //用于归并的字符串模板
   //template<class T>
   //bool greater(T t1, T t2)
   //{
   //    return t1 < t2;
   //}
  
   //也可以用仿函数
   template<class T>
   class greater
   {
   public:
       bool operator ()(T t1, T t2)
       {
           return t1 < t2;
       }
   };
   //两个数组归并排序
   void main5()
   {
       int a[] = { ,,,,,,,,, };
       int b[]{ , , , ,  };
       int c[]{  };
       //从大到小排序
       sort(a, a + , [](int a, int b) {return a > b; });
       sort(b, b + , [](int a, int b) {return a > b; });
       //通过lambda
       //merge(a, a + 10, b, b + 5, c, [](int a, int b) {return a > b; });
  
       //通过仿函数
       merge(a, a + , b, b + , c, greater<int>());
       for (auto i : c)
       {
           cout << i << endl;
       }
       cin.get();
   }

• 判断是否有连续相等区间

   //判断是否是包含关系(要在realease下执行) 必须要连续相等
   void main6()
   {
       int a[] = { ,,,,,,,,, };
       int b[] = { ,,,, };
       bool check = includes(a, a + ,  b, b + );
       if (check)
       {
           cout << "包含" << endl;
       }
       else
       {
           cout << "不包含" << endl;
       }
  
       cin.get();
   }

• 求两个容器交并集

   //求并集
   void main7()
   {
       int a[] = { ,,,,,,,,, };
       int b[] = { ,,,, };
       //这种操作重复数据会被省略(第一个不重复的后面会被保留)
       /*set_union(a, a + 10, b, b + 5, ostream_iterator<int>(cout, " "));*/
       //这种操作会都保留
       int c[]{  };
       set_union(a, a + , b, b + , c);
       for (auto i : c)
       {
           cout << i << endl;
       }
       cin.get();
   }

• 把一个数组转化成一个堆

   //把一个数组转成一个堆
   void main8()
   {
       int a[]{ ,,,,,,,,, };
  
       //创建一个堆(创建一个最小堆:顶部值最小)
       make_heap(a, a + , [](int a, int b)->bool {return a > b; });
       for (auto i : a)
       {
           cout << i << endl;
       }
       cout << endl << endl;
  
       //将第一个最大元素移动到最后，同时将剩下的元素重新构造成一个新的heap。
       /*pop_heap(a, a + 10);
       for (auto i : a)
       {
           cout << i << endl;
       }
       cout << endl << endl;*/
  
       //堆排序(最小堆sort_heap是从大到小排序,最大堆sort_heap是从小到大排序)
       sort_heap(a, a + ,[](int a, int b)->bool {return a > b; });
       for (auto i : a)
       {
           cout << i << endl;
       }
       cout << endl << endl;
       cin.get();
   }

• 内部区间归并排序(需要有两个个排序好子列)

   //内部区间归并排序(需要有两个个排序好子列)
   void main9()
   {
       int a[] = { ,,,,,,,,, };
       //inplace_merge(a, a + 5, a + 10);
       int b[] = { ,,,,,,,,, };
       inplace_merge(b, b + , b + , [](int a, int b)->bool {return a > b; });
       for (auto i : b)
       {
           cout << i << endl;
       }
       cin.get();
   }

• 判断容器是否有序

   //判断是否有序
   void main10()
   {
       int a[] = { ,,,,,,,, };
       if (is_sorted(a, a + ))
       {
           cout << "有序" << endl;
       }
       cin.get();
   }

• 取出第n大的数据并排好序

   //取出第n大数据并排好序
   void main11()
   {
       int a[] = { ,,,,,,,, };
       nth_element(a, a + , a + );
       for (auto i : a)
       {
           cout << i << endl;
       }
       cin.get();
   }

• 求出数组中第一个大于(大于等于)某个数的数据

   //求出数组中第一个大于(大于等于)某个数的数据
   void main12()
   {
       //需要有序
       int a[] = { ,,,,,,,,};
       //寻找数组中第一个大于等于的数据
       int *p = lower_bound(a, a + , );
       cout << "last:" << *p << endl;
  
       //寻找第一个大于的数据
       int *p2 = upper_bound(a, a + , );
       cout << "last:" << *p2 << endl;
  
       for (auto i : a)
       {
           cout << i << endl;
       }
       cin.get();
   }

• 处理有序数组中的重复序列,红黑树的每一个结点是一个链表

   //处理有序数组中的重复序列,红黑树的每一个结点是一个链表
   void main13()
   {
       int a[] = { ,,,,,,,,, };
       pair<int *, int *> range = equal_range(a, a + , );
       cout << *range.first << endl;
       cout << *range.second << endl;
       for_each(range.first, range.second, [](int x) {cout << x << endl; });
       cin.get();
   }

• 求两个容器交集差集,以及各自独有的汇总到一起

   //求两个容器交集差集,以及各自独有的汇总到一起
   void main()
   {
       int a[] = { ,,,, };
       int b[] = { ,,,, };
       int c[] = {  };
       //求交集
       set_intersection(a, a + , b, b + , c);
       //求差集(a中有b中没有的数据存到d里面)
       int d[]{  };
       set_difference(a, a + , b, b + , d);
       int e[]{  };
       //将a,b各自独有的汇总到一起
       set_symmetric_difference(a, a + , b, b + , e);
       for (auto i : c)
       {
           cout << i << endl;
       }
       cin.get();
   }