字符串算法

字符串算法

  1. 字符串字符判重算法
  2. 字符串反转算法
  3. 字符串左旋算法
  4. 字符串右旋算法
  5. 字符串旋转匹配算法
  6. 字符串包含算法
  7. 字符串删除算法
  8. 字符串原地替换算法
  9. 字符串压缩算法
  10. 字符串变位词检测算法
  11. 字符串转整数算法
  12. 字符串全排列算法
  13. 字符串字典序组合算法
  14. 字符串的(括号)生成算法

字符串字符判重算法

给定字符串,确定是否字符串中的所有字符全都是不同的。假设字符集是 ASCII。

 1 using System;
 2 using System.Collections.Generic;
 3 
 4 namespace AlgorithmTesting
 5 {
 6   class Program
 7   {
 8     static void Main(string[] args)
 9     {
10       Console.WriteLine(IsUniqueChars("asdf5678888888".ToCharArray()));
11       Console.WriteLine(IsUniqueChars("asdf5678!@#$%^&".ToCharArray()));
12       Console.WriteLine(IsUniqueSmallAlphabetChars("asdf5678!@#$%^&".ToCharArray()));
13       Console.WriteLine(IsUniqueSmallAlphabetChars("asdf5678".ToCharArray()));
14       Console.WriteLine(IsUniqueSmallAlphabetChars("asdf{}".ToCharArray()));
15       Console.WriteLine(IsUniqueSmallAlphabetChars("asdf".ToCharArray()));
16       Console.ReadKey();
17     }
18 
19     static bool IsUniqueChars(char[] str)
20     {
21       if (str.Length > 256)
22         return false;
23 
24       // 为每个字符保存一个是否存在标记
25       bool[] charSet = new bool[256];
26       for (int i = 0; i < str.Length; i++)
27       {
28         var index = (byte)str[i];
29         if (charSet[index])
30         {
31           return false;
32         }
33         charSet[index] = true;
34       }
35 
36       return true;
37     }
38 
39     static bool IsUniqueSmallAlphabetChars(char[] str)
40     {
41       if (str.Length > 26)
42         return false;
43 
44       // 使用位操作以改进空间占用
45       int checker = 0;
46       for (int i = 0; i < str.Length; i++)
47       {
48         int index = str[i] - 'a';
49         if (index < 0
50           || index > 26
51           || (checker & (1 << index)) > 0)
52         {
53           return false;
54         }
55         checker |= (1 << index);
56       }
57 
58       return true;
59     }
60   }
61 }

字符串反转算法

有字符串 s1 = “ABC1DEF”,要求将其反转成 “FED1CBA”。

 1 using System;
 2  
 3 namespace ConsoleApplication1
 4 {
 5   class Program
 6   {
 7     static void Main(string[] args)
 8     {
 9       string text1 = "ABC1DEF";
10       string text2 = "ABC1DEFG";
11       char[] t1 = text1.ToCharArray();
12       char[] t2 = text2.ToCharArray();
13  
14       ReversePartOfString(t1, 1, t1.Length - 2);
15       ReversePartOfString(t2, 1, t2.Length - 2);
16  
17       string s1 = new string(t1);
18       string s2 = new string(t2);
19       Console.WriteLine(s1);
20       Console.WriteLine(s2);
21  
22       string text3 = "ABC1DEF";
23       string text4 = "ABC1DEFG";
24       char[] t3 = text3.ToCharArray();
25       char[] t4 = text4.ToCharArray();
26  
27       ReverseArrayByXor(t3);
28       ReverseArrayByXor(t4);
29  
30       string s3 = new string(t3);
31       string s4 = new string(t4);
32       Console.WriteLine(s3);
33       Console.WriteLine(s4);
34  
35       Console.ReadKey();
36     }
37  
38     static void ReversePartOfString(char[] s, int begin, int length)
39     {
40       char temp;
41       for (int i = begin, j = begin + length - 1; i < j; i++, j--)
42       {
43         temp = s[i];
44         s[i] = s[j];
45         s[j] = temp;
46       }
47     }
48  
49     static void ReversePartOfStringWithWhile(char[] s, int begin, int length)
50     {
51       // actually, use while is same with use for loop
52       // which one looks better?
53       char temp;
54       int i = begin;
55       int j = begin + length - 1;
56       while (i < j)
57       {
58         temp = s[i];
59         s[i] = s[j];
60         s[j] = temp;
61         i++;
62         j--;
63       }
64     }
65  
66     static void ReverseArray(char[] s)
67     {
68       char temp;
69       for (int i = 0, j = s.Length - 1; i < j; i++, j--)
70       {
71         temp = s[i];
72         s[i] = s[j];
73         s[j] = temp;
74       }
75     }
76  
77     static void ReverseArrayByXor(char[] s)
78     {
79       for (int i = 0, j = s.Length - 1; i < j; i++, j--)
80       {
81         // XOR 2 values bitwise 3 times and they're switched
82         s[i] ^= s[j];
83         s[j] ^= s[i];
84         s[i] ^= s[j];
85       }
86     }
87   }
88 }

字符串左旋算法

给定一个字符串,要求把字符串前面的若干个字符移动到字符串的尾部,如把字符串 “abcdef” 前面的 2 个字符 ‘a’ 和 ‘b’ 移动到字符串的尾部,使得原字符串变成字符串 “cdefab”。要求对长度为 n 的字符串操作的时间复杂度为 O(n),空间复杂度为 O(1)。

 1 using System;
 2 
 3 namespace ConsoleApplication1
 4 {
 5   class Program
 6   {
 7     static void Main(string[] args)
 8     {
 9       string s1 = "abcdefg";
10       string s2 = "abcdefgh";
11 
12       char[] a1 = s1.ToCharArray();
13       char[] a2 = s2.ToCharArray();
14 
15       LeftRotateStringByGcd(a1, 2);
16       LeftRotateStringByGcd(a2, 2);
17 
18       string str1 = new string(a1);
19       string str2 = new string(a2);
20       Console.WriteLine(str1);
21       Console.WriteLine(str2);
22 
23       Console.ReadKey();
24     }
25 
26     static void LeftRotateString(char[] s, int m)
27     {
28       ReverseString(s, 0, m - 1);
29       ReverseString(s, m, s.Length - 1);
30       ReverseString(s, 0, s.Length - 1);
31     }
32 
33     static void ReverseString(char[] s, int begin, int end)
34     {
35       char temp;
36       int i = begin;
37       int j = end;
38       while (i < j)
39       {
40         temp = s[i];
41         s[i] = s[j];
42         s[j] = temp;
43         i++;
44         j--;
45       }
46     }
47 
48     static int Gcd(int m, int n)
49     {
50       int k = m % n;
51       if (k == 0)
52         return n;
53       else
54         return Gcd(n, k);
55     }
56 
57     static void LeftRotateStringByGcd(char[] s, int m)
58     {
59       int n = s.Length;
60       int g = Gcd(n, m);
61       int e = n / g;
62 
63       char temp;
64       for (int i = 0; i < g; i++)
65       {
66         temp = s[i];
67 
68         int j = 0;
69         for (; j < e - 1; j++)
70         {
71           s[(i + j * m) % n] = s[(i + (j + 1) * m) % n];
72         }
73 
74         s[(i + j * m) % n] = temp;
75       }
76     }
77   }
78 }

字符串右旋算法

给定一个字符串,要求把字符串后面的若干个字符移动到字符串的头部,如把字符串 “abcdef” 后面的 2 个字符 ‘e’ 和 ‘f’ 移动到字符串的头部,使得原字符串变成字符串 “efabcd”。要求对长度为 n 的字符串操作的时间复杂度为 O(n),空间复杂度为 O(1)。

 1 using System;
 2 
 3 namespace ConsoleApplication1
 4 {
 5   class Program
 6   {
 7     static void Main(string[] args)
 8     {
 9       string s3 = "abcdefg";
10       string s4 = "abcdefgh";
11 
12       char[] a3 = s3.ToCharArray();
13       char[] a4 = s4.ToCharArray();
14 
15       RightRotateString(a3, 2);
16       RightRotateString(a4, 2);
17 
18       string str3 = new string(a3);
19       string str4 = new string(a4);
20       Console.WriteLine(str3);
21       Console.WriteLine(str4);
22 
23       Console.ReadKey();
24     }
25 
26     static void RightRotateString(char[] s, int m)
27     {
28       ReverseString(s, 0, s.Length - m - 1);
29       ReverseString(s, s.Length - m, s.Length - 1);
30       ReverseString(s, 0, s.Length - 1);
31     }
32 
33     static void ReverseString(char[] s, int begin, int end)
34     {
35       char temp;
36       int i = begin;
37       int j = end;
38       while (i < j)
39       {
40         temp = s[i];
41         s[i] = s[j];
42         s[j] = temp;
43         i++;
44         j--;
45       }
46     }
47   }
48 }

字符串旋转匹配算法

给定两个字符串 s1 和 s2,如何判断 s1 是 s2 的一个旋转版本?

 1 using System;
 2 
 3 namespace ConsoleApplication1
 4 {
 5   class Program
 6   {
 7     static void Main(string[] args)
 8     {
 9       // Given two string s1 and s2 
10       // how will you check if s1 is a rotated version of s2 ?
11 
12       string s1 = "tackoverflows";
13       string s2 = "ackoverflowst";
14       string s3 = "overflowstack";
15       string s4 = "stackoverflwo";
16 
17       string pattern = "stackoverflow";
18 
19       Console.WriteLine(string.Format("{0}, {1}, {2}", s1, pattern, CheckRotation(s1, pattern)));
20       Console.WriteLine(string.Format("{0}, {1}, {2}", s2, pattern, CheckRotation(s2, pattern)));
21       Console.WriteLine(string.Format("{0}, {1}, {2}", s3, pattern, CheckRotation(s3, pattern)));
22       Console.WriteLine(string.Format("{0}, {1}, {2}", s4, pattern, CheckRotation(s4, pattern)));
23 
24       Console.ReadKey();
25     }
26 
27     static bool CheckRotation(string s1, string s2)
28     {
29       return s1.Length == s2.Length
30         && (s1 + s1).IndexOf(s2) != -1;
31     }
32   }
33 }

字符串包含算法

给定两个分别由字母组成的字符串 s1 和字符串 s2,如何最快地判断字符串 s2 中所有字母是否都在字符串 s1 里?

 1 using System;
 2 
 3 namespace ConsoleApplication1
 4 {
 5   class Program
 6   {
 7     static void Main(string[] args)
 8     {
 9       string s1 = "abcdefg";
10       string s2 = "cfx";
11 
12       char[] a1 = s1.ToCharArray();
13       char[] a2 = s2.ToCharArray();
14 
15       Console.WriteLine(
16         string.Format("{0}, {1}, {2}", s1, s2, IsContainAllChars(a1, a2)));
17 
18       Console.ReadKey();
19     }
20 
21     // 给定两个分别由字母组成的字符串a和字符串b
22     // 判断字符串b中所有字母是否都在字符串a里?
23     // 时间复杂度O(n + m),空间复杂度O(1)
24     static bool IsContainAllChars(char[] a, char[] b)
25     {
26       int hash = 0;
27       for (int i = 0; i < a.Length; ++i)
28       {
29         hash |= (1 << (a[i] - 'A'));
30       }
31 
32       for (int i = 0; i < b.Length; ++i)
33       {
34         if ((hash & (1 << (b[i] - 'A'))) == 0)
35         {
36           return false;
37         }
38       }
39 
40       return true;
41     }
42   }
43 }

字符串原地替换算法

将字符串 s1 中的某字符 p 全部替换成字符串 s2。假设 s1 字符数组尾部有足够的空间存放新增字符。

 1 using System;
 2 using System.Collections.Generic;
 3 
 4 namespace AlgorithmTesting
 5 {
 6   class Program
 7   {
 8     static void Main(string[] args)
 9     {
10       // 假设 s1 有足够的冗余空间
11       char[] s1 = new char[100];
12       for (int i = 0; i < 9; i = i + 3)
13       {
14         s1[i] = 'a';
15         s1[i + 1] = 'b';
16         s1[i + 2] = 'c';
17       }
18 
19       Console.WriteLine(new string(s1));
20       ReplaceChars(s1, 9, 'b', "%&$".ToCharArray());
21       Console.WriteLine(new string(s1));
22       Console.ReadKey();
23     }
24 
25     // 将字符串 s1 中的某字符 p 替换成字符串 s2
26     static void ReplaceChars(char[] s1, int s1Length, char p, char[] s2)
27     {
28       int count = 0;
29       for (int i = 0; i < s1.Length; i++)
30       {
31         if (s1[i] == p)
32           count++;
33       }
34 
35       int newLength = s1Length + count * (s2.Length - 1);
36 
37       // 从尾部开始编辑,从后向前操作,无须担心覆写原数据
38       for (int i = s1Length - 1; i >= 0; i--)
39       {
40         if (s1[i] == p)
41         {
42           for (int j = 0; j < s2.Length; j++)
43           {
44             s1[newLength - s2.Length + j] = s2[j];
45           }
46           newLength = newLength - s2.Length;
47         }
48         else
49         {
50           s1[newLength - 1] = s1[i];
51           newLength = newLength - 1;
52         }
53       }
54     }
55   }
56 }

字符串压缩算法

给定字符串 s,要求将连续出现的字符压缩至字符和数量,并返回新的字符串。

比如:s = “aabccccaaa”,则压缩后的字符串为 s2 = “a2b1c4a3″。

  1 using System;
  2 using System.Collections.Generic;
  3 
  4 namespace AlgorithmTesting
  5 {
  6   class Program
  7   {
  8     static void Main(string[] args)
  9     {
 10       string s1 = "aabccccaaa";
 11       Console.WriteLine(s1);
 12       char[] s2 = Compress(s1.ToCharArray());
 13       Console.WriteLine(new string(s2));
 14 
 15       string s3 = "aabccdeeaa";
 16       Console.WriteLine(s3);
 17       char[] s4 = Compress(s3.ToCharArray());
 18       Console.WriteLine(new string(s4));
 19 
 20       Console.ReadKey();
 21     }
 22 
 23     static char[] Compress(char[] s)
 24     {
 25       // 如果压缩后比原来还长,则不必压缩
 26       int size = CountCompression(s);
 27       if (size >= s.Length)
 28         return s;
 29 
 30       // 根据计算的压缩后长度生成数组
 31       char[] compressed = new char[size];
 32 
 33       int index = 0;
 34       char last = s[0];
 35       int count = 1;
 36       for (int i = 1; i < s.Length; i++)
 37       {
 38         if (s[i] == last) // 找到重复字符
 39         {
 40           count++;
 41         }
 42         else
 43         {
 44           // 当前字符处理完毕
 45           index = AppendChar(compressed, last, index, count);
 46 
 47           // 处理下一个字符
 48           last = s[i];
 49           count = 1;
 50         }
 51       }
 52 
 53       // 添加最后一个字符
 54       index = AppendChar(compressed, last, index, count);
 55 
 56       return compressed;
 57     }
 58 
 59     static int AppendChar(char[] array, char c, int index, int count)
 60     {
 61       array[index] = c;
 62       index++;
 63 
 64       char[] countString = count.ToString().ToCharArray();
 65 
 66       for (int i = 0; i < countString.Length; i++)
 67       {
 68         array[index] = countString[i];
 69         index++;
 70       }
 71 
 72       return index;
 73     }
 74 
 75     static int CountCompression(char[] s)
 76     {
 77       if (s == null || s.Length == 0)
 78         return 0;
 79 
 80       // 计算压缩后的长度
 81       int size = 0;
 82 
 83       char last = s[0];
 84       int count = 1;
 85       for (int i = 0; i < s.Length; i++)
 86       {
 87         if (s[i] == last) // 找到重复字符
 88         {
 89           count++;
 90         }
 91         else
 92         {
 93           // 当前字符处理完毕
 94           size += 1 + count.ToString().ToCharArray().Length;
 95 
 96           // 处理下一个字符
 97           last = s[i];
 98           count = 1;
 99         }
100       }
101 
102       size += 1 + count.ToString().ToCharArray().Length;
103 
104       return size;
105     }
106   }
107 }

字符串变位词检测算法

给定字符串 s1 和 s2,判断是否能够将 s1 中的字符重新排列后变成 s2。假设字符全部为小写 a-z 字符,字符串中没有空格。

变位词(anagram):是由变换某个词或短语的字母顺序而构成的新的词或短语。

 1 using System;
 2 using System.Collections.Generic;
 3 
 4 namespace AlgorithmTesting
 5 {
 6   class Program
 7   {
 8     static void Main(string[] args)
 9     {
10       Console.WriteLine(IsPermutation(
11         "hello".ToCharArray(), "ehollu".ToCharArray()));
12       Console.WriteLine(IsPermutation(
13         "hello".ToCharArray(), "eholu".ToCharArray()));
14       Console.WriteLine(IsPermutation(
15         "hello".ToCharArray(), "eholl".ToCharArray()));
16       Console.ReadKey();
17     }
18 
19     static bool IsPermutation(char[] s1, char[] s2)
20     {
21       if (s1.Length != s2.Length)
22         return false;
23 
24       int[] letters = new int[256];
25       for (int i = 0; i < s1.Length; i++)
26       {
27         letters[s1[i]]++;
28       }
29 
30       for (int i = 0; i < s2.Length; i++)
31       {
32         letters[s2[i]]--;
33         if (letters[s2[i]] < 0)
34           return false;
35       }
36 
37       return true;
38     }
39   }
40 }

字符串删除算法

给定两个分别由字母组成的字符串 s1 和字符串 s2,将字符串 s2 中所有字符都在字符串 s1 中删除?

 1 using System;
 2 
 3 namespace ConsoleApplication1
 4 {
 5   class Program
 6   {
 7     static void Main(string[] args)
 8     {
 9       string text = "cdacbcdefabcdef";
10       string pattern = "ab";
11 
12       char[] t = text.ToCharArray();
13       char[] p = pattern.ToCharArray();
14 
15       // generate hash table of pattern
16       bool[] hash = new bool[256];
17       for (int i = 0; i < p.Length; i++)
18       {
19         hash[p[i]] = true;
20       }
21 
22       // compare text chars exist in pattern
23       int faster = 0;
24       int slower = 0;
25       while (faster < t.Length)
26       {
27         // want to save some space
28         if (!hash[t[faster]])
29         {
30           t[slower] = t[faster];
31           faster++;
32           slower++;
33         }
34         else
35         {
36           faster++;
37         }
38       }
39 
40       // make string
41       string s = new string(t, 0, slower);
42 
43       Console.WriteLine(s);
44       Console.ReadKey();
45     }
46   }
47 }

字符串转整数算法

输入一个由数字组成的字符串,把它转换成整数并输出。例如:输入字符串 “123”,输出整数 123。

 1 using System;
 2 
 3 namespace ConsoleApplication1
 4 {
 5   class Program
 6   {
 7     static void Main(string[] args)
 8     {
 9       // good
10       Console.WriteLine(string.Format("{0}, {1}",
11         "12345", StringToInt32("12345".ToCharArray())));
12       Console.WriteLine(string.Format("{0}, {1}",
13         "-12345", StringToInt32("-12345".ToCharArray())));
14 
15       // max
16       Console.WriteLine(string.Format("{0}, {1}",
17         "2147483647", StringToInt32("2147483647".ToCharArray())));
18       Console.WriteLine(string.Format("{0}, {1}",
19         "-2147483648", StringToInt32("-2147483648".ToCharArray())));
20 
21       // overflow
22       Console.WriteLine(string.Format("{0}, {1}",
23         "21474836470", StringToInt32("21474836470".ToCharArray())));
24       Console.WriteLine(string.Format("{0}, {1}",
25         "-21474836480", StringToInt32("-21474836480".ToCharArray())));
26 
27       Console.ReadKey();
28     }
29 
30     static int StringToInt32(char[] s)
31     {
32       // do you need handle space?
33       // do you need handle bad char?
34 
35       // check string null
36       if (s.Length == 0)
37       {
38         return 0;
39       }
40 
41       int value = 0;
42       int i = 0;
43 
44       // check positive or negative
45       int sign = 1;
46       if (s[0] == '+' || s[0] == '-')
47       {
48         if (s[0] == '-')
49           sign = -1;
50         i++;
51       }
52 
53       while (i < s.Length)
54       {
55         int c = s[i] - '0';
56 
57         // handle overflow
58         if (sign > 0
59           && (value > int.MaxValue / 10
60             || (value == int.MaxValue / 10
61               && c >= int.MaxValue % 10)))
62         {
63           value = int.MaxValue;
64           break;
65         }
66         else if (sign < 0
67           && (value > -(int.MinValue / 10)
68             || (value == -(int.MinValue / 10)
69               && c >= -(int.MinValue % 10))))
70         {
71           value = int.MinValue;
72           break;
73         }
74 
75         // calculate the value based on 10 times
76         value = value * 10 + c;
77 
78         i++;
79       }
80 
81       return sign > 0
82         ? value
83         : value == int.MinValue ? value : -value;
84     }
85   }
86 }

字符串全排列算法

输入一个字符串,打印出该字符串中字符的所有排列。

例如:输入字符串 “abc”,则输出由字符 ‘a’, ‘b’, ‘c’ 所能排列出来的所有字符串:abc, acb, bac, bca, cab, cba。

 1 using System;
 2 
 3 namespace ConsoleApplication1
 4 {
 5   class Program
 6   {
 7     static void Main(string[] args)
 8     {
 9       // 要求首次输入是有序的,否则需要排序
10       CalculateAllPermutations("abc".ToCharArray());
11 
12       Console.ReadKey();
13     }
14 
15     static void CalculateAllPermutations(char[] s)
16     {
17       // 输出当前排列
18       Console.WriteLine(new string(s));
19 
20       int i, j;
21 
22       // 找到排列中最右一个升序的首位位置 i
23       for (i = s.Length - 2; (i >= 0) && (s[i] >= s[i + 1]); --i) ;
24 
25       // 已经找到所有排列
26       if (i < 0) return;
27 
28       // 找到排列中第 i 位右边最后一个比 s[i] 大的位置 j
29       for (j = s.Length - 1; (j > i) && (s[j] <= s[i]); --j) ;
30 
31       // 交换 s[i],s[j]
32       Swap(s, i, j);
33 
34       // 将第 i + 1 位到最后的部分反转
35       Reverse(s, i + 1, s.Length - 1);
36 
37       // 继续下一次排列
38       CalculateAllPermutations(s);
39     }
40 
41     static void Swap(char[] s, int i, int j)
42     {
43       char temp = s[i];
44       s[i] = s[j];
45       s[j] = temp;
46     }
47 
48     static void Reverse(char[] s, int begin, int end)
49     {
50       char temp;
51       int i = begin;
52       int j = end;
53       while (i < j)
54       {
55         temp = s[i];
56         s[i] = s[j];
57         s[j] = temp;
58         i++;
59         j--;
60       }
61     }
62   }
63 }

字符串字典序组合算法

输入一个字符串,字符串里的字符是互不相同的,打印出该字符串中字符按照字典序输出所有的组合。

例如:输入字符串 “ab”,则输出由字符 ‘a’, ‘b’ 所能排列出来的所有字符串:aa, ab, ba, bb。

 1 using System;
 2 
 3 namespace ConsoleApplication1
 4 {
 5   class Program
 6   {
 7     static void Main(string[] args)
 8     {
 9       // 要求字符是不同的,否则需要去重
10       // 要求输入是有序的,否则需要排序
11       CalculateRepeatablePermutations("abc".ToCharArray(), new char[3], 0);
12 
13       Console.ReadKey();
14     }
15 
16     static void CalculateRepeatablePermutations(char[] s, char[] permutation, int p)
17     {
18       if (p == s.Length)
19       {
20         Console.WriteLine(new string(permutation));
21       }
22       else
23       {
24         for (int i = 0; i < s.Length; ++i)
25         {
26           permutation[p] = s[i];
27           CalculateRepeatablePermutations(s, permutation, p + 1);
28         }
29       }
30     }
31   }
32 }

字符串的(括号)生成算法

输出 n 对括号的全部有效组合。

 1 using System;
 2 using System.Collections.Generic;
 3 
 4 namespace AlgorithmTesting
 5 {
 6   class Program
 7   {
 8     static void Main(string[] args)
 9     {
10       List<string> parenList = GenerateParens(3);
11       foreach (var item in parenList)
12       {
13         Console.WriteLine(item);
14       }
15 
16       Console.ReadKey();
17     }
18 
19     static List<string> GenerateParens(int count)
20     {
21       char[] str = new char[count * 2];
22       List<string> list = new List<string>();
23       AddParen(list, count, count, str, 0);
24       return list;
25     }
26 
27     static void AddParen(
28       List<string> list,
29       int leftRem,
30       int rightRem,
31       char[] str,
32       int count)
33     {
34       // 无效状态
35       if (leftRem < 0 || rightRem < leftRem)
36         return;
37 
38       // 无括号可用
39       if (leftRem == 0 && rightRem == 0)
40       {
41         string s = new string(str);
42         list.Add(s);
43       }
44       else
45       {
46         // 还有左括号可用
47         if (leftRem > 0)
48         {
49           str[count] = '(';
50           AddParen(list, leftRem - 1, rightRem, str, count + 1);
51         }
52 
53         // 还有右括号可用
54         if (rightRem > leftRem)
55         {
56           str[count] = ')';
57           AddParen(list, leftRem, rightRem - 1, str, count + 1);
58         }
59       }
60     }
61   }
62 }

 

本篇文章《字符串算法》由 Dennis Gao 原创并发表自博客园个人博客,未经作者本人同意禁止以任何的形式转载,任何自动的或人为的爬虫转载行为均为耍流氓。

    原文作者:匠心十年
    原文地址: https://www.cnblogs.com/gaochundong/p/string_algorithms.html#contain_all_chars
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞