Сортировка std :: vector точек vec2 (x, y) [dубликат]

Следующий метод, на этот раз на стороне SQL, должен использовать метод convert в вашем запросе sql:

CONVERT(VARCHAR(11),$user_date,111) //e.g. SELECT CONVERT(VARCHAR(11),DATEFIELD,111) AS DATE //or SET DATEFIELD = CONVERT(VARCHAR(11),'".$user_date."',111)

См.: http://www.w3schools.com/sql/func_convert. asp - число в конце изменяет тип формата даты, с возвратом 111: 2006/12/30.

195
задан Ankur 4 September 2009 в 18:05
поделиться

12 ответов

Простой пример с использованием std :: sort

  struct MyStruct {int key;  std :: string stringValue;  MyStruct (int k, const std :: string & amp; s): key (k), stringValue (s) {}};  struct less_than_key {inline bool operator () (const MyStruct & amp; struct1, const MyStruct & amp; struct2) {return (struct1.key & lt; struct2.key);  }};  std :: vector & lt;  MyStruct & gt;  VEC;  vec.push_back (MyStruct (4, "test"));  vec.push_back (MyStruct (3, "a"));  vec.push_back (MyStruct (2, "is"));  vec.push_back (MyStruct (1, «this»));  std :: sort (vec.begin (), vec.end (), less_than_key ());   

Редактировать: Как указал Кирилл В. Лядвинский, вместо предоставления предиката сортировки вы можете реализовать оператор & lt; для MyStruct [ ! d3]:

  struct MyStruct {int key;  std :: string stringValue;  MyStruct (int k, const std :: string & amp; s): key (k), stringValue (s) {} Оператор bool & lt;  (const MyStruct & amp; str) const {return (key & lt; str.key);  }};   

Используя этот метод, вы можете просто отсортировать вектор следующим образом:

  std :: sort (vec.begin (), vec.end ()  );   

Edit2: Как говорит Каппа, вы также можете отсортировать вектор в порядке убывания, перегрузив оператор & gt; и немного изменив вызов сортировки:

  struct MyStruct {int key;  std :: string stringValue;  MyStruct (int k, const std :: string & amp; s): key (k), stringValue (s) {} bool operator & gt;  (const MyStruct & amp; str) const {return (key & gt; str.key);  }};   

И вы должны вызвать сортировку как:

  std :: sort (vec.begin (), vec.end (), больше & lt; MyStruct & gt; (  ));   
299
ответ дан Ron 15 August 2018 в 20:27
поделиться
  • 1
    Не могли бы вы объяснить, почему вы сделали функцию сравнения в строке struct less_than_key (в первом) примере? – kluka 15 May 2013 в 19:10
  • 2
    и другой вопрос / примечание: если вы хотите иметь несколько методов сортировки (для разных атрибутов) в классе, способ перегрузки & lt; оператор, вероятно, не вариант, не так ли? – kluka 15 May 2013 в 19:28
  • 3
    Самое интересное - предоставить оператора & gt; метод. Это позволит нам сортировать в обратном порядке, например: std :: sort (vec.begin (), vec.end (), больше & lt; MyStruct & gt; ()) , который является чистым и элегантным. – kappa 31 May 2014 в 00:21
  • 4
    @Bovaz Вам нужно #include & lt; functional & gt; использовать «std :: больше». – Nick Hartung 31 August 2015 в 15:21
  • 5
    @kappa: где вы могли бы просто иметь operator & lt; и использовать либо std :: sort (vec.begin (), vec.end ()); или std :: sort (vec.rbegin (), vec.rend ()); в зависимости от того, хотите ли вы иметь восходящий или нисходящий порядок. – Pixelchemist 19 May 2016 в 22:24
  // пример алгоритма сортировки #include & lt; iostream & gt;  // std :: cout #include & lt; algorithm & gt;  // std :: sort #include & lt; vector & gt;  // std :: vector с использованием пространства имен std;  int main () {char myints [] = {'F', 'C', 'E', 'G', 'A', 'H', 'B', 'D'};  вектор & л; символ & GT;  myvector (myints, myints + 8);  // 32 71 12 45 26 80 53 33 // используя сравнение по умолчанию (operator & lt;): sort (myvector.begin (), myvector.end ());  // (12 32 45 71) 26 80 53 33 // распечатать содержимое: cout & lt;  «myvector содержит:»;  для (int i = 0; i! = 8; i ++) cout & lt;  '' & lt; & lt; myvector [i];  cout & lt;  '\n';  Система ( "Пауза");  return 0;  }  
1
ответ дан Amin Alomaisi 15 August 2018 в 20:27
поделиться
  typedef struct Freqamp {double freq;  двойной усилитель;  } FREQAMP;  bool struct_cmp_by_freq (FREQAMP a, FREQAMP b) {return a.freq & lt;  b.freq;  } main () {vector & lt; FREQAMP & gt;  темп;  FREQAMP freqAMP;  freqAMP.freq = 330;  freqAMP.amp = 117,56;  temp.push_back (freqAMP);  freqAMP.freq = 450;  freqAMP.amp = 99,56;  temp.push_back (freqAMP);  freqAMP.freq = 110;  freqAMP.amp = 106,56;  temp.push_back (freqAMP);  sort (temp.begin (), temp.end (), struct_cmp_by_freq);  }  

, если сравнение ложно, оно будет «обмениваться».

0
ответ дан bruce 15 August 2018 в 20:27
поделиться

Мне было любопытно, есть ли какое-либо измеримое влияние на производительность между различными способами вызова std :: sort, поэтому я создал этот простой тест:

  $ cat sort.cpp  # включают & л; алгоритм & GT;  # Включают & л; iostream & GT;  # Включают & Lt; & вектор GT;  # Включают & л; хроно & GT;  #define COMPILER_BARRIER () asm volatile ("" ::: "memory");  typedef unsigned long int ulint;  использование пространства имен std;  struct S {int x;  int y;  };  #define BODY {return s1.x * s2.y & lt;  s2.x * s1.y;  } bool operator & lt; (const S & amp; s1, const S & amp; s2) BODY bool Sgreater_func (const S & amp; s1, const S & amp; s2) BODY struct Sgreater {bool operator () (const S & amp; s1, const S & amp; s2) const BODY  };  void sort_by_operator (vector & lt; s & amp; v) {sort (v.begin (), v.end ());  } void sort_by_lambda (vector & lt; s & amp; v) {sort (v.begin (), v.end (), [] (const S & amp; s1, const S & amp; s2) BODY);  } void sort_by_functor (vector & lt; s & amp; v) {sort (v.begin (), v.end (), Sgreater ());  } void sort_by_function (vector & lt; s & amp; v) {sort (v.begin (), v.end (), & amp; Sgreater_func);  } const int N = 10000000;  вектор & л, S & GT;  random_vector;  ulint run (void foo (вектор & lt; S & gt; v)) {вектор & lt; S & gt;  TMP (random_vector);  Foo (TMP);  ulint checksum = 0;  for (int i = 0; i & lt; tmp.size (); ++ i) {checksum + = i * tmp [i] .x ^ tmp [i] .y;  } контрольная сумма возврата;  } void measure (void foo (vector & lt; S & gt; & amp; v)) {ulint check_sum = 0;  // разминка const int WARMUP_ROUNDS = 3;  const int TEST_ROUNDS = 10;  for (int t = WARMUP_ROUNDS; t -;) {COMPILER_BARRIER ();  check_sum + = run (foo);  COMPILER_BARRIER ();  } for (int t = TEST_ROUNDS; t -;) {COMPILER_BARRIER ();  auto start = std :: chrono :: high_resolution_clock :: now ();  COMPILER_BARRIER ();  check_sum + = run (foo);  COMPILER_BARRIER ();  auto end = std :: chrono :: high_resolution_clock :: now ();  COMPILER_BARRIER ();  auto duration_ns = std :: chrono :: duration_cast & lt; std :: chrono :: duration & lt; double & gt; gt; (end-start) .count ();  cout & lt;  «Взял» & lt;  duration_ns & lt;  's, чтобы закончить круглый & lt; & lt;  епсИ;  } cout & lt;  "Контрольная сумма:" & lt;  check_sum & lt;  епсИ;  } #define M (x) \ cout & lt;  «Измерение» #x «on» & lt;  N & lt;  "items:" & lt;  endl; \ measure (x);  int main () {random_vector.reserve (N);  for (int i = 0; i & lt; N; ++ i) {random_vector.push_back (S {rand (), rand ()});  } M (sort_by_operator);  М (sort_by_lambda);  М (sort_by_functor);  М (sort_by_function);  return 0;  }  

Что он делает, так это создает случайный вектор, а затем измеряет, сколько времени требуется для его копирования и сортировки его копии (и вычислить некоторую контрольную сумму, чтобы избежать слишком сильного мертвого кода исключение).

Я компилировал с g ++ (GCC) 7.2.1 20170829 (Red Hat 7.2.1-1)

  $ g ++ -O2 -o сортировка сортировки.  cpp & amp; & amp;  ./sort  

Вот результаты:

  Измерение sort_by_operator на 10000000 элементах: Взял 0.994285s, чтобы завершить раунд. Взял 0.990162s, чтобы завершить раунд. Принимал 0.992103s до  полный раунд Взял 0.989638s, чтобы завершить раунд Взял 0.98105s, чтобы завершить раунд Взял 0.991913s, чтобы завершить раунд Взял 0.992176s, чтобы завершить раунд Взял 0.981706s, чтобы завершить раунд Взял 0.99021s, чтобы завершить раунд Взял 0.988841s для завершения раунда Контрольная сумма: 18446656212269526361 Мера sort_by_lambda on  10000000 предметов: Взял 0.974274s, чтобы завершить раунд Взял 0.97298s, чтобы завершить раунд Взял 0.964506s, чтобы завершить раунд Взял 0.96899s, чтобы завершить раунд Взял 0.965773s, чтобы завершить раунд Взял 0.96457s, чтобы завершить раунд Взял 0.974286s, чтобы завершить раунд Взял 0.975524s, чтобы закончить раунд  раунд Взял 0,966238s для завершения раунда Взял 0,964676s для завершения раунда Контрольная сумма: 18446656212269526361 Мера sort_by_functor на 10000000 предметов: Взял 0.964359s, чтобы завершить раунд Взял 0.979619s, чтобы завершить раунд Взял 0.974027s для завершения раунда  Взял 0,964671s, чтобы завершить раунд Взял 0,964764s, чтобы завершить раунд Взял 0,966491s, чтобы завершить раунд Взял 0,964706s, чтобы завершить раунд Взял 0,965115s, чтобы завершить раунд Взял 0,964352s, чтобы завершить раунд Взял 0,968954s для завершения раунда Контрольная сумма: 18446656212269526361 Мера sort_by_function на 10000000 статьях  : Взял 1.29942s, чтобы завершить раунд Взял 1.3029s, чтобы закончить раунд Взял 1.29931s, чтобы закончить раунд Взял 1.29946s, чтобы закончить раунд Взял 1.29837s, чтобы закончить раунд Took 1.30132s, чтобы закончить раунд Взял 1.3023s, чтобы закончить раунд Взял 1.30997s, чтобы закончить раунд Took  1.30819s для завершения раунда Took 1.3003s для завершения раунда Контрольная сумма: 18446656212269526361  

Похоже, что все параметры, кроме указателя функции, очень похожи, а передача указателя функции вызывает + 30% -ный штраф.

Он также выглядит как оператор & lt; версия на ~ 1% медленнее (я повторил тест несколько раз, и эффект сохраняется), что немного странно, поскольку предполагает, что сгенерированный код отличается (мне не хватает навыков для анализа --save-temps output).

0
ответ дан Chris Reid 15 August 2018 в 20:27
поделиться

В вашем классе вы можете перегрузить символ "& lt;" оператор

  класс MyClass {bool operator & lt; (const MyClass & amp; rhs) {return this- & gt; key & lt;  rhs.key;  }}  
120
ответ дан Corvusoft 15 August 2018 в 20:27
поделиться
  • 1
    дополнительный +1 для включения #includes – Anne 3 May 2016 в 17:35
  • 2
    Чтобы быть ясным, это приводит к возрастанию; используйте & gt; вместо & lt; , чтобы получить убывающий порядок. – bhaller 27 April 2017 в 04:53

Вы можете использовать функтор в качестве третьего аргумента в std :: sort , или вы можете определить оператор & lt; в вашем классе.

   struct X {int x;  bool operator & lt; (const X & amp; val) const {return x & lt;  val.x;  }};  struct Xgreater {bool operator () (const X & amp; lx, const X & amp; rx) const {return lx.x & lt;  rx.x;  }};  int main () {std :: vector & lt; X & gt;  my_vec;  // используем X :: operator & lt;  по умолчанию std :: sort (my_vec.begin (), my_vec.end ());  // используем functor std :: sort (my_vec.begin (), my_vec.end (), Xgreater ());  }  
52
ответ дан Kirill V. Lyadvinsky 15 August 2018 в 20:27
поделиться
  • 1
    почему мы должны добавить const в конце сигнатуры функции? – prongs 14 June 2013 в 12:40
  • 2
    Функция не изменяет объект, поэтому он const . – Kirill V. Lyadvinsky 2 July 2013 в 09:35
  • 3
    Если это так, то почему мы передаем «const X & amp; val ", я предполагаю, что передача значения as const в функцию заставляет функцию думать, что ее значение не будет изменено. – Prashant Bhanarkar 22 August 2016 в 06:47
  • 4
    @PrashantBhanarkar Ключевое слово const в конце подписи указывает, что функция operator () не изменяет экземпляр структуры Xgreater (которая в общем случае могут иметь переменные-члены), тогда как указание const для входных значений указывает только на то, что эти входные значения неизменяемы. – schester 28 December 2017 в 20:35

Да, std :: sort () с третьим параметром (функцией или объектом) будет проще. Пример: http://www.cplusplus.com/reference/algorithm/sort/

4
ответ дан Manos Nikolaidis 15 August 2018 в 20:27
поделиться
  • 1
    Не совсем ссылка только ответ, но, по крайней мере, один пример строки был бы полезен. – Manos Nikolaidis 31 December 2015 в 12:20
10
ответ дан Pixelchemist 15 August 2018 в 20:27
поделиться

Вы на правильном пути. std :: sort будет использовать operator & lt; в качестве функции сравнения по умолчанию. Поэтому для сортировки ваших объектов вам придется либо перегрузить bool operator & lt; (const T & amp ;, const T & amp;) , либо предоставить функтор, который выполняет сравнение, например:

  struct C {int i;  static bool before (const C & amp; c1, const C & amp; c2) {return c1.i & lt;  c2.i;  }};  bool operator & lt; (const C & amp; c1, const C & amp; c2) {return c1.i & gt;  c2.i;  } std :: vector & lt; C & gt;  значения;  std :: sort (values.begin (), values.end ());  // использует оператор & lt;  std :: sort (values.begin (), values.end (), C :: before);   

Преимущество использования функтора заключается в том, что вы можете использовать функцию с доступом к закрытым членам класса.

12
ответ дан pjvandehaar 15 August 2018 в 20:27
поделиться
  • 1
    Пропущено это: предоставить оператор-член-член & lt ;. – xtofl 4 September 2009 в 18:13
  • 2
    Лучше сделать operator & lt; членом класса (или структуры), поскольку глобальный может использовать защищенные или частные члены. Или вы должны сделать его другом структуры C. – Kirill V. Lyadvinsky 4 September 2009 в 18:25

Чтобы отсортировать вектор, вы можете использовать алгоритм sort () в.

  sort (vec.begin (), vec.end (), less & lt; int & gt; ());   

Третий используемый параметр может быть больше или меньше, а также использовать любую функцию или объект. Однако оператор по умолчанию равен & lt; если вы оставите третий параметр пустым.

  // используя функцию as comp std :: sort (myvector.begin () + 4, myvector.end (), myfunction);  bool myfunction (int i, int j) {return (i & lt; j);  } // использование объекта as comp std :: sort (myvector.begin (), myvector.end (), myobject);   
0
ответ дан Prashant Shubham 15 August 2018 в 20:27
поделиться

Ниже приведен код с использованием lambdas

  #include "stdafx.h" #include & lt; vector & gt;  #include & lt; algorithm & gt;  использование пространства имен std;  struct MyStruct {int key;  std :: string stringValue;  MyStruct (int k, const std :: string & amp; s): key (k), stringValue (s) {}};  int main () {std :: vector & lt;  MyStruct & gt;  VEC;  vec.push_back (MyStruct (4, "test"));  vec.push_back (MyStruct (3, "a"));  vec.push_back (MyStruct (2, "is"));  vec.push_back (MyStruct (1, «this»));  std :: sort (vec.begin (), vec.end (), [] (const MyStruct & amp; struct1, const MyStruct & amp; struct2) {return (struct1.key & lt; struct2.key);});  return 0;  }  
2
ответ дан Sathwick 15 August 2018 в 20:27
поделиться
1
ответ дан user 15 August 2018 в 20:27
поделиться
Другие вопросы по тегам:

Похожие вопросы: