从字符串中提取数字串并排序（C语言实现）

#include "stdio.h" 
#include "stdlib.h"
#include "string.h" 

typedef int BOOL;
#define TRUE  1;
#define FALSE 0;

static void SplitBySeparator( char **arr, char *str, int size, char sep);

void SortNums        ( char*  str,     int size,  int cnt);
int  CompareDigStr   ( char*  digStr1, char* digStr2);

/*
从字符串中提取数字串并排序, 其中:
参数:
   str      字符串
   length   字符串长度, 若 < 0 则为 str 以 ‘\0‘ 结尾
   dest     存放数字串的缓冲区
   size     传入 dest 缓冲区的尺寸, 并返回数字串的长度
返回值:
   -2       提取失败, 存放数字串的缓冲区尺寸太小
   -1       提取失败, 参数不合法
    0       提取失败, 无数字串
   >0       提取成功, 返回数字串的项数
*/
int ExtractNums(const char* str, int length, char* dest, int* size)
{
   int   result    = -1;
   int   sizeDest  = 0;     // 数字串长度
   int   cntDest   = 0;     // 数字串的项数(cntDest+1)
   BOOL  isNeedSep = FALSE; // 是否需要分隔符
   char  ch;

   if (str != NULL && dest != NULL && size != NULL && *size > 0)
   {
      if (length < 0)           // str 以 ‘\0‘ 结尾
      {
         while(*str != ‘\0‘)
         {
            ch = *str;
            if (ch >= ‘0‘ && ch <= ‘9‘)
            {
               // 分隔符
               if (isNeedSep)
               {
                  if (sizeDest >= *size)
                  {
                     result = -2;  // 提取失败, 存放数字串的缓冲区尺寸太小
                     break;
                  }
                  dest[sizeDest++] = ‘ ‘;   // 分隔符
                  cntDest ++;
                  isNeedSep = FALSE;
                  
               }

               // 数字项
               if (sizeDest >= *size)
               {
                  result = -2;   // 提取失败, 存放数字串的缓冲区尺寸太小
                  break;
               }
               dest[sizeDest++] = ch;
            }
            else if (!isNeedSep && sizeDest > 0)
            {       
               isNeedSep = TRUE; // 下一数字项前需要加分隔符
            }
            str ++;
         }
      }
      else
      {
         for (int i=0; i<length; i++)
         {
            ch = str[i];
            if (ch >= ‘0‘ && ch <= ‘9‘)
            {
               // 分隔符
               if (isNeedSep)
               {
                  if (sizeDest >= *size)
                  {
                     result = -2;  // 提取失败, 存放数字串的缓冲区尺寸太小
                     break;
                  }
                  dest[sizeDest++] = ‘ ‘;   // 分隔符
                  cntDest ++;
                  isNeedSep = FALSE;

               }

               // 数字项
               if (sizeDest >= *size)
               {
                  result = -2;   // 提取失败, 存放数字串的缓冲区尺寸太小
                  break;
               }
               dest[sizeDest++] = ch;
            }
            else if (!isNeedSep && sizeDest > 0)
            {       
               isNeedSep = TRUE; // 下一数字项前需要加分隔符
            }
         }
      }


      // 输出缓冲区太小则不进行排序
      if (result != -2)
      {
         *size = sizeDest;       // 数字串的长度

         // 数字项大于1才进行排序
         if (++cntDest > 1)
         {
            SortNums(dest, sizeDest, cntDest);
            result = cntDest;    // 返回数字串的项数
         }
         else if (sizeDest != 0) // 只有一个数字项
         {
            result = cntDest;
         }
         else
            result = 0;          // 无数字串
      }
   }
   return result;
}

/*
数字字符串串排序（从小到大）, 其中:
参数:
   str      数字字符串
   size     数字字符串长度
   cnt      数字串项数
返回值:
   无
*/
void SortNums(char* str, int size, int cnt)
{
   char** arrStr   = NULL;   // 二级指针，用于存放分割提取好的数字项
   char*  strDest  = NULL;   // 待分隔数字串
   char*  arrTmp   = NULL;
   int    nLen     = 0;      // 数字项长度
   BOOL   isSorted = FALSE;


   if (str != NULL && size > 0)
   {
      strDest = (char*)malloc(size+1);
      
      if (strDest != NULL)
      {
         arrStr  = (char**)malloc(cnt*sizeof(char *)); // 申请cnt个指针保存数字项地址
         if (arrStr != NULL)
         {
            memcpy(strDest, str, size);
            *(strDest+size) = ‘\0‘; 

            // 提取数字项
            SplitBySeparator(arrStr, strDest, size, ‘ ‘);

            // 冒泡排序
            for(int i=0; i<cnt-1; i++)
            {
               isSorted = TRUE;
               //每一轮比较前cnt-1-i个，即已排序好的最后i个不用比较
               for(int j=0; j<cnt-1-i; j++)
               {
                  if(CompareDigStr(arrStr[j], arrStr[j+1]) == 1)
                  {
                     isSorted    = FALSE;
                     arrTmp      = arrStr[j];
                     arrStr[j]   = arrStr[j+1];
                     arrStr[j+1] = arrTmp;
                  }
               }
               if(isSorted) break; // 没有发生交换，排序已完成   
            }

            // str返回排序结果
            nLen = strlen(arrStr[0]);
            memcpy(str, arrStr[0], nLen);
            str += nLen;
            for(int i=1; i<cnt; i++)
            {
               *str = ‘ ‘;
               str ++;
               nLen = strlen(arrStr[i]);
               memcpy(str, arrStr[i], nLen);
               str += nLen;
            }
            free(arrStr);
         }
         free(strDest);
      }
   }
}

/*
提取数字项(static静态函数), 其中:
参数:
   arr      返回提取好的数字项
   str      数字串
   size     数字串长度
   sep      分隔符
返回值:
   无
*/
void SplitBySeparator( char **arr, char *str, int size, char sep)
{
   char* pEnd = str + size;
   for (*arr = str; str < pEnd; str++)
      if (*str == sep)
      {
         *str = ‘\0‘;
         *(++arr) = str + 1;
      }
}

/*
比较数字串大小, 其中:
参数:
   digStr1  数字串1
   digStr2  数字串2
返回值:
    <0      digStr1小于digStr2
    0       digStr1等于digStr2
    >0      digStr1大于digStr2
*/
int CompareDigStr(char* digStr1, char* digStr2)
{
   int result  = -1;
   int dig1Len = 0;
   int dig2Len = 0;
   
   if (digStr1 != NULL && digStr2 != NULL)
   {
      // 除数字串头‘0’
      while(*digStr1 == ‘0‘)
      {
         digStr1 ++;
      }

      while(*digStr2 == ‘0‘)
      {
         digStr2 ++;
      }

      dig1Len = strlen(digStr1);
      dig2Len = strlen(digStr2);

      if (dig1Len > dig2Len)
      {
         result = 1;
      }
      else if (dig1Len == dig2Len)
      {
         result = strncmp(digStr1, digStr2, dig1Len);
      }
   }
   return result;
}