字符串算法
- 字符串字符判重算法
- 字符串反转算法
- 字符串左旋算法
- 字符串右旋算法
- 字符串旋转匹配算法
- 字符串包含算法
- 字符串删除算法
- 字符串原地替换算法
- 字符串压缩算法
- 字符串变位词检测算法
- 字符串转整数算法
- 字符串全排列算法
- 字符串字典序组合算法
- 字符串的（括号）生成算法
字符串字符判重算法
给定字符串，确定是否字符串中的所有字符全都是不同的。假设字符集是 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 原创并发表自博客园个人博客，未经作者本人同意禁止以任何的形式转载，任何自动的或人为的爬虫转载行为均为耍流氓。
