ساختمان داده در جاوا — از صفر تا صد

1package org.arpit.java2blog;
2 
3import java.util.Arrays;
4public class StringArrayMain {
5 
6    public static void main(String[] args) {
7        String[] strArr = {"One","Two","Three"};
8 
9        System.out.println("Array elements are:");
10        // تکرار روی آرایه
11        for (int i=0;i<strArr.length;i++)
12        {
13            System.out.println(strArr[i]);
14        }
15        System.out.println("====================");
16        System.out.println("Printing array elements using Arrays.toString():");
17        System.out.println("====================");
18        // .برای چاپ آرایه استفاده کرد Arrays.toString() می‌توان از آرایه
19        System.out.println(Arrays.toString(strArr));
20    }
21}

1package org.arpit.java2blog.datastructures;
2 
3class Node {
4    public int data;
5    public Node next;
6 
7    public void displayNodeData() {
8        System.out.println("{ " + data + " } ");
9    }
10}
11 
12public class MyLinkedList {
13    private Node head;
14 
15    public boolean isEmpty() {
16        return (head == null);
17    }
18 
19    // متد درج گره در ابتدای لیست پیوندی
20    public void insertFirst(int data) {
21        Node newHead = new Node();
22        newHead.data = data;
23        newHead.next = head;
24        head = newHead;
25    }
26 
27    // متد حذف گره از ابتدای لیست پیوندی
28    public Node deleteFirst() {
29        Node temp = head;
30        head = head.next;
31        return temp;
32    }
33 
34    // متد برای حذف گره ارائه شده در برنامه
35    public void deleteAfter(Node after) {
36        Node temp = head;
37        while (temp.next != null && temp.data != after.data) {
38            temp = temp.next;
39        }
40        if (temp.next != null)
41            temp.next = temp.next.next;
42    }
43 
44    // متد برای درج در انتهای لیست پیوندی
45    public void insertLast(int data) {
46        Node current = head;
47        while (current.next != null) {
48            current = current.next; // تهی شود، حلقه ایجاد خواهد شد current.next تا زمانی که
49        }
50        Node newNode = new Node();
51        newNode.data = data;
52        current.next = newNode;
53    }
54 
55    // متد برای چاپ لیست پیوندی
56    public void printLinkedList() {
57        System.out.println("Printing LinkedList (head --> last) ");
58        Node current = head;
59        while (current != null) {
60            current.displayNodeData();
61            current = current.next;
62        }
63        System.out.println();
64    }
65 
66    public static void main(String args[])
67    {
68        MyLinkedList myLinkedlist = new MyLinkedList();
69        myLinkedlist.insertFirst(50);
70        myLinkedlist.insertFirst(60);
71        myLinkedlist.insertFirst(70);
72        myLinkedlist.insertFirst(10);
73        myLinkedlist.insertLast(20);
74        myLinkedlist.printLinkedList();
75        // لیست پیوندی به صورت زیر خواهد بود:
76        // 10 -> 70 ->  60 -> 50 -> 20
77 
78        System.out.println("=========================");
79        System.out.println("Delete node after Node 60");
80        Node node=new Node();
81        node.data=60;
82        myLinkedlist.deleteAfter(node);
83        // پس از حذف گره بعد از ۱، لیست پیوندی به صورت زیر خواهد بود:
84        // 10 -> 70 -> 60 -> 20
85 
86        System.out.println("=========================");
87        myLinkedlist.printLinkedList();
88    }
89}

1package org.arpit.java2blog.datastructures;
2 
3class Node {
4    public int data;
5    public Node next;
6    public Node prev;
7 
8    public void displayNodeData() {
9        System.out.println("{ " + data + " } ");
10    }
11}
12 
13public class MyDoublyLinkedList {
14 
15    private Node head;
16    private Node tail;
17    int size;
18 
19    public boolean isEmpty() {
20        return (head == null);
21    }
22 
23    // متد برای درج گره در ابتدای لیست پیوندی
24    public void insertFirst(int data) {
25        Node newNode = new Node();
26        newNode.data = data;
27        newNode.next = head;
28        newNode.prev=null;
29        if(head!=null)
30            head.prev=newNode;
31        head = newNode;
32        if(tail==null)
33            tail=newNode;
34        size++;
35    }
36 
37    // متد برای درج گره در انتهای لیست پیوندی
38    public void insertLast(int data) {
39        Node newNode = new Node();
40        newNode.data = data;
41        newNode.next = null;
42        newNode.prev=tail;
43        if(tail!=null)
44            tail.next=newNode;
45        tail = newNode;
46        if(head==null)
47            head=newNode;
48        size++;
49    }
50    // متد حذف گره از ابتدای لیست پیوندی دو طرفه
51    public Node deleteFirst() {
52 
53        if (size == 0)
54            throw new RuntimeException("Doubly linked list is already empty");
55        Node temp = head;
56        head = head.next;
57        head.prev = null;
58        size--;
59        return temp;
60    }
61 
62    // متد حذف گره از انتهای لیست پیوندی دو طرفه
63    public Node deleteLast() {
64 
65        Node temp = tail;
66        tail = tail.prev;
67        tail.next=null;
68        size--;
69        return temp;
70    }
71 
72    // متد برای حذف گره پس از یک گره خاص
73    public void deleteAfter(Node after) {
74        Node temp = head;
75        while (temp.next != null && temp.data != after.data) {
76            temp = temp.next;
77        }
78        if (temp.next != null)
79            temp.next.next.prev=temp;
80        temp.next = temp.next.next;
81 
82    }
83 
84    // (Forward) متد چاپ لیست پیوندی دو طرفه رو به جلو 
85    public void printLinkedListForward() {
86        System.out.println("Printing Doubly LinkedList (head --> tail) ");
87        Node current = head;
88        while (current != null) {
89            current.displayNodeData();
90            current = current.next;
91        }
92        System.out.println();
93    }
94 
95    // (Backward) متد چاپ لیست پیوندی دو طرفه رو به عقب
96    public void printLinkedListBackward() {
97        System.out.println("Printing Doubly LinkedList (tail --> head) ");
98        Node current = tail;
99        while (current != null) {
100            current.displayNodeData();
101            current = current.prev;
102        }
103        System.out.println();
104    }
105 
106    public static void main(String args[])
107    {
108        MyDoublyLinkedList mdll = new MyDoublyLinkedList();
109        mdll.insertFirst(50);
110        mdll.insertFirst(60);
111        mdll.insertFirst(70);
112        mdll.insertFirst(10);
113        mdll.insertLast(20);
114        mdll.printLinkedListForward();
115        mdll.printLinkedListBackward();
116 
117        System.out.println("================");
118        // :لیست پیوندی دو طرفه به صورت زیر خواهد بود
119        // 10 ->  70 -> 60 -> 50 -> 20
120 
121        Node node=new Node();
122        node.data=10;
123        mdll.deleteAfter(node);
124        mdll.printLinkedListForward();
125        mdll.printLinkedListBackward();
126        // :بعد از حذف نود پس از ۱، لیست پیوندی به صورت زیر خواهد شد
127        // 20 -> 10 -> 60-> 50
128        System.out.println("================");
129        mdll.deleteFirst();
130        mdll.deleteLast();
131 
132        // :پس از انجام عملیات فوق، لیست پیوندی به صورت زیر خواهد شد
133        //  60 -> 50
134        mdll.printLinkedListForward();
135        mdll.printLinkedListBackward();
136    }
137}

1package org.arpit.java2blog.datastructures;
2 
3public class MyStack {
4    int size;
5    int arr[];
6    int top;
7 
8    MyStack(int size) {
9        this.size = size;
10        this.arr = new int[size];
11        this.top = -1;
12    }
13 
14    public void push(int element) {
15        if (!isFull()) {
16            top++;
17            arr[top] = element;
18            System.out.println("Pushed element:" + element);
19        } else {
20            System.out.println("Stack is full !");
21        }
22    }
23 
24    public int pop() {
25        if (!isEmpty()) {
26            int topElement = top;
27            top--;
28            System.out.println("Popped element :" + arr[topElement]);
29            return arr[topElement];
30 
31        } else {
32            System.out.println("Stack is empty !");
33            return -1;
34        }
35    }
36 
37    public int peek() {
38        if(!this.isEmpty())
39            return arr[top];
40        else
41        {
42            System.out.println("Stack is Empty");
43            return -1;
44        }
45    }
46 
47    public boolean isEmpty() {
48        return (top == -1);
49    }
50 
51    public boolean isFull() {
52        return (size - 1 == top);
53    }
54 
55    public static void main(String[] args) {
56        MyStack myStack = new MyStack(5);
57        myStack.pop();
58        System.out.println("=================");
59        myStack.push(100);
60        myStack.push(90);
61        myStack.push(10);
62        myStack.push(50);
63        System.out.println("=================");
64        myStack.pop();
65        myStack.pop();
66        myStack.pop();
67        System.out.println("=================");
68    }
69}

1package org.arpit.java2blog.datastructures;
2 
3public class StackUsingLinkedList {
4    private Node head; // اولین گره
5 
6    // .کلاس بعدی برای تعریف گره در لیست پیوندی ارائه شده است
7    private class Node {
8        int value;
9        Node next;
10    }
11 
12    public StackUsingLinkedList() {
13        head = null;
14    }
15 
16    // .برای شبیه‌سازی پشته، مقدار از ابتدای لیست حذف می‌شود
17    public int pop() throws LinkedListEmptyException {
18        if (head == null) {
19            throw new LinkedListEmptyException();
20        }
21        int value = head.value;
22        head = head.next;
23        return value;
24    }
25 
26    // .برای شبیه‌سازی پشته، مقدار به ابتدای لیست اضافه می‌شود
27    public void push(int value) {
28        Node prevHead = head;
29        head = new Node();
30        head.value = value;
31        head.next = prevHead;
32    }
33 
34    public static void main(String args[])
35    {
36        StackUsingLinkedList sll=new StackUsingLinkedList();
37        sll.push(200);
38        sll.push(150);
39        sll.push(80);
40        sll.push(90);
41        sll.push(600);
42        sll.push(175);
43        System.out.println("Removed element from LinkedList: "+sll.pop());
44        System.out.println("Removed element from LinkedList: "+sll.pop());
45        sll.push(100);
46        System.out.println("Removed element from LinkedList: "+sll.pop());
47        printList(sll.head);
48    }
49    public static void printList(Node head) {
50        Node temp = head;
51        while (temp != null) {
52            System.out.format("%d ", temp.value);
53            temp = temp.next;
54        }
55        System.out.println();
56    }
57}
58 
59/**
60 * .اگر لیست پیوندی خالی باشد از کلاس زیر استفاده می‌شود
61 */
62 
63class LinkedListEmptyException extends RuntimeException {
64    private static final long serialVersionUID = 1L;
65 
66    public LinkedListEmptyException() {
67        super();
68    }
69 
70    public LinkedListEmptyException(String message) {
71        super(message);
72    }
73}

1package org.arpit.java2blog.datastructures;
2 
3public class MyQueue {
4 
5    private int capacity;
6    int queueArr[];
7    int front;
8    int rear;
9    int currentSize = 0;
10 
11    public MyQueue(int size) {
12        this.capacity = size;
13        front = 0;
14        rear = -1;
15        queueArr = new int[this.capacity];
16    }
17 
18    /**
19     * متدی برای اضافه کردن عناصر به صف
20     */
21    public void enqueue(int data) {
22        if (isFull()) {
23            System.out.println("Queue is full!! Can not add more elements");
24        } else {
25            rear++;
26            if (rear == capacity - 1) {
27                rear = 0;
28            }
29            queueArr[rear] = data;
30            currentSize++;
31            System.out.println(data + " added to the queue");
32        }
33    }
34 
35    /**
36     * .این متد عناصر را از ابتدای صف حذف می‌کند
37     */
38    public void dequeue() {
39        if (isEmpty()) {
40            System.out.println("Queue is empty!! Can not dequeue element");
41        } else {
42            front++;
43            if (front == capacity - 1) {
44                System.out.println(queueArr[front - 1] + " removed from the queue");
45                front = 0;
46            } else {
47                System.out.println(queueArr[front - 1] + " removed from the queue");
48            }
49            currentSize--;
50        }
51    }
52 
53    /**
54     * .متدی که پر بودن صف را بررسی می‌کند
55     */
56    public boolean isFull() {
57        if (currentSize == capacity) {
58            return true;
59        }
60        return false;
61    }
62 
63    /**
64     * .متدی که خالی بودن صف را بررسی می‌کند
65     */
66    public boolean isEmpty() {
67 
68        if (currentSize == 0) {
69            return true;
70        }
71        return false;
72    }
73 
74    public static void main(String a[]) {
75 
76        MyQueue myQueue = new MyQueue(6);
77        myQueue.enqueue(1);
78        myQueue.dequeue();
79        myQueue.enqueue(30);
80        myQueue.enqueue(44);
81        myQueue.enqueue(32);
82        myQueue.dequeue();
83        myQueue.enqueue(98);
84        myQueue.dequeue();
85        myQueue.enqueue(70);
86        myQueue.enqueue(22);
87        myQueue.dequeue();
88        myQueue.enqueue(67);
89        myQueue.enqueue(23);
90    }
91}

1package org.arpit.java2blog.datastructures;
2 
3public class QueueUsingLinkedList
4{
5    private Node front, rear;
6    private int currentSize; // اندازه
7 
8    // ساختمان داده گره
9    private class Node
10    {
11        int data;
12        Node next;
13    }
14 
15    // سازنده
16    public QueueUsingLinkedList()
17    {
18        front = null;
19        rear = null;
20        currentSize = 0;
21    }
22 
23    public boolean isEmpty()
24    {
25        return (currentSize == 0);
26    }
27 
28    // .برای شبیه‌سازی صف، موردی از ابتدای لیست حذف می‌شود 
29    public int dequeue()
30    {
31        int data = front.data;
32        front = front.next;
33        if (isEmpty())
34        {
35            rear = null;
36        }
37        currentSize--;
38        System.out.println(data+ " removed from the queue");
39        return data;
40    }
41 
42    // .برای شبیه‌سازی صف داده‌ای به انتهای صف اضافه می‌شود
43    public void enqueue(int data)
44    {
45        Node oldRear = rear;
46        rear = new Node();
47        rear.data = data;
48        rear.next = null;
49        if (isEmpty())
50        {
51            front = rear;
52        }
53        else
54        {
55            oldRear.next = rear;
56        }
57        currentSize++;
58        System.out.println(data+ " added to the queue");
59    }
60    public static void main(String a[]){
61 
62        QueueUsingLinkedList queueUsingLinkedList = new QueueUsingLinkedList();
63        queueUsingLinkedList.enqueue(60);
64        queueUsingLinkedList.dequeue();
65        queueUsingLinkedList.enqueue(10);
66        queueUsingLinkedList.enqueue(20);
67        queueUsingLinkedList.enqueue(40);
68        queueUsingLinkedList.dequeue();
69        queueUsingLinkedList.enqueue(70);
70        queueUsingLinkedList.dequeue();
71        queueUsingLinkedList.enqueue(80);
72        queueUsingLinkedList.enqueue(100);
73        queueUsingLinkedList.dequeue();
74        queueUsingLinkedList.enqueue(150);
75        queueUsingLinkedList.enqueue(50);
76    }
77}

1package org.arpit.java2blog.datastructures;
2 
3import java.util.Stack;
4 
5public class BinaryTree {
6 
7    public static class Node
8    {
9        int data;
10        Node left;
11        Node right;
12        Node(int data)
13        {
14            this.data=data;
15        }
16    }
17 
18    // راه حل بازگشتی
19    public void preorder(Node root) {
20        if(root !=  null) {
21            //Pre order traversal
22            System.out.printf("%d ",root.data);
23            preorder(root.left);
24            preorder(root.right);
25        }
26    }
27 
28    // راه حل تکراری
29    public void preorderIter(Node root) {
30 
31        if(root == null)
32            return;
33 
34        Stack<Node> s = new Stack<Node>();
35        s.push(root);
36 
37        while(!s.empty()){
38 
39            Node n = s.pop();
40            System.out.printf("%s ",n.data);
41 
42            if(n.right != null){
43                s.push(n.right);
44            }
45            if(n.left != null){
46                s.push(n.left);
47            }
48 
49        }
50 
51    }
52 
53    public static void main(String[] args)
54    {
55        BinaryTree bi=new BinaryTree();
56        // ایجاد ساختمان داده درخت باینری
57        Node rootNode=createBinaryTree();
58        System.out.println("Using Recursive solution:");
59 
60        bi.preorder(rootNode);
61 
62        System.out.println();
63        System.out.println("-------------------------");
64        System.out.println("Using Iterative solution:");
65 
66        bi.preorderIter(rootNode);
67    }
68 
69    public static Node createBinaryTree()
70    {
71 
72        Node rootNode =new Node(30);
73        Node node20=new Node(50);
74        Node node10=new Node(60);
75        Node node30=new Node(80);
76        Node node60=new Node(90);
77        Node node50=new Node(100);
78        Node node70=new Node(110);
79 
80        rootNode.left=node20;
81        rootNode.right=node60;
82 
83        node20.left=node10;
84        node20.right=node30;
85 
86        node60.left=node50;
87        node60.right=node70;
88 
89        return rootNode;
90    }
91}

1package org.arpit.java2blog.datastructures;
2 
3public class MyBinarySearchTree {
4    public static class Node
5    {
6        int data;
7        Node left;
8        Node right;
9        Node(int data)
10        {
11            this.data=data;
12        }
13    }
14 
15    public static boolean search(Node root, Node nodeToBeSearched)
16    {
17        if(root==null)
18            return false;
19        if(root.data== nodeToBeSearched.data)
20        {
21            return true;
22        }
23        boolean result=false;
24 
25        if(root.data > nodeToBeSearched.data)
26            result=search(root.left,nodeToBeSearched);
27        else if(root.data < nodeToBeSearched.data)
28            result= search(root.right,nodeToBeSearched);
29 
30        return result;
31    }
32 
33    public static Node insert(Node root, Node nodeToBeInserted)
34    { if(root==null) {
35        root=nodeToBeInserted; return root;
36    } if(root.data > nodeToBeInserted.data)
37    {
38        if(root.left==null)
39            root.left=nodeToBeInserted;
40        else
41            insert(root.left,nodeToBeInserted);
42    }
43    else if(root.data < nodeToBeInserted.data)
44        if(root.right==null)
45            root.right=nodeToBeInserted;
46        else
47            insert(root.right,nodeToBeInserted);
48        return root;
49    }
50 
51    public static void inOrder(Node root)
52    {
53        if(root==null)
54            return;
55        inOrder(root.left);
56        System.out.print(root.data+" ");
57        inOrder(root.right);
58    }
59    public static void main(String[] args)
60    {
61        // ایجاد درخت جست‌وجوی باینری
62        Node rootNode=createBinarySearchTree();
63        Node node55=new Node(55);
64        boolean result=search(rootNode,node55);
65        System.out.println("Searching for node 55 : "+result);
66        System.out.println("---------------------------");
67        Node node13=new Node(13);
68        Node root=insert(rootNode,node13);
69        System.out.println("Inorder traversal of binary tree after adding 13:");
70        inOrder(root);
71 
72    }
73 
74    public static Node createBinarySearchTree()
75    {
76        Node rNode =new Node(40);
77        Node node20=new Node(20);
78        Node node10=new Node(10);
79        Node node30=new Node(30);
80        Node node60=new Node(60);
81        Node node50=new Node(50);
82        Node node70=new Node(70);
83        Node node5=new Node(5);
84        Node node55=new Node(55);
85 
86        insert(null,rNode);
87        insert(rNode,node20);
88        insert(rNode,node10);
89        insert(rNode,node30);
90        insert(rNode,node60);
91        insert(rNode,node50);
92        insert(rNode,node70);
93        insert(rNode,node5);
94        insert(rNode,node55);
95        return rNode;
96    }
97 
98}

1package org.arpit.java2blog.datastructures;
2 
3/*
4 *  برنامه جاوا برای پیاده‌سازی درخت ترای
5 */
6 
7import java.util.*;
8 
9class TrieNode
10{
11    char data;
12    boolean isEnd;
13    int count;
14    LinkedList<TrieNode> childList;
15 
16    /* سازنده */
17    public TrieNode(char c)
18    {
19        childList = new LinkedList();
20        isEnd = false;
21        data = c;
22        count = 0;
23    }
24    public TrieNode getChild(char c)
25    {
26        if (childList != null)
27            for (TrieNode eachChild : childList)
28                if (eachChild.data == c)
29                    return eachChild;
30        return null;
31    }
32}
33 
34public class Trie
35{
36    private TrieNode root;
37 
38    /* سازنده */
39    public Trie()
40    {
41        root = new TrieNode(' ');
42    }
43    /* متد درج ترای از درخت ترای*/
44    public void insert(String word)
45    {
46        if (search(word) == true)
47            return;
48        TrieNode tempCurr = root;
49        for (char ch : word.toCharArray() )
50        {
51            TrieNode child = tempCurr.getChild(ch);
52            if (child != null)
53                tempCurr = child;
54            else
55            {
56                // .اگر فرزند وجود نداشت به لیست اضافه می‌شود
57                tempCurr.childList.add(new TrieNode(ch));
58                tempCurr = tempCurr.getChild(ch);
59            }
60            tempCurr.count++;
61        }
62        tempCurr.isEnd = true;
63    }
64    /* متد برای جست‌و‌جوی کلمات در درخت ترای*/
65    public boolean search(String word)
66    {
67        TrieNode tempCurr = root;
68        for (char ch : word.toCharArray() )
69        {
70            if (tempCurr.getChild(ch) == null)
71                return false;
72            else
73                tempCurr = tempCurr.getChild(ch);
74        }
75        if (tempCurr.isEnd == true)
76            return true;
77        return false;
78    }
79    /* متد برای حذف کلمات از درخت ترای*/
80    public void remove(String word)
81    {
82        if (search(word) == false)
83        {
84            System.out.println(word +" does not present in trien");
85            return;
86        }
87        TrieNode tempCurr = root;
88        for (char ch : word.toCharArray())
89        {
90            TrieNode child = tempCurr.getChild(ch);
91            if (child.count == 1)
92            {
93                tempCurr.childList.remove(child);
94                return;
95            }
96            else
97            {
98                child.count--;
99                tempCurr = child;
100            }
101        }
102        tempCurr.isEnd = false;
103    }
104 
105    public static void displayWordsInTrie(TrieNode root, String str)
106    {
107        TrieNode tempCurr = root;
108        if(root.childList==null || root.childList.size()==0)
109            return;
110        Iterator iter=tempCurr.childList.iterator();
111        while(iter.hasNext())
112        {
113            TrieNode trieNode= (TrieNode) iter.next();
114            str+=trieNode.data;
115            displayWordsInTrie(trieNode,str);
116            if(trieNode.isEnd==true)
117            {
118                System.out.print(" "+str);
119                str=str.substring(0,str.length()-1);
120            }
121            else
122            {
123                str=str.substring(0,str.length()-1);
124            }
125        }
126 
127    }
128    public static void main(String[] args)
129    {
130        Trie t = new Trie();
131        t.insert("apple");
132        t.insert("ape");
133        t.insert("goat");
134        t.insert("goa");
135        t.insert("apt");
136 
137        System.out.println("go present in trie : "+t.search("go"));
138        System.out.println("goa present in trie : "+t.search("goa"));
139        System.out.println("appl present in trie : "+t.search("ape"));
140        System.out.println("========================");
141        System.out.println("Displaying all word present in trie : ");
142        displayWordsInTrie(t.root,"");
143    }
144}

1package org.arpit.java2blog.datastructures;
2 
3import java.util.Arrays;
4public class MinHeap
5{
6    int Heap[];
7    int size;
8    int capacity;
9 
10    public MinHeap(int size)
11    {
12        this.capacity = size;
13        this.size = 0;
14        Heap = new int[size];
15    }
16 
17    int parent(int i)
18    {
19        return (i - 1)/2;     // .ام را برمی‌گرداند i اندیس گره والد
20    }
21 
22    int leftChild(int i)
23    {
24        return (2 * i) + 1;              // .اندیس فرزند سمت چپ را برمی‌گرداند
25    }
26 
27    int rightChild(int i)
28    {
29        return (2 * i) + 2;              // .اندیس فرزند سمت راست را برمی‌گرداند
30    }
31 
32    boolean isLeaf(int i)   // امین گره، گره برگ است یا خیر i بررسی می‌کند که آیا
33    {
34        if (rightChild(i) >= size || leftChild(i) >= size)
35            return true;
36 
37        return false;
38    }
39 
40    /* متد درج گره در ساختمان داده مین هیپ در جاوا
41 
42     */
43    void insert(int data)
44    {
45        if (size >= capacity)
46            return;
47 
48        Heap[size] = data;
49        int tempCurr = size;
50 
51        while (Heap[tempCurr] < Heap[parent(tempCurr)])
52        {
53            swap(tempCurr, parent(tempCurr));
54            tempCurr = parent(tempCurr);
55        }
56        size++;
57    }
58 
59    // حذف و برگرداندن عناصر مینیمم یا ریشه هیپ
60    int extractMinimum()
61    {
62        int min = Heap[0];
63        Heap[0] = Heap[--size];
64        minHeapify(0);
65        System.out.print("\nThe Min Heap after Removing node is :");
66 
67        for(int i=0;i<size;i++)
68            System.out.print(Heap[i]+" ");
69 
70        System.out.println();
71        return min;
72    }
73 
74    // فقط برگرداندن مقادیر مینیمم و ریشه
75    int getMinimum()
76    {
77        int min=Heap[0];
78        return min;
79    }
80 
81    // (Heapify) هیپ کردن گره iام
82    void minHeapify(int i)
83    {
84 
85        // .اگر گره، یک گره غیر برگ باشد و هر یک از فرزندان آن کوچک‌تر باشند
86        if(!isLeaf(i))
87        {
88            if(Heap[i] > Heap[leftChild(i)] || Heap[i] > Heap[rightChild(i)])
89            {
90                if(Heap[leftChild(i)] < Heap[rightChild(i)])
91                {
92                    swap(i, leftChild(i));
93                    minHeapify(leftChild(i));
94                }
95                else
96                {
97                    swap(i, rightChild(i));
98                    minHeapify(rightChild(i));
99                }
100 
101            }
102        }
103 
104    }
105 
106    // minHeapify ساخت مین هیپ با استفاده از 
107    public void minHeap()
108    {
109        // .تا زمانی که «اندازه/۲» باعث شود گره‌های والد تا آن اندیس وجود داشته باشند فراخوانی انجام می‌شود
110        for (int i = (size-1)/2; i >= 0; i--)
111        {
112            minHeapify(i);
113        }
114    }
115 
116    // چاپ محتوای هیپ
117    public void printHeap()
118    {
119        for (int i = 0; i < (size / 2); i++)
120        {
121            if(i==0)
122                System.out.print("Root : "+ Heap[i]);
123            else
124                System.out.print("Parent : " + Heap[i]);
125 
126            if (leftChild(i) < size)
127                System.out.print(" Left : " + Heap[leftChild(i)]);
128 
129            if (rightChild(i) < size)
130                System.out.print(" Right : " + Heap[rightChild(i)]);
131 
132            System.out.println();
133        }
134    }
135 
136    // تعویض دو گره از هیپ
137    void swap(int x, int y)
138    {
139        int temp;
140        temp = Heap[x];
141        Heap[x] = Heap[y];
142        Heap[y] = temp;
143    }
144 
145    // کدهایی برای تست روش‌های فوق
146    public static void main(String[] args)
147    {
148 
149        // ایجاد یک مین هیپ با ظرفیت ۶
150        MinHeap heap = new MinHeap(6);
151 
152        heap.insert(100);
153        heap.insert(200);
154        heap.insert(500);
155        heap.insert(700);
156        heap.insert(800);
157        heap.insert(900);
158 
159        // ساخت مین هیپ
160        heap.minHeap();
161        System.out.println("The Min Heap is : "+     Arrays.toString(heap.Heap));
162 
163        // انجام مینیمم عملیات
164        System.out.println("\nThe Min Value in the heap : " + heap.getMinimum());
165        System.out.println();
166 
167        heap.printHeap();
168 
169        // استخراج مینیمم عملیات
170        System.out.println("Extracted Minimum Node in the heap : " + heap.extractMinimum());
171        System.out.println();
172 
173        // .در نهایت هیپ برای بررسی موارد حذف شده، بررسی می‌شود
174        heap.printHeap();
175 
176    }
177}