Программа не компилируется

// This program demonstrates the QuickSort Algorithm.
#include <iostream>
#include <algorithm>
using namespace std;
 
 
 
 
//**********************************************************
// partition selects the value in the middle of the        *
// array set as the pivot. The list is rearranged so       *
// all the values less than the pivot are on its left      *
// and all the values greater than pivot are on its right. *
//**********************************************************
 
template <class T1>
int partition(T1 set[], int start, int end)
{
   int pivotValue, pivotIndex, mid;
 
   mid = (start + end) / 2;
   swap(set[start], set[mid]);
   pivotIndex = start;
   pivotValue = set[start];
   for (int scan = start + 1; scan <= end; scan++)
   {
      if (set[scan] < pivotValue)
      {
         pivotIndex++;
         swap(set[pivotIndex], set[scan]);
      }
   }
   swap(set[start], set[pivotIndex]);
   return pivotIndex;
}
 
//************************************************
// quickSort uses the quicksort algorithm to     *
// sort set, from set[start] through set[end].   *
//************************************************
 
template <class T>
void quickSort(T set[], int start, int end)
{
   T pivotPoint;
 
   if (start < end)
   {
      // Get the pivot point.
      pivotPoint = partition(set, start, end);
      // Sort the first sub list.
      quickSort(set, start, pivotPoint - 1);
      // Sort the second sub list.
      quickSort(set, pivotPoint + 1, end);
   }
}
//**********************************************
// swap simply exchanges the contents of       *
// value1 and value2.                          *
//**********************************************
 
template <class T>
void swap(T &value1, T &value2)
{
   int temp = value1;
 
   value1 = value2;
   value2 = temp;
}
 
int main()
{
   const int SIZE = 10;  // Array size
   int count;            // Loop counter
 
   // need to override the [] function?
   int array[SIZE] = {7, 3, 9, 2, 0, 1, 8, 4, 6, 5};
 
   // Display the array contents.
   for (count = 0; count < SIZE; count++)
      cout << array[count] << " ";
   cout << endl;
 
   // Sort the array.
   quickSort(array, 0, SIZE - 1);
 
   // Display the array contents.
   for (count = 0; count < SIZE; count++)
      cout << array[count] << " ";
   cout << endl;
   return 0;
}

swap(set[start], set[mid]);

void swap(

using namespace std;

using std::cout;
using std::endl;

#include <iostream>
#include <algorithm>
using std::cout;    using std::endl;
 
 
 
 
//**********************************************************
// partition selects the value in the middle of the *
// array set as the pivot. The list is rearranged so *
// all the values less than the pivot are on its left *
// and all the values greater than pivot are on its right. *
//**********************************************************
 
template <class T1>
int partition(T1 set[], int start, int end) {
    int pivotValue, pivotIndex, mid;
 
    mid = (start + end) / 2;
    std::swap(set[start], set[mid]);
    pivotIndex = start;
    pivotValue = set[start];
    for (int scan = start + 1; scan <= end; scan++) {
        if (set[scan] < pivotValue) {
            pivotIndex++;
            std::swap(set[pivotIndex], set[scan]);
        }
    }
    std::swap(set[start], set[pivotIndex]);
    return pivotIndex;
}
 
//************************************************
// quickSort uses the quicksort algorithm to *
// sort set, from set[start] through set[end]. *
//************************************************
 
template <class T>
void quickSort(T set[], int start, int end) {
    T pivotPoint;
 
    if (start < end) {
// Get the pivot point.
        pivotPoint = partition(set, start, end);
// Sort the first sub list.
        quickSort(set, start, pivotPoint - 1);
// Sort the second sub list.
        quickSort(set, pivotPoint + 1, end);
    }
}
//**********************************************
// swap simply exchanges the contents of *
// value1 and value2. *
//**********************************************
 
template <class T>
void swap(T &value1, T &value2) {
    int temp = value1;
 
    value1 = value2;
    value2 = temp;
}
 
int main() {
    const int SIZE = 10; // Array size
    int count; // Loop counter
 
// need to override the [] function?
    int array[SIZE] = {7, 3, 9, 2, 0, 1, 8, 4, 6, 5};
 
// Display the array contents.
    for (count = 0; count < SIZE; count++)
        cout << array[count] << " ";
    cout << endl;
 
// Sort the array.
    quickSort(array, 0, SIZE - 1);
 
// Display the array contents.
    for (count = 0; count < SIZE; count++)
        cout << array[count] << " ";
    cout << endl;
    return 0;
}

mid = (start + end) / 2;

using std::swap;

int main()
{
   int array1[] = {-18, -1, 9, 1, 9, 33, 34, 45, 100, 75};
 
   int array2[] = {100, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99};
 
  // и т.п.
 
   // Sort the array1
   quickSort(array1, 0, sizeof(array1)/sizeof(*array1)-1);
 
   // Sort the array2 first 10
   quickSort(array2, 0, 9);
 
   // Sort the array2 last 10
   int end2 = sizeof(array2)/sizeof(*array2) -1;
   quickSort(array2, end2-9, end2);
 
   // Выводим 
}