对版本号数组进行排序

给定一个字符串数组arr [] ，该数组由N个字符串组成，每个字符串代表以软件版本形式的点分隔数字。

Input: arr[] = {“1.1.2”, “0.9.1”, “1.1.0”}
Output: “0.9.1” “1.1.0” “1.1.2”

Input: arr[] = {“1.2”, “0.8.1”, “1.0”}
Output: “0.8.1” “1.0” “1.2”

方法：请按照以下步骤解决问题：

• 创建一个比较两个字符串的函数。
• 将字符串存储到向量中。
• 为了比较两个点分隔的字符串S1和S2 ，迭代直到长度min(S1，S2)+1，然后比较字符串的每个数字部分并进行相应排序。
• 对每对字符串重复上述步骤，并对数组进行相应排序。

  下面是上述想法的实现：

  C++

  // C++ Program to implement
  // the above approach
  #include 
  using namespace std;
    
  // Compares two strings
  int check(const string& a, const string& b)
  {
    
      int al = a.length();
      int bl = b.length();
    
      int i = 0, j = 0;
      while (i < al && j < bl) {
          if (a[i] == b[j]) {
              ++i;
              ++j;
          }
          else if (a[i] > b[j]) {
              return 1;
          }
          else
              return -1;
      }
    
      if (i == al && j == bl)
          return 0;
      if (i == al)
          return -1;
      return 1;
  }
    
  // Function to split strings based on dots
  vector getTokens(const string& a)
  {
      vector v;
      string s;
    
      // Stringstream is used here for
      // tokenising the string based
      // on "." delimiter which might
      // contain unequal number of "."[dots]
      stringstream ss(a);
      while (getline(ss, s, '.')) {
          v.push_back(s);
      }
      return v;
  }
    
  // Comparator to sort the array of strings
  bool comp(const string& a, const string& b)
  {
    
      // Stores the numerical substrings
      vector va, vb;
      va = getTokens(a);
      vb = getTokens(b);
    
      // Iterate up to length of minimum
      // of the two strings
      for (int i = 0; i < min(va.size(), vb.size());
           i++) {
    
          // Compare each numerical substring
          // of the two strings
          int countCheck = check(va[i], vb[i]);
    
          if (countCheck == -1)
              return true;
    
          else if (countCheck == 1)
              return false;
      }
    
      if (va.size() < vb.size())
          return true;
    
      return false;
  }
    
  // Driver Code
  int main()
  {
    
      vector s;
      s.push_back("1.1.0");
      s.push_back("1.2.1");
      s.push_back("0.9.1");
      s.push_back("1.3.4");
      s.push_back("1.1.2");
      s.push_back("1.1.2.2.3");
      s.push_back("9.3");
    
      // Sort the strings using comparator
      sort(s.begin(), s.end(), comp);
    
      // Display the sorted order
      for (int i = 0; i < s.size(); i++) {
          cout << s[i] << endl;
      }
      cout << endl;
      return 0;
  }

  输出：

  0.9.1
  1.1.0
  1.1.2
  1.1.2.2.3
  1.2.1
  1.3.4
  9.3
  

  时间复杂度： O(N * L * logN)，其中N是版本字符串的总数，L是这些字符串的最大长度。
  辅助空间： O(N * L)