Beispiel #1
0
        /// <summary>
        /// Heapify Move Up
        /// </summary>
        protected override void MoveUp(int index)
        {
            if (index <= 0)
            {
                return;
            }

            int topIndex = (index - 1) / 2;

            // Correct order
            if (Comparer.Compare(m_Items[topIndex].Value, m_Items[index].Value) <= 0)
            {
                return;
            }

            int nextIndex = index % 2 == 0 ? index - 1 : index + 1;

            // No next index: swap top and current only
            if (nextIndex >= m_Items.Count)
            {
                MasterHeapNode <T> h = m_Items[topIndex];
                m_Items[topIndex] = m_Items[index];
                m_Items[index]    = h;

                m_Items[topIndex].Index = topIndex;
                m_Items[index].Index    = index;
            }
            else if (Comparer.Compare(m_Items[nextIndex].Value, m_Items[index].Value) < 0)
            {
                MasterHeapNode <T> h = m_Items[nextIndex];
                m_Items[topIndex]  = m_Items[nextIndex];
                m_Items[nextIndex] = h;

                m_Items[topIndex].Index  = topIndex;
                m_Items[nextIndex].Index = nextIndex;
            }
            else
            {
                MasterHeapNode <T> h = m_Items[topIndex];
                m_Items[topIndex] = m_Items[index];
                m_Items[index]    = h;

                m_Items[topIndex].Index = topIndex;
                m_Items[index].Index    = index;
            }

            MoveUp(topIndex);
        }
Beispiel #2
0
        /// <summary>
        /// Heapify Move Down
        /// </summary>
        protected override void MoveDown(int index)
        {
            if (index >= m_Items.Count)
            {
                return;
            }

            int leftIndex = 2 * index + 1;

            // No Left item - do nothing
            if (leftIndex >= m_Items.Count)
            {
                return;
            }

            int rightIndex = leftIndex + 1;

            // Just right index - compare with left and stop
            if (rightIndex >= m_Items.Count)
            {
                if (Comparer.Compare(m_Items[index].Value, m_Items[leftIndex].Value) > 0)
                {
                    MasterHeapNode <T> h = m_Items[index];
                    m_Items[index]     = m_Items[leftIndex];
                    m_Items[leftIndex] = h;

                    m_Items[index].Index     = index;
                    m_Items[leftIndex].Index = leftIndex;
                }

                return;
            }

            // Both indice exist
            if (Comparer.Compare(m_Items[index].Value, m_Items[leftIndex].Value) > 0)
            {
                if (Comparer.Compare(m_Items[leftIndex].Value, m_Items[rightIndex].Value) > 0)
                {
                    MasterHeapNode <T> h = m_Items[index];
                    m_Items[index]      = m_Items[rightIndex];
                    m_Items[rightIndex] = h;

                    m_Items[rightIndex].Index = rightIndex;
                    m_Items[index].Index      = index;

                    MoveDown(rightIndex);
                }
                else
                {
                    MasterHeapNode <T> h = m_Items[index];
                    m_Items[index]     = m_Items[leftIndex];
                    m_Items[leftIndex] = h;

                    m_Items[leftIndex].Index = leftIndex;
                    m_Items[index].Index     = index;

                    MoveDown(leftIndex);
                }
            }
            else if (Comparer.Compare(m_Items[index].Value, m_Items[rightIndex].Value) > 0)
            {
                MasterHeapNode <T> h = m_Items[index];
                m_Items[index]      = m_Items[rightIndex];
                m_Items[rightIndex] = h;

                m_Items[rightIndex].Index = rightIndex;
                m_Items[index].Index      = index;

                MoveDown(rightIndex);
            }
        }