Wie sortiere ich ein Array von Strings, die sowohl negative als auch positive Zahlen in c ++ enthalten?

String str[]={"-123","89","-10","456"};

strist ein Array von Zeichenfolgen, wobei jede Zeichenfolge das Format einer Ganzzahl hat, und Sie müssen dieses Array O(n log n)rechtzeitig sortieren .

Die Zeichenfolgen in strkönnen sowohl positive als auch negative Ganzzahlen darstellen. Die maximale Länge dieser Zeichenfolgen beträgt 1024 Zeichen.

Ich weiß, dass eine Lösung dieses Problems darin besteht, die Zeichenfolgen in Zahlen umzuwandeln und sie dann zu vergleichen. Gibt es eine andere Lösung für dieses Problem?

Eine andere Lösung besteht darin, eine eigene Vergleichsfunktion zu implementieren:

• Überprüfen Sie das erste Zeichen beider Zeichenfolgen. Wenn eine mit einer Ziffer beginnt und die andere mit einer -, ist die Zeichenfolge, die mit beginnt, - die kleinere Zahl.
• Wenn beide Zeichenfolgen mit einer Ziffer beginnen, vergleichen Sie die Länge der Zeichenfolgen. Die kürzere Zeichenfolge ist die kleinere Zahl. Wenn beide Zeichenfolgen dieselbe Länge haben, führen Sie einen Standard-Zeichenfolgenvergleich durch.
• Wenn beide Zeichenfolgen mit beginnen -, vergleichen Sie die Länge der Zeichenfolgen. Die längere Zeichenfolge ist die kleinere Zahl. Wenn beide Zeichenfolgen dieselbe Länge haben, führen Sie einen Standard-Zeichenfolgenvergleich durch, negieren Sie jedoch das Ergebnis.

Hier ist ein minimales und möglicherweise unzureichendes Beispiel (behandelt keine führenden Nullen, Leerzeichen usw.), das das tut, was Sie möchten.

Die Kommentare erklären, was es tut. :) :)

#include <algorithm>
#include <iostream>
#include <string>
#include <vector>

int main() {
  std::vector<std::string> strings = {
      "-1", "-1", "-20", "-4", "3", "0", "-0", "1", "20", "20", "44020",
  };

  // Assumes everything in "strings" has no whitespace in it.
  // Assumes everything in "strings" does not have leading zeroes.
  // Assumes everything in "strings" is an ascii representaion of an integer.
  // Assumes everything in "strings" is nonempty.
  std::sort(strings.begin(), strings.end(),
            [](const std::string &a, const std::string &b) {
              const bool a_is_negative = a[0] == '-';
              const bool b_is_negative = b[0] == '-';
              if (a_is_negative != b_is_negative) {
                // If they have different signs, then whichever is negative is
                // smaller.
                return a_is_negative;
              } else if (a.length() != b.length()) {
                // If they have the same sign, then whichever has more
                // characters is larger in magnitude. When the sign is negative,
                // the longer (more digits) number is "more negative". When
                // positive, the longer (more digits) number is "more positive".
                return (a.length() < b.length()) != a_is_negative;
              } else {
                // Otherwise a lexicographic comparison of "a" and "b" will
                // determine which string is larger in magnitude. Using the same
                // logic above, we account for the "negative vs. positive"
                // comparison.
                return (a < b) != a_is_negative;
              }
            });

  for (const auto &str : strings) {
    std::cout << str << " ";
  }
  std::cout << std::endl;
}