Accessing and storing elements in an array - c

Question

I have a modified version of quicksort in my program that is instructed to sort pairs of numbers by the sum of their squares ( for example: -4,1 > 2,2). My program works fine with positive integers, but when I use too many negative integers the program crashes (any more than one or two negative numbers will cause a crash). I think I'm trying to access or sort undefined parts of the array that is storing the integers. What is it about array storage that I am forgetting? Or is the problem elsewhere?
void swap(int *a,int *b);
int square(int num);
int abs_value(int num);
void quicksort(int arr[],int first,int last);
int main()
{
int num_of_pts;
int num1;
int num2;
printf("Enter number of points: ");//points are coordinates on the xy axis
scanf("%d", &num_of_pts); //that's why there is double
int unsorted_pts_arr[2*num_of_pts];//the amount of storage in the array
for(int i=0; i<num_of_pts; i++){
printf("Enter Point: ");
scanf(" %d",&num1);
scanf(" %d",&num2);
unsorted_pts_arr[2*i]=num1;
unsorted_pts_arr[2*i+1]=num2;
}
quicksort(unsorted_pts_arr,0,num_of_pts);
printf("Sorted Points:");
for(int j=0; j<num_of_pts; j++)
printf(" (%d,%d)",unsorted_pts_arr[2*j],unsorted_pts_arr[2*j+1]);
return 0;
}
void swap(int *a,int *b)
{
int temp;
temp = *b;
*b = *a;
*a = temp;
}
int square(int num)
{
num=abs_value(num);
num*=num;
return num;
}
int abs_value(int num)
{
if(num<0) return -num;
else return num;
}
void quicksort(int arr[],int first,int last)
{
int pivot,j,i;
if(first<last){
pivot=first;
i=first;
j=last;
while(i<j){
while((square(arr[2*i])+square(arr[2*i+1]))<=
(square(arr[pivot])+square(arr[pivot+1]))
&&i<last)
i++;
while((square(arr[2*j])+square(arr[2*j+1]))>
(square(arr[pivot])+square(arr[pivot+1])))
j--;
if(i<j){
swap(&arr[2*i],&arr[2*j]);
swap(&arr[2*i+1],&arr[2*j+1]);
}
}
swap(&arr[pivot],&arr[2*j]);
swap(&arr[pivot+1],&arr[2*j+1]);
quicksort(arr,first,2*j-1);
quicksort(arr,2*j+1,last);
}
}

Answer 1

Main problem
You are most likely accessing the array out of bounds by using 2*j-1 and 2*j+1 as the array indices in the recursive calls.
quicksort(arr,first,2*j-1);
quicksort(arr,2*j+1,last);
When you call quicksort from main, last is equal to num_of_pts. It makes sense that in the recursive calls, you should use j and j+1.
quicksort(arr,first,j);
quicksort(arr,j+1,last);
Suggestion for minor improvement
Implementation of square can be simpler.
int square(int num)
{
return num*num;
}

Answer 2

The last index is num_of_pts-1, so
quicksort(unsorted_pts_arr,0,num_of_pts);
must rather be
quicksort(unsorted_pts_arr, 0, num_of_pts-1);
pivot is used like i and j to index a pair of numbers in arr, so it must be doubled as well:
(square(arr[pivot])+square(arr[pivot+1]))
(both occurences) must be
square(arr[2*pivot])+square(arr[2*pivot+1])
quicksort is passed indexes to pairs of numbers (as in main), so the arguments of the recursive call also must not be doubled:
quicksort(arr,first,2*j-1);
quicksort(arr,2*j+1,last);
must be
quicksort(arr, first, j-1);
quicksort(arr, j+1, last);