Como classificar matriz de seqüências de caracteres que contém números positivos e negativos em c ++.?

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

stré uma matriz de cadeias, com cada cadeia no formato de um número inteiro, e você deve executar a classificação nessa matriz no O(n log n)tempo.

As cadeias em strpodem representar números inteiros positivos e negativos. O comprimento máximo dessas seqüências é 1024 caracteres.

Eu sei que uma solução desse problema é converter as seqüências de caracteres em números e compará-las além disso; existe alguma outra solução para esse problema?

Outra solução é implementar sua própria função de comparação:

• Verifique o primeiro caractere das duas strings. Se um começa com um dígito e o outro começa com a -, a sequência que começa com - é o número menor.
• Se ambas as cadeias começarem com um dígito, compare o comprimento das cadeias. A cadeia mais curta é o número menor. Se as duas seqüências tiverem o mesmo comprimento, faça uma comparação padrão.
• Se ambas as strings começarem -, compare o comprimento das strings. A cadeia mais longa é o número menor. Se as duas seqüências tiverem o mesmo comprimento, faça uma comparação padrão, mas negue o resultado.

Aqui está um exemplo mínimo e potencialmente insuficiente (não lida com zeros à esquerda, espaços em branco etc.) que faz o que você deseja.

Os comentários explicam o que estão fazendo. :)

#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;
}