### Archive

Posts Tagged ‘sorting’

## Python Sorting Algorithm – Heap Sorting -P4

Learning : Python, Math, Algorithm
Subject: Sorting Algorithm, Heap Sort P2

[NOTE: To keep the code as simple as we can, We WILL NOT ADD any user input Varevecations. Assuming that our user will Enter the right inputs.]

In Last Parts (2 & 3) we wort the Following Functions:

• Entering/Creating the Array.
• Print-Out or to Display the Array.
• Check If Array in Max-Heap.
• Convert Array to Max-Heap.

In this Part-4 we will cover another Two important Functions that we need to talk about in our mission to understand the Heap Sorting Algorithm. In a Max-Heap Array we may need to Add new Node to the Array and we may need to Delete a Node. Also I just add Item No.7 style=”color:#2662ee;”>print(‘ ‘*5,’ 7. Start Heap Sorting.’) to the main-menu so we can do Heap Sorting to a given Array.

Starting with Add New Node, Simply we Add the Node to the end of the Array using arrat.append(new_node) then we need to Check If still the Array in Max-Heap If NOT, We MUST Convert it to a Max-Heap.

Scope of Work Ask the user to Enter the New Node Value, Add The Node to the End of the Array, in While Loop Call convert_to_max_heap (arr,True), check_if_max_heap (arr,True) as following:
while not is_max:
arr = convert_to_max_heap (arr,True)
is_max = check_if_max_heap (arr,True)
this will keep check and convert the Array to Max-Heap. Here is the Full code and run screen ..

Now we will write a Function to Delete a Node from the Max-Heap Array. Deleting a Node is just by removing the first node in the Array (Array), then moving the last element in the Array to it’s position, by doing this we may not having a Max-Heap Array any-more, so we need to convert the array to a Max-Heap. In our application here, we will have a while loop and calling the functions (check_if_max_heap and convert_to_max_heap) until we have the Array in a Max-Heap. Here is the code ..

We will stop here in this part. In Part-5 we will Sort any Array using the Max-Heap Sort Algorithm.

..:: Have Fun with Coding ::.. 🙂 Follow me on Twitter..

## Python Sorting Algorithm – Heap Sorting -P2

Learning : Python, Math, Algorithm
Subject: Sorting Algorithm, Heap Sort P2

[NOTE: To keep the code as simple as we can, We WILL NOT ADD any user input Varevecations. Assuming that our user will Enter the right inputs.]

In this post we will start writing some codes for the Heap Sorting application, we will start with the following Functions:

• Entering/Creating the Array.
• Print-Out or to Display the Array.

So First: We will start with the Main_menu Function and will return user_choice also the main application body.. Here is the code ..

``` # Main Menu function and the main application body..

os.system('clear')
print(' '*5,' 1. Enter the Binary Tree as an Array.')
print(' '*5,' 2. Print out the Binary Tree. {Text Mode}')
print(' '*5,' 3. Check if it is a Max Heap.')
print(' '*5,' 4. Convert an Array (Binary Tree) to a Max-Heap.')
print(' '*5,' 5. Add New Node to the Binary Tree.')
print(' '*5,' 6. Delete a Node From the Binary Tree.')
print(' '*5,' 9. Exit.')

user_choice = input("\n Select from the Menu: > ")

return user_choice

# This is the Main application body.
while True :

if user_select == '1' :
print(' Enter the Binary Tree as a Array.')
arr = create_array_node_b_node()

if user_select == '2' :
try:
print_bt_text (arr)
except :
input('\n   You Must First Enter/Create the Array... Press any key then Select Option 1. > ')

if user_select == '3' :
print(' Check if the Array is a Max Heap.')

if user_select == '4' :
print(' Convert an Array (Binary Tree) to a Max-Heap.')

if user_select == '5' :
print(' Add New Node to the Binary Tree.')

if user_select == '6' :
print(' Delete a Node from the Binary Tree.')
#delete_node(arr)

if user_select == '9' :
print('\n\n   Thank you for using this Appliation. ')
input('\n         Press any key .. ')
break

```

Next we will write the function def create_array_node_b_node() in this function the user will start to enter the nodes in the Heap Tree starting from the Root and level-by-level. With every/each Node if the user just press Enter the Node will be as None,then will ask the user if there is any more nodes in the level and if the user answer with [N] then we will complete the level with None. Also in starting of each level we will ask the user if there is any more Nodes remain in the level.
Here is the code ..

In the last Function in this part, we will print-out the Heap-Array as text of Parents and Childs. Here is the code ..

``` # Function to print-out the Heap-Array Tree

def print_bt_text (arr):
"""
Function will Write/Print-out the Tree as Text Showing the Parents and the Childs.

Arguments: The Array as arr

return None
"""
os.system('clear')
print("\n\n==========[ Print out the Binary Tree. {Text Mode} ]==========\n\n")

print('   The array we Have is: ',arr)

for x in range (0,len(arr)):
print(' ')
if arr[x] != None :

try:  # For left childs
l_child = 2 * x + 1

if arr[l_child] != None :
print(f'   Parent Node ({arr[x]}) has a Left Child ({arr[l_child]})',end="")

elif arr[l_child] == None:
print(f'   Parent Node ({arr[x]}) has NO Left Child',end="")
except:
pass

try:   # For right Childs
r_child = 2 * x + 2

if (arr[l_child] == None) and (arr[r_child] != None) :
print(f' But it Has a Right Child ({arr[r_child]}).')

elif (arr[l_child] != None) and (arr[r_child] != None) :

print(f' and a Right Child ({arr[r_child]})')

elif (arr[r_child] == None):
print(f' and Has NO Rigth Child.')
except:
pass

input('   DONE ... Here is a Print out of the Heap Tree Array in {Text Mode}')
```

We will stop here in this part and will do more Functions in Part 3

..:: Have Fun with Coding ::.. 🙂 Follow me on Twitter..

## Python Sorting Algorithm – Heap Sorting -P1

Learning : Python, Math, Algorithm
Subject: Sorting Algorithm, Heap Sort

[NOTE: To keep the code as simple as we can, We WILL NOT ADD any user input Varevecations. Assuming that our user will Enter the right inputs.]

Once I start preparing and writing the code for Heap Sorting I fond that I can’t jump to the Heap Sorting without some introductions, So in this post we will cover the Array, Binary Tree, Binary Array, Max-Heap, how to know if a given Array is in Max-Heap or not, Add node to a Max-Heap and Delete a node from a Max-heap. For all this, we will have two or three posts to cover what i think we must know.

So First:
Binary Tree: A Binary Tree is a set of Nodes and each Node may have a Maximum of TWO Childs, called Left-Child and Right-Child. Going down to the next level, each of the Child’s (the left one and the right one) again may have TWO Child’s (Left and Right) .. and so on. The last level were there is no more child’s that level is the Leaves. Here are some sample of Binary Tree’s..

All the above are Binary Tree’s, But we will talk about Three Definitions for a Binary Trees:

Full Binary Tree, Complete Binary Tree, Perfect Binary Tree

Full Binary Tree:
A Tree is a Full Binary Tree in which Every/All Nodes Except Leaf Nodes(last level) have Zero or Two Children.

Complete Binary Tree:
A Binary Tree called a {complete binary tree} in which All/Each levels are completely filled except possibly the last level has all keys as left as possible
Practical example of Complete Binary Tree is Binary Heap.

Perfect Binary Tree:
A Binary Tree is {a Perfect Binary Tree} IF all the internal nodes have Two children and all leaf nodes are at the same level.

NOTE: Every Full Binary Tree is A Complete.

Binary Tree And Array: To convert a binary tree into array or to present a Binary Tree as an Array we need to consider the following :
1. To Taking all the elements in the Binary Tree.
2. To Keeping the relations between the nodes, who is the parent and what are the childerns for each parents [Left child and Right child].

1. Taking all the elements in the Binary Tree:
So for a given tree as Figure 1:[in above example] , we can see that (A) is the First Element [Root] (First Parent) and has 2 childs (B) (Left Child) & (C) (Right Child), –> Then Element (B) as parent has Two childs (D) (Left Child) & (E) (Right Child), –> Then Element (C) as parent has Two Childs (F) (Left Child) & (G) (Right Child) .. this is the end of the tree, leaves level.

Now, IF we want to present this Tree as an Array we will start with (A) in index 0, then will write all the elements level by level, from Left to Right. So we will have the array a1 as follow:
a1 = [A,B,C,D,E,F,G]

2. Keeping the relations between the Nodes: Using the Method of filling the Array as in point One (above) we Save the relations between the Parents and Childs. For a given Array a1 = [A,B,C,D,E,F,G] we can user three formulas to know the Parent and the Childs of any given Node as following:
Assuming we are at index (x) then:
1. Left Child Index of Node (x) : 2 * x + 1
2. Right Child Index of Node (x) : 2 * x + 2
3. Parent Index of Node (x) : x//2 (absolute value of the division)

So, if we refer to a1 Array and (Figure-1), and say we want to know the childrens of node (A), Node (A) is in index  so:
The Left child index of Node (A) is : 2 * 0 + 1 = 0 + 1 = 1, the Element in index 1 in the Array a1 = B.

The Right child index of Node (A) is : 2 * 0 + 2 = 0 + 2 = 2, the Element in index 2 in the Array a1 = C.

The Left child index of Node (C) is : 2 * 2 + 1 = 4 + 1 = 5, the Element in index 5 in the Array a1 = F.

The Right child index of Node (C) is : 2 * 2 + 2 = 4 + 2 = 6, the Element in index 6 in the Array a1 = (G).

The Parent of Node (E) will be: 4//2 = 2, so the parent of the Element (E) is a1 = (B)

Heap Tree: Is a Binary Essentially an almost Complete Tree. So a Heap Tree is: Tree with All/Each levels are completely Filled except possibly the last level has all keys as left as possible. In Heap The Nodes represents as Integer Numbers.

Max-Heap: In Max-Heap Tree the Child Node is Smaller than his Parent.

Mini-Heap: In Mini-Heap Tree the Child Node is Larger than his Parent.

We will stop here in this part and will start doing some coding in Python Sorting Algorithm – Heap Sorting – P2.

..:: Have Fun with Coding ::.. 🙂 Follow me on Twitter..