Vwwxrf

I am trying to write a NDK program for quicksorting an array. However, in my benchmarks C is doing consistently worse than Java, as indicated by my results:

Java 1190625
C 1809218

Java 895104
C 1372656

Java 1104792
C 1491198

Java 10766875
C 14929115

Java 9200104
C 9770833

Java 5740782
C 9177135

Could someone help me?

package com.example.bill.androidredblacktree;

import android.content.Intent;
import android.net.Uri;
import android.os.Debug;
import android.support.v4.content.FileProvider;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.support.v7.widget.Toolbar;
import android.util.Log;
import android.view.View;

import java.util.Arrays;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;

public class QuicksortBenchmarks extends AppCompatActivity 


 public native void QuicksortCPassArray(int a[]);

 @Override
 protected void onCreate(Bundle savedInstanceState) 
 super.onCreate(savedInstanceState);
 setContentView(R.layout.activity_quicksort_benchmarks);


 int n1[] = 2000,20000;
 int j1 = 0;
 for (j1 = 0; j1 < n1.length; j1++) 
 int counts=0;
 for (int k1=0;k1<3;k1++) 
 int i, n = n1[j1];
 long startTime, estimatedTime, estimatedTime1;

 int a[];
 a = new int[n];
 for (i = 0; i < n; i++) 
 a[i] = i;
 

 int z, j;
 Random rnd = ThreadLocalRandom.current();
 for (j = n - 1; j > 0; j--) 
 z = rnd.nextInt(j + 1);
 swap(a, z, j);
 

 int b[]= Arrays.copyOf(a,a.length);

 startTime = System.nanoTime();
 quicksort(a, 0, n - 1);
 estimatedTime = System.nanoTime() - startTime;
 System.out.print("Java " + estimatedTime + 'n');

 startTime = System.nanoTime();
 QuicksortCPassArray(b);
 estimatedTime1 = System.nanoTime() - startTime; 
 System.out.print("C " + estimatedTime1 + 'n');

 

 







 

 private static void quicksort(int a[], int x, int y) 

 int q;
 if (x < y) 
 q = partition(a, x, y);
 quicksort(a, x, q - 1);
 quicksort(a, q + 1, y);
 
 

 private static int partition(int a[], int x, int y) 
 int temp = a[y];
 int i = x - 1;
 int j;
 for (j = x; j <= y - 1; j++) 
 if (a[j] <= temp) 
 i++;
 swap(a, i, j);
 
 
 swap(a, i + 1, y);
 return (i + 1);
 

 private static void swap(int a[], int i, int j) 
 int t = a[i];
 a[i] = a[j];
 a[j] = t;
 

 private int[] shuffleArray(int a[])
 int i;
 for (i = 0; i < a.length; i++) 
 a[i] = i;
 

 int z;
 Random rnd = ThreadLocalRandom.current();
 for (int j = a.length - 1; j > 0; j--) 
 z = rnd.nextInt(j + 1);
 swap(a, z, j);
 
 return a;

 

#include <jni.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void quicksort(jint *a, jint x, jint y);

jint partition(jint *a, jint x, jint y);

void swap(jint *a, jint *b);


JNIEXPORT void JNICALL
Java_com_example_bill_androidredblacktree_QuicksortBenchmarks_QuicksortCPassArray(
 JNIEnv *env,
 jobject this,
 jintArray arr) 

 jint *c_array = (*env)->GetIntArrayElements(env, arr, 0);

 jint n = (*env)->GetArrayLength(env, arr); 

 quicksort(c_array, 0, n - 1);

 (*env)->ReleaseIntArrayElements(env, arr, c_array, 0);





void quicksort(jint *a, jint x, jint y) 
 jint q;
 if (x < y) 
 q = partition(a, x, y);
 quicksort(a, x, q - 1);
 quicksort(a, q + 1, y);
 



jint partition(jint *a, jint x, jint y) 
 jint temp = *(a + y);
 jint i = x - 1;
 jint j;
 for (j = x; j <= y - 1; j++) 
 if (*(a + j) <= temp) 
 i++;
 jint temp1 = *(a + i);
 *(a + i) = *(a + j);
 *(a + j) = temp1;
 //swap(&a[i], &a[j]);
 
 
 jint temp2 = *(a + i + 1);
 *(a + i + 1) = *(a + y);
 *(a + y) = temp2;
 //swap(&a[i + 1], &a[y]);
 return (i + 1);



void swap(jint *a, jint *b) 
 jint temp = *a;
 *a = *b;
 *b = temp;