예제 #1
0
        //The below function is my implementation for question 2. 
        //
        //:p is the size of the lexicographical order, 
        //:n is the number of strings in the string array,
        //:m is the size of the strings
        //
        //Run-Time: F(n) = p+n*(m+logn)= O(n*logn) or O(n*m) depending if logn > m or m > logn and noting that p can be at maximum, 
        //the size of the alphabet, and thus essentially a constant, 
        //
        public static String[] Sort(String[] un_sorted, string order)
        {
            Dictionary<string, int> priority = new Dictionary<string, int>();
            BST string_score = new BST();

            //iterate through every charcter in the user-specified lexicographical ordering 
            //assign a priority to each character corresponding to their index in the string+1
            priority.Add(" ", 0); 
            for (int i = 0; i < order.Length; i++) //O(p)
            {
                priority.Add(order[i].ToString(), i + 1);
            }

            for (int i = 0; i < un_sorted.Length; i++) //O(n)
            {
                string word = un_sorted[i];
                if (word != null) 
                {
                    double score = -1.0;
                    if (word.Length > 0)
                    {
                        score = 0.0;
                        //Calculate a score similar to calculting the value of a base N character array
                        //In this case, our N would be order.Length + 1 
                        for (int j = 0; j < word.Length; j++) //O(m)
                        {
                            if (priority.ContainsKey(word[j].ToString()))
                                score += priority[word[j].ToString()] * (double)Math.Pow(order.Length + 1, order.Length - j); 
                            else
                                throw new Exception();
                        }
                    }
                    //insert each score with their corresponding string as a key,value pair into a BST. This ensures the strings are sorted based on their score form lowest to greatest, 
                    //when an in-order traveral is performed
                    string_score.insert(score, word); //O(logn)
                }
            }
            return string_score.inOrderTraversal().ToArray();
        }