コード例 #1
0
        public void TestSystemDefaultMapBasicPutandGet()
        {
            var map = new SysDefaultMap <int, int>();
            int len = 100;

            for (int i = 0; ++i <= len;)
            {
                map[i] = i * i;
                WriteLine(map[i]);
            }
        }
コード例 #2
0
        /// <summary>
        /// it will use Floyd buildheap algorithm, it will not modify the inputs.
        /// </summary>
        /// <return>
        /// A new heap that made from the Floyd Buildheap Algorithm.
        /// </return>
        public static MyLittleArrayHeapPriorityQueue <R> BuildHeap <R>(R[] arg)
            where R : IComparable <R>
        {
            IMap <R, int> freqmap = new SysDefaultMap <R, int>();

            for (
                int i = -1;
                ++i < arg.Length;
                freqmap[arg[i]] = freqmap.ContainsKey(arg[i]) ? freqmap[arg[i]] + 1 : 1
                )
            {
                ;
            }

            // Split it into 2 array;
            int elementcount = 0;

            int[] freqtable    = new int[freqmap.Size];
            R[]   contentatble = new R[freqmap.Size];
            int   uniquecount  = 0;

            foreach (KVP <R, int> kvp in freqmap)
            {
                contentatble[uniquecount] = kvp.Key;
                freqtable[uniquecount]    = kvp.Value;
                elementcount += kvp.Value;
                uniquecount++;
            }
            MyLittleArrayHeapPriorityQueue <R> q = new MyLittleArrayHeapPriorityQueue <R>();

            q.ArrayHeap          = contentatble;
            q.Frequencies        = freqtable;
            q.UniqueElementCount = uniquecount;
            q.ElementCount       = elementcount;
            for (int i = (q.ArrayHeap.Length / 4) - 1; i >= 0; i--)
            {
                q.PercolateDown(i);
            }

            return(q);


            /* MyLittleArrayHeapPriorityQueue<R> resultQ =
             *   new MyLittleArrayHeapPriorityQueue<R>();
             * resultQ.ElementCount = arg.Length;
             * IMap<R, int> freqmap = new SysDefaultMap<R, int>();
             * for (
             *       int i = -1;
             ++i < arg.Length;
             *       freqmap[arg[i]] = freqmap.ContainsKey(arg[i]) ? freqmap[arg[i]] + 1 : 1
             *   );
             * resultQ.ArrayHeap = new R[freqmap.Size];
             * resultQ.Frequencies = new int[freqmap.Size];
             * int uniquecount = 0;
             * foreach (KVP<R, int> kvp in freqmap)
             * {
             *   resultQ.ArrayHeap[uniquecount] = kvp.Key;
             *   uniquecount++;
             * }
             * resultQ.UniqueElementCount = uniquecount;
             * for (int i = uniquecount / 4; i >= 0; i--)
             * {
             *   resultQ.PercolateDown(i, true);
             * }
             * for (int i = 0; i < uniquecount; i++)
             * {
             *   resultQ.Frequencies[i] = freqmap[resultQ.ArrayHeap[i]];
             *   resultQ.Indices[resultQ.ArrayHeap[i]] = i;
             * }
             * return resultQ; */
        }