Write a Java Program to implement heap and heap sort.

I am assuming that actual index of array for purpose of implementing heap starts with 1 and whatever value is in index no. 0 will treated as garbage.

package heap;
public class Heap
{
    public static void main(String[ ] args)
    {
     
        int [ ]A = {-9999, 67, 28, 2, 23, 5 ,93, 98, -37};
        HeapData myHeap = new HeapData(A);
        System.out.println("Heap formed is:");
        myHeap.printHeap();
        System.out.println(myHeap.checkHeap(A));
        myHeap.HeapSort();
        myHeap.printHeap();
        //test case 1
        int [ ]B = {-9999, 162, 32, 92, 2, 22, 12, 42};  //This is a Heapified Array .. must return true.
        System.out.println(myHeap.checkHeap(B));
        //test case 2
        int [ ]C = {-9999, 12, 32, 2, 32, 29, 122, 43};
        System.out.println(myHeap.checkHeap(C));
    }
}


class HeapData
{
    int [ ] Data;
    HeapData(int [ ]A)
    {
        int i = 1, k = 1;
     
        for(i =2 ; i<A.length; i++)
        {
            k =i;
            do
            {  
                if(A[k] > A[(k>>1)])
                {
                    /* SWAP */
                    A[k] = A[k] ^ A[k>>1];
                    A[k>>1] = A[k] ^ A[k>>1];
                    A[k] = A[k] ^ A[k>>1];
                }
                k = k>>1;
                             
            }while(k>1);
        }
        Data = A;
    }
    void printHeap()
    {
        for(int i = 1 ; i<Data.length;i++)
        {
         
          System.out.print(Data[i]);
           if (i < Data.length -1)
                System.out.print(", ");
        }
        System.out.println();
    }
    boolean checkHeap(int A[ ])
    {
        for (int i = 1; i< A.length/2;i++)
        {
         
            if(!(A[i]>A[2*i] && A[i]>A[(2*i) +1]))
            {
                return false;
            }
        }
        return true;
    }
    void HeapSort()
    {
        int i, j, k = 0;
        for(i = Data.length - 1;i>0;i--)
        {
            //Swap Data[1] with ith element
            Data[i] = Data[i] ^ Data[1];
            Data[1] = Data[i] ^ Data[1];
            Data[i] = Data[i] ^ Data[1];
             for(j =2 ; j<i; j++)
             {
                k =j;
                do
                {  
                    if(Data[k] > Data[(k>>1)])
                    {
                        /* SWAP */
                        Data[k] = Data[k] ^ Data[k>>1];
                        Data[k>>1] = Data[k] ^ Data[k>>1];
                        Data[k] = Data[k] ^ Data[k>>1];
                    }
                    k = k>>1;
                             
                }while(k>1);
            }  
        }
     
    }
 
}