How do you write a program in c plus plus to swap each half of an array?

Answer 1

Swapping array elements is simple enough. The only issue is what to do with the middle element when there are an odd number of elements. The following program simply leaves it where it is.

#include<iostream>

#include<vector>

template<typename T>

void exchange (std::vector<T>& v)

{

if (v.size()<2) return;

size_t left = 0;

size_t right = v.size() / 2;

if (v.size()%2)

++right; // skip middle element

while (right < v.size())

std::swap (v[left++], v[right++]);

}

int main()

{

std::vector<unsigned> v {4, 8, 15, 16, 23, 42, 69};

for (auto n : v) std::cout << n << ' '; std::cout << std::endl;

exchange (v);

for (auto n : v) std::cout << n << ' '; std::cout << std::endl;

}

Answer 2

The following is the inefficient way of doing it; physically swapping each individual element in the array (assuming both arrays are of the same size):

template<typename T>

void copy(T& A[], T& B[], size_t size)

{

if( &A == &B )

return;

for(int index=0; index<size; ++index)

{

A[index]^=B[index]^=A[index]^=B[index];

}

}

A more efficient method is to simply point at the two arrays, and swap the pointer values instead. By doing so, you not only save a great deal of processing time (swapping two pointer variable values instead of potentially millions of elements), you also overcome the problem of swapping arrays of different sizes. The trick is to use pointers to the arrays, rather than references to the arrays, since references cannot be swapped, other than by physically swapping the elements being referred to. Also, it pays to use arrays of pointers to objects rather than arrays of objects, regardless of the object complexity. Copying pointers is always more efficient than copying objects.