Why is my heapsort faster than Javas and C++s sort functions?

Your Java code looks bugged to me

int tmp = heap[0];
heap[i] = heap[0];
heap[i] = tmp;

That's not the code to swap two elements.

Does that make a difference to the execution time? I don't know heap sort well enough to be sure.

You do not properly swap items in either your Java (as john pointed out), nor your C++ code:

void heapSort(vector<int> & heap, int length)
{
    int heapsize = length;
    buildHeap(heap, heapsize);
    for(int i = heapsize-1; i >= 1; i--)
    {
        int tmp = heap[0];
        heap[i] = heap[0];
        heap[i] = tmp; // overwrote the item you just tried to swap!
        heapsize--;
        heapify(heap, 0, heapsize);
    }
}

In short, your code is "more efficient" because it doesn't do any sorting at all.

There is one other issue in your C++ code that relates to how you're generating your random distribution:

int randomval()
{
  double d;
  int result;
  d = rand() / RAND_MAX;
  result = (int) (d * N);
  return result;
}

d is always going to be 0 because you are perform an int division and then implicitly converting it to double afterwards. In short, your randomval function isn't giving you any random values at all.

When you sort this with your own heap sort, the same code path is always executed. In your case, heapify will probably never execute this portion of code:

if (largest != i)
{
    int tmp = heap[i];
    heap[i] = heap[largest];
    heap[largest] = tmp;

    heapify(heap, largest, heapsize);
}

which is why your implementation appears to be faster.

Fixing the random test data with an actual distribution I think you'll find your implementation to be slower:

#include <random>
// snip...
int main()
{
  int length = 10000000;
  std::vector<int> vint1;

  std::default_random_engine gen;
  std::uniform_int_distribution<int> randomval(1, N);
  for (int i = 0; i < length; i++)
  {
        vint1.push_back(randomval(gen));
  }
  std::vector<int> vint2 = vint1; /* so we're sorting same testdata for both */
  // ...

Rerunning the benchmark again shows:

g++ -std=c++0x -Wall -pedantic -O2 heapsorttest.cpp -o heapsorttest.exe
heapsorttest.exe

Heapsort: 5.822s
true

std::sort: 0.936s
true