判断重复字符存在：更有意义一点

    class Program
    {
        static void Main(string[] args)
        {
            Program p = new Program();
            List<char> result = p.FindMostFrequentlyUsedChars("hjkluuiuikjk");

            Console.ReadKey();
        }

        /// <summary>
        /// 判断字符串中是否存在重复字符
        /// 该算法假设的前提条件：所有字符都是ASCII
        /// 时间复杂度O(n),n=s.Length
        /// 空间复杂度为常数O(256)
        /// 时间复杂度已经最低了，空间复杂度还能有更优化的解法嘛？
        /// 参见IsStringWithNoDuplicatedChar_Implemenation2
        /// </summary>
        public bool IsStringWithNoDuplicatedChar_Implemenation1(string s)
        {
            bool[] flags = new bool[256];
            foreach (char c in s)
            {
                //错误处理：含有非ASCII码情况
                if (c > 255)
                {
                    throw new ArgumentException("string contains UNICODE char");
                }

                if (flags[c])
                {
                    return false;
                }
                flags[c] = true;
            }
            return true;
        }

        /// <summary>
        /// bit映射法，该解法对比IsStringWithNoDuplicatedChar_Implemenation1空间使用上更少了
        /// </summary>
        public bool IsStringWithNoDuplicatedChar_Implemenation2(string s)
        {
            //注意是Int32而不是Int，在64位机器上Int=Int64
            Int32[] flags = new Int32[8];
            foreach (char c in s)
            {
                //依旧需要该错误处理，因为假设前提是不变的,否则该算法无效
                if (c > 255)
                {
                    throw new ArgumentException("string contains UNICODE char");
                }

                int index = c / 32;
                int relative_position = c % 32;
                if ((flags[index] & (1 << relative_position)) >0)
                {
                    return false;
                }
                flags[index] |= (1 << relative_position);
            }
            return true;
        }

        /// <summary>
        /// 再次增进假设，假设所有字符都是介于a-z的小写字母
        /// 26个字母可用一个32位的int映射
        /// </summary>
        public bool IsStringWithNoDuplicatedChar_Implemenation3(string s)
        {
            Int32 flag = 0;
            foreach (char c in s)
            {
                if (c <='a' && c>='z')
                {
                    throw new ArgumentException("string contains char out of a-z");
                }

                int relative_position = c - 'a';
                if ((flag & (1 << relative_position)) > 0)
                {
                    return false;
                }
                flag |= (1 << relative_position);
            }
            return true;
        }


        /// <summary>
        ///以上算法有意义麽？
        ///很明显这些算法都基于一个共同的前提就是字符集的基数是ASCII码，
        ///如果是Unicode，那么无无论是哪一种，都需要更大的空间
        ///如果假设前提还是ASCII,其实也还有更好的思路：
        ///如果字符串长度大于字符集范围，那么一定属于两种情况之一：
        ///要么有重复字符，要麽输入非法
        ///这便是IsStringWithNoDuplicatedChar_Implemenation4
        /// </summary>
        public bool IsStringWithNoDuplicatedChar_Implemenation4(string s)
        {
            if (s.Length > 256)
            {
                return false;
            }
            else
            {
                return IsStringWithNoDuplicatedChar_Implemenation2(s);
            }
        }

        /// <summary>
        /// 基于输入是ASCII这个前提，
        /// 长度大于256，根本不用判断，肯定有重复
        /// 长度小于256，1-3算法其实对现代计算机来说简直是小菜一碟，不值一提
        /// 所以更有可能的应用场景是找到最常出现的字符，这比判断是否有重复字符看起来更有价值一些
        /// </summary>
        public char? FindMostFrequentlyUsedChar(string s)
        {
            int[] counters = new int[256];
            int most_used_times = 0;
            char? most_used_char=null;
            foreach (char c in s)
            {
                //错误处理：含有非ASCII码情况
                if (c > 255)
                {
                    throw new ArgumentException("string contains UNICODE char");
                }

                counters[c]++;

                if (counters[c] > most_used_times)
                {
                    most_used_times = counters[c];
                    most_used_char = c;
                }
            }
            return most_used_char;
        }

        /// <summary>
        /// 处理FindMostFrequentlyUsedChar无法处理并列第一的情况
        /// 时间复杂度依旧是O(n)
        ///
        /// </summary>
        public List<char> FindMostFrequentlyUsedChars(string s)
        {
            List<char> most_used_chars = new List<char>();
            int[] counters = new int[256];
            int most_used_times = 0;
            foreach (char c in s)
            {
                //错误处理：含有非ASCII码情况
                if (c > 255)
                {
                    throw new ArgumentException("string contains UNICODE char");
                }

                counters[c]++;

                if (counters[c] > most_used_times)
                {
                    most_used_chars.Clear();
                    most_used_times = counters[c];
                    most_used_chars.Add(c);
                }
                else if (counters[c] == most_used_times)
                {
                    most_used_chars.Add(c);
                }
            }
            return most_used_chars;
        }
    }