RGB排序，一个字符串，里面只有三种字符R G B，所有的R都在G的前面，所有的G都在B的前面。将给定字符串按照此规律排序。要求不允许用辅助空间，复杂度控制在O(N)。

(1)RGB排序，一个字符串，里面只有三种字符R G B，所有的R都在G的前面，所有的G都在B的前面。将给定字符串按照此规律排序。要求不允许用辅助空间，复杂度控制在O(N)。遍历一遍就排好序。

 

设原来的的字符串为：

RGBBGRRBRGRBBG

 

算法思路如下：

1）题目中要求不能增加辅助空间，所以交换两个字符的时候要做特殊处理哦！不增加任何空间交换2个元素的位置，这样的题目遇到的多了！

比如：char a=R，char b=G；

那么交换a，b的算法如下：

b=a+b；

a=b-a；

b=b-a；不过注意这里如果用字符型运行可能会溢出，转换成int型在运算吧，呵呵！不多讲了，大家都明白！

 

2）时间复杂度为o(n),所以只能遍历一遍就排好序；即不能回朔！

 

解法如下：

1）用两个int i,j分别指向字符串的开始和字符串的末尾

2）然后i往后移动，j往前移动，当i>j时，结束，排序完毕；

3）如果i的位置为R，则i++，如果j的位置为B，则j--；

4）如果i为B或者j为R，则交换i和j对应位置的元素；

5）如果i的位置为G，且j的位置为G，则考虑i+1的位置和j-1的位置；

5.1）如果i+1的位置为R，则交换i和i+1的位置的元素，然后i++；

5.2）如果j-1的位置为B，则交换j和j-1的元素，然后j--；

5.3)如果i+1的位置为B，则交换j和i+1的位置上的元素；然后j--；

5.4）如果j-1的位置的元素为R，则交换j-1和i位置上的元素，然后i++；

5.5）如果i+1和j+1上的元素还是为G，则比较i+2，和j-2；依次类推：

如：

RGBBGRRBRGRBBG

举例如下：

第一次：i指向R，j指向G，因为i的位置上的元素为R，所以i++；j的元素为G，则判断j-1的位置的元素，因为为B，则交换j和j-1，然后j--

第一次交换后的元素如下：

RGBBGRRBRGRBGB

 

其中i=1；j=12

 

然后第2次比较：

i=1的位置和j=12的位置上的元素都为G，那么就按照上面的第5条处理；

比较i+1的元素，i=2的元素为B，那么就交换i+1=2和j上的元素；满足5.3；

交换后的元素排列顺序如下：

RGGBGRRBRGRBBB

 

其中i=1，j=11；

 

第3次比较：

j的位置上的元素为B，则j--；j=10；然后j=10上的位置元素为R，交换i和j上的元素

交换后的元素排列如下：

RRGBGRRBRGGBBB

然后i++

 

此时i=2，j=10；

 

第4次比较：

此时i和j位置上的元素都为G了，又要参考第5条处理；

i+1上的元素为B，则交换i+1和j位置上的元素，然后j--；

 

交换后的排列如下：

RRGGGRRBRGBBBB

 

此时i=2，j=9；

 

第5次交换：i和j的位置的元素都是G，还是按第5条处理；

i+1位置上的元素也是G，那么就看j-1上的位置，此时j-1上的位置为R，那么交换j-1和i的元素，然后i++；

 

交换后的元素如下：

RRRGGRRBGGBBBB

此时i=3；j=9；

 

第6次交换：

此时i和j上的位置都是G，且i+1和j-1上的位置元素也是G，那么我们就要依次类推了，推到i+2

i+2上的元素为R，那么交换i和i+2位置上的元素的值；交换后i++

 

交换后排列如下：

RRRRGGRBGGBBBB

此时：

i=4，j=9；

 

此时i和j位置上的元素还都是G，且i+1和j-1位置上的元素也是G，推到i+2；

i+2上的元素为R，那么交换i和i+2位置上的元素的值；交换后i++

 

交换后：

RRRRRGGBGGBBBB

此时i=5，j=9；

此时i和j的元素都是G，那么且i+1和j-1位置上的元素也是G，推到i+2；

i+2上的元素为B，那么交换i+2和j的值，交换后，j--；

 

交换后的排列如下：

RRRRRGGGGBBBBB

 

此时i=5；j=8；

 

此时i和j上的位置上的元素都为G，依次类推：i+1=6，j-1=7上的位置，都是G，然后在推i+2，和j-2的位置上的元素，还是G，且i+2=7，j-2=6；(i+2)>(j

-2)，排序结束！

 

 

 

下面是我算法的源码，绝对满足要求，如果你还有更好的方法，欢迎和我交流！

#include "stdafx.h"
#include "stdlib.h"
#include <string>

#include <vector>
#include <list>
#include <algorithm>

using namespace std;

//算法中谈到了怎样不增加任何空间，交换两个元素的位置，在前面中介绍的是char型的加减法实现的，在做加减法实现的过程中要防止溢出，所以我这里换了个方法，使用异或实现！
void swap(std::string &StrSrc,int i,int j) 
{ 

 StrSrc[i]=StrSrc[i]^StrSrc[j];
 StrSrc[j]=StrSrc[j]^StrSrc[i];
 StrSrc[i]=StrSrc[i]^StrSrc[j];
 
 return;
} 

 //返回flase表示排序已经完成
bool StringSortGG(std::string &StrSrc,int &i,int &j)
{
 
 int ibegin,iend;

 ibegin=i+1;
 iend=j-1;

 if (ibegin>iend)
 {
  return false;  //
 }

 while (ibegin<=iend)
 {
  //
  if (StrSrc[ibegin]=='R')
  {
   swap(StrSrc,i,ibegin);
   i++;
   break;
  }else if (StrSrc[iend]=='B')
  {
   swap(StrSrc,j,iend);
   j--;
   break;
  }else if (StrSrc[ibegin]=='B')
  {
   swap(StrSrc,ibegin,j);
   j--;
   break;
  }else if (StrSrc[iend]=='R')
  {
   swap(StrSrc,i,iend);
   i++;
  }else{
   ibegin++;
   iend--;
   
   if (ibegin>iend)
   {
    return false;
   }
  }
 }

 return true;
}

bool StringSort(std::string &StrSrc)
{

 // std::string StrSrc="RGBBGRRBRGRBBG";

 if (StrSrc.empty())
 {
  return false;
 }

 int i=0;

 int j=StrSrc.length()-1;

 while (i<j)
 {
  
  if (StrSrc[i]=='R')
  {
   i++;
  }else if (StrSrc[j]=='B')
  {
   j--;
  }else if (StrSrc[i]=='B')
  {
   swap(StrSrc,i,j);
   j--;
  }else if(StrSrc[j]=='R')
  {
   swap(StrSrc,i,j);
   i++;
  }else if ((StrSrc[i]=='G')&&(StrSrc[j]=='G'))
  {
   //
   bool bRet=StringSortGG(StrSrc,i,j);

   if (!bRet)
   {
    return true;
   }
   
  }

 }
 
 return true;

}

int main(void)
{
    std::string StrSrc="RGBBGRRBRGRBBG";
    StringSort(StrSrc);
}

 

算法完毕！