array copying

[kakashi316]

Im trying to write a program that sorts an array into different sorts.What im trying to do is write a copy function that copys a the original array into a new array and then the sort function sorts that array.I have a function,but it wont display anything when i run it,

This is my code for reference:

#include<iostream>
#include<iomanip>
#include<cstdlib>
#include<fstream>
using std::rand;
using std::srand;
using namespace std;
//FUNCTIONS START
int BubbleSort(int numbers[],int arraysize);
int insertion_sort(int numbers[], int arraysize);
int quickSort(int numbers[], int array_size);
int q_sort(int a[], int left, int right);
int heapSort(int numbers[], int array_size);
int heapify(int numbers[],int array_size);
int siftDown(int numbers[], int start,int end);
int copy(int a[],int numbers[],int arraysize);
//FUNCTIONS END
ofstream outf("f:Proj1-Output.dat", ios::out);
ifstream inf("f:Proj1-Input.dat", ios::in);


//-------------------MAIN-----------------------------------------------------------
int main()
{
     float t1, t2, t3, t4;
    long int start,end;
     int array_cnt=0;         
     int results1;
     int results2;
     int results3;
     int results4;
     srand(time(0));
     int arraysize = 10;
     int numbers[arraysize];
int copiedarray[arraysize];

     
     
outf<<"SIZE   "<<"QUICK "<<"HEAP "<<"BUBBLE "<<"INSERTION "<<endl;      
for (int global=1; global<=20; global++)     
{

                for (int i = 0; i <=arraysize; i++)
                {  
                array_cnt++;     
                }

outf<<array_cnt<<"    ";
                                 copy(copiedarray,numbers,arraysize);
                                 start= clock();
                                 quickSort(copiedarray,arraysize);
                                 end= clock();                                                                         
                                 outf<<(end-start)/CLOCKS_PER_SEC<<"    ";
                                 
                                 start= clock();
                                 results2= insertion_sort(numbers,arraysize);      
                                 end= clock();                                
                                 
                                 start= clock();
                                 results3= BubbleSort(numbers,arraysize);
                                 end= clock();                                     
                                 
                                 start= clock();
                                 results4= heapSort(numbers,arraysize);
                                 end= clock();
}
         return 0;

}    
//END OF MAIN!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!







//BUBBBLE START
int BubbleSort(int a[], int array_size)
{

    
     int i, j, temp;
     for (i = 0; i < (array_size - 1); ++i)
     {
          for (j = 0; j < array_size - 1 - i; ++j )
          {
               if (a[j] > a[j+1])
               {
                    temp = a[j+1];
                    a[j+1] = a[j];
                    a[j] = temp;
               }
          }
     }
}
//BUBBLE END


//INSERTION START
int insertion_sort(int a[], int array_size)
{
     int i, j, key;
     for(j = 1; j < array_size; j++)    
    {
           key = a[j];
           for(i = j - 1; (i >= 0) && (a[i] > key); i++)   
          {
                 a[i+1] = a[i];
          }
         a[i+1] = key;    
     }
}
//INSERTION END


//QUICK START
int quickSort(int a[], int array_size)
{

  int i;
  q_sort(a, 0, array_size - 1);
}

int q_sort(int a[], int left, int right)
{
  int pivot, l_hold, r_hold;

  l_hold = left;
  r_hold = right;
  pivot = a[left];
  while (left < right)
  {
    while ((a[right] >= pivot) && (left < right))
      right--;
    if (left != right)
    {
      a[left] = a[right];
      left++;
    }
    while ((a[left] <= pivot) && (left < right))
      left++;
    if (left != right)
    {
      a[right] = a[left];
      right--;
    }
  }
  a[left] = pivot;
  pivot = left;
  left = l_hold;
  right = r_hold;
  if (left < pivot)
    q_sort(a, left, pivot-1);
  if (right > pivot)
    q_sort(a, pivot+1, right);
}
//QUICK END


//HEAP START


int heapify(int a[],int array_size)
{

    int start= (array_size- 2) / 2;
    for(; start >= 0; start--)     
    {
     siftDown(a, start, array_size-1);
     }
     return 0;
}
int siftDown(int a[], int start,int end)
{
    int root;
    int child;
    root=start;
    while (root * 2 <= end)
    {
          if (root*2 == end)
			child = root * 2;
		else if(a[root * 2] > a[root * 2 + 1])
			child = root * 2;		
		else
			child = root * 2 + 1;


		if(a[root] < a[child])
		{
			swap(a[root], a[child]);
			root = child;
		}
		else
			return 0;
   }
}
int heapSort(int a[], int array_size)
{
    int i;    
      int end;    
	heapify(a, array_size);
	

	for (end = array_size - 1; end >= 1; end--)
	{
		swap(a[end], a[0]);
		siftDown(a, 0, end - 1);		
	}
}
//HEAP END

int copy(int a[],int b[],int arraysize)
{
      
     for (int i = 1; i <=arraysize; i++)
                {   
                int a[arraysize];
                int b[arraysize];
                a[arraysize]= b[arraysize];   
                }
     return a[arraysize];
} 

if anyone can help me,i would be apprecative.

[helios]

Lines 219, 220, 221, and 223: God, that's just awful. On lines 219 and 220 you're creating two new arrays with elements [0..arraysize-1]. Both are uninitialized. Even worse, arraysize is a variable (creating stack arrays of variable size is not standard)! Then on line 221 you go ahaed and produce two buffer overflows by reading one element past the end of b and writing that one element past the end of a. Finally, you produce yet another buffer overflow on line 223 by reading one element past the end of a.
Note that the a and b line 221 refers to are the ones declared on lines 219 and 220, not the function parameters.

[kakashi316]

then any suggestions on how i fix them them?

[kakashi316]

int copy(int a[],int b[])
{
     int arraysize; 
     for (int i = 0; i < arraysize; i++)
                {   
                int a[i];
                int b[i];
                a[i]=b[i];   
                }
     for (int i = 0; i < arraysize; i++)
                {   
                return a[i];   
               }
} 
 

this is my fixed code,it still wont work.any help will be appreciate.

[buffbill]

Try the memcpy(p1,p2,n) function which requires the string.h header file. It copies n elements of memory block p2 to p1

[daman371]

You don't have to return using a function like that. You do it as void because the compiler remembers the addresses of all arrays created, ie, arrays as arguments are pass by reference.

[kempofighter]

The "fixed" code is looping until i becomes >= some uninitialized variable called arraysize.

I recommend that you take a look at std::copy. It is a template function and can take a pointer to the first and last array element as the iterators.
http://cplusplus.com/reference/algorithm/copy/

Now in your copy function you are trying to create new arrays which makes no sense. You need to simply use the input parameters. Moving the arraysize parameter out of the declaration was unwise. You need that in order to tell the copy function how big the input arrays are.

You are inspiring me to write an article about why beginner programmers shouldn't be trying to rewrite the std algorithms as a "learning" exercise. If you simply used std::copy there would be fewer defects in the program.