示例#1
0
        static void PriorityQueueTest()
        {
            { 
                PriorityQueue<int> queueRemoveMin = new PriorityQueue<int>();
                PriorityQueue<int> queueRemoveMax = new PriorityQueue<int>();
                List<int> doubleCheckMin = new List<int>();
                List<int> doubleCheckMax = new List<int>();
                Random r = new Random();
                // Generate the list of numbers to populate the queue and to check against
                for (int i = 0; i < 20; i++)
                {
                    int randInt = r.Next(-100, 100);
                    doubleCheckMin.Add(randInt);
                }

                for (int i = 0; i < doubleCheckMin.Count; i++)
                {
                    int randInt = doubleCheckMin[i];
                    // heap.Add("" + i, i);
                    queueRemoveMin.Enqueue(randInt, randInt);
                    queueRemoveMax.Enqueue(randInt, randInt);
                    doubleCheckMax.Add(randInt);
                }
                doubleCheckMin.Sort(); // Default. Ascending
                doubleCheckMax.Sort(delegate (int x, int y)
                {
                    if (x == y) return 0;
                    if (x > y) return -1;
                    if (x < y) return 1;
                    return 0;
                });

                Console.WriteLine(" -- NOW REMOVE MIN --");

                int checkCount = 0;
                while (queueRemoveMin.Count > 0)
                {
                    int min = queueRemoveMin.DequeueMin();
                    if (doubleCheckMin[checkCount] != min)
                    {
                        throw new Exception("WRONG!");
                    }
                    checkCount++;
                    Console.WriteLine(min);
                }
                Console.WriteLine(" -- NOW REMOVE MAX --");
                checkCount = 0;
                while (queueRemoveMax.Count > 0)
                {
                    int max = queueRemoveMax.DequeueMax();
                    if (doubleCheckMax[checkCount] != max)
                    {
                        throw new Exception("WRONG!");
                    }
                    checkCount++;
                    Console.WriteLine(max);
                }
            }


            // Now for some random fun. Randomly decide what operation we're performing. 
            // Sorted list is kept alongside for double-checking validity of heap results.
            {
                PriorityQueue<int> queue = new PriorityQueue<int>();
                queue.DebugValidation = true;
                List<int> list = new List<int>();

                const int kMaxOperations = 2000;
                int numOps = 0;
                Random r = new Random();
                for (numOps = 0; numOps < kMaxOperations; numOps++)
                {
                    int randInt = r.Next(0, 4);
                    switch (randInt)
                    {
                        case 0:
                        case 1: // twice as likely to occur
                            {
                                // Add an item.
                                randInt = r.Next(-1000, 1000);
                                Console.WriteLine("Adding : " + randInt);
                                list.Add(randInt);
                                queue.Enqueue(randInt, randInt);
                                if (list.Count != queue.Count)
                                {
                                    throw new Exception("Count mismatch!");
                                }
                            }
                            break;
                        case 2:
                            {
                                // Dequeue Min
                                list.Sort();
                                if (list.Count != queue.Count)
                                {
                                    throw new Exception("Count mismatch! List= " + list.Count + ", queue = " + queue.Count);
                                }
                                if (list.Count == 0)
                                {
                                    // well, can't do much here. early break
                                    break;
                                }
                                int listMin = list[0];
                                list.RemoveAt(0);
                                int queueMin = queue.DequeueMin();
                                if (listMin != queueMin)
                                {
                                    throw new Exception("Min mismatch! List=" + listMin + ", queue=" + queueMin);
                                }
                                Console.WriteLine("DequeueMin : " + queueMin);
                            }

                            break;
                        case 3:
                            {
                                // DequeueMax
                                list.Sort(delegate (int x, int y)
                                {
                                    if (x == y) return 0;
                                    if (x > y) return -1;
                                    if (x < y) return 1;
                                    return 0;
                                });
                                if (list.Count != queue.Count)
                                {
                                    throw new Exception("Count mismatch! List= " + list.Count + ", queue = " + queue.Count);
                                }
                                if (list.Count == 0)
                                {
                                    // well, can't do much here. early break
                                    break;
                                }
                                int listMax = list[0];
                                list.RemoveAt(0);
                                int queueMax = queue.DequeueMax();
                                if (listMax != queueMax)
                                {
                                    throw new Exception("Max mismatch! List=" + listMax + ", queue=" + queueMax);
                                }
                                Console.WriteLine("DequeueMax : " + queueMax);
                            }
                            break;
                    }
                }
                Console.WriteLine("All tests passed!");

            }

        }