# [Algorithm design-priority queue] implementation and operation of priority queue, algorithm queue

Source: Internet
Author: User

[Algorithm design-priority queue] implementation and operation of priority queue, algorithm queue

Priority queue is a specific application of heap sorting.

Priority Queues are divided into the following operations:

1. INSERT (S, x) inserts element x into the priority queue.

2. MAXIMUM (S): returns the element with the MAXIMUM keyword in s.

3. EXTRACT_MAX (S): removes the element of the maximum keyword in S.

4. INCREASE_KEY (S, x, k): increases the key value of element x to k, and k is an element not less than x.

Application of priority queue:

1. Job Scheduling in the shared computer system. The maximum priority queue requires I to record the jobs to be executed and their relative priority. After a job is completed or interrupted, the scheduler calls EXTRACT_MAX to select the job with the highest priority from all the waiting jobs for execution. At any time, the scheduler can call INSERT to present a new job to the queue.

2. DECREASE_KEY can be used in the Minimum Spanning Tree and cell Shortest Path priority algorithms.

Code:

/*
Author: Bai
Name: priority queue
Use for: 1. Share Job Scheduling in computer systems
2. event-driven Simulators
3. Used in the Minimum Spanning Tree and the minimum cell path
Date:
*/
# Include <iostream>
Using namespace std;
Typedef struct heap
{
Int heap_size;
Int * key;
} Heap;
Void initialize (heap *)
{
A-> key = new int;
A-> heap_size = 0;
}
Void MAX_HEAPIFY (heap * A, int I) // to keep the heap as A large root heap (here I use the cyclic operation method, the recursive call method is applied in the introduction to algorithms)
{
// Non-Recursive Method
Int largest;
Int l = 2 * I; // l is the left child of.
Int r = 2 * I + 1; // r is the right child of.
If (l <= A-> heap_size & A-> key [l]> A-> key [I]) // The greater than the number here is changed to smaller than the number, that is, the smaller root heap sorting.
Largest = l;
Else
Largest = I;
If (r <= A-> heap_size & A-> key [r]> A-> key [largest])
Largest = r;
While (largest! = I)
{
Int temp = A-> key [I];
A-> key [I] = A-> key [largest];
A-> key [largest] = temp;
I = largest;
L = 2 * I;
R = 2 * I + 1;
If (l <= A-> heap_size & A-> key [l]> A-> key [I])
Largest = l;
Else
Largest = I;
If (r <= A-> heap_size & A-> key [r]> A-> key [largest])
Largest = r;
}
For (int k = 1; k <= A-> heap_size; k ++)
Printf ("% d,", A-> key [k]);
Printf ("\ n ");
}
Void BUILD_MAX_HEAP (heap *)
{
Int m = (A-> heap_size)/2;
While (m> = 1)
{
MAX_HEAPIFY (A, m );
M --;
}
}
Void HEAP_SORT (heap *)
{
BUILD_MAX_HEAP ();
Printf ("the array after the first creation of a large root heap is :");
For (int k = 1; k <= A-> heap_size; k ++)
Printf ("% d,", A-> key [k]);
Printf ("\ n ");
Int length = A-> heap_size;
Printf ("the array after sorting the big root heap is :");
Printf ("% d,", A-> key );
For (int I = length; I> = 2; I --)
{
A-> key  = A-> key [I];
A-> heap_size --;
MAX_HEAPIFY (A, 1); // currently, only the first node of the heap is incorrect, and all the other subtree is A large root heap.
Printf ("% d", A-> key );
}
Printf ("\ n ");
Printf ("done \ n ");
}
// Calculate the maximum value of the priority queue
Int HEAP_MAXIMUM (heap *)
{
Printf ("% d \ n", A-> key );
Return 0;
}
// Remove the maximum value from the priority queue
Void HEAP_EXTRACT_MAX (heap *)
{
If (A-> heap_size <1)
Printf ("You cannot delete it again! \ N ");
A-> key  = A-> key [A-> heap_size];
A-> heap_size --;
MAX_HEAPIFY (A, 1 );
}
// Increase the number of m in the priority queue to key, key> m
Void HEAP_INCREASE_KEY (heap * A, int I, int key)
{
A-> key [I] = key;
Int parent = I/2;
While (I> 1 & A-> key [I]> A-> key [parent]) // after this point is increased, You need to judge whether it is bigger than the parent node, then, it is cyclically modified.
{
Int temp = A-> key [I];
A-> key [I] = A-> key [parent];
A-> key [parent] = temp;
I = parent;
Parent = I/2;
}

}
// Insert the key value into the priority queue
// Create a new node, assign it a negative infinity value, and then use HEAP_INCREASE_KEY to increase it to the key.
Void HEAP_INSERT (heap * A, int key)
{
A-> heap_size = A-> heap_size + 1;
A-> key [A-> heap_size] = INT_MIN;
HEAP_INCREASE_KEY (A, A-> heap_size, key );
}
Void SHOW_HEAP (heap *)
{
Printf ("the current priority queue is \ n ");
For (int I = 1; I <= A-> heap_size; I ++)
Printf ("% d", A-> key [I]);
Printf ("\ n ");
}
Int main (void)
{
Int ch;
Heap * A = new heap;
Initialize ();
Printf ("enter a set of heap values to end? \ N ");
Int key;
Int I = 1;
While (scanf ("% d", & key) = 1)
{
HEAP_INSERT (A, key); // The insert process automatically creates A priority queue.
}
Fflush (stdin );
While (1)
{
Printf ("**************** select the following operation options **************** \ n ");
Printf ("1. obtain the maximum value of the priority queue \ n ");
Printf ("2. Remove the current maximum value of the priority queue. After the removal, it is still automatically changed to the priority queue structure \ n ");
Printf ("3. Insert a value. After insertion, it is still automatically converted to the priority queue structure \ n ");
Printf ("4. Increase the value of an I point to key \ n ");
Printf ("5. Exit System \ n ");
Scanf ("% d", & ch );
Switch (ch)
{
Case 1: HEAP_MAXIMUM (A); break;
Case 2:

HEAP_EXTRACT_MAX ();
Break;
Case 3:
{
Int key;
Printf ("Enter the Key value you want to insert :");
Scanf ("% d", & key );
HEAP_INSERT (A, key );
}
SHOW_HEAP ();
Break;
Case 4:
{
Printf ("How much do you want to change the number? :");
Int I, key;
Scanf ("% d", & I, & key );
HEAP_INCREASE_KEY (A, I, key );
}
SHOW_HEAP ();
Break;
Case 5:
Return 0;
Default: break;
}
}
}

Result Display:

Related Keywords:
Related Article

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

## A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

• #### Sales Support

1 on 1 presale consultation

• #### After-Sales Support

24/7 Technical Support 6 Free Tickets per Quarter Faster Response

• Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.