用c++编写函数 reverse，将数组中的元素逆序，函数原型如下。 void reverse( int array[], int size ); 其中 array 为指向数组的指针，size 表示数组的大小。

reverse 函数的实现如下：

void reverse(int array[], int size) {
int temp;
for (int i = ; i < size / 2; i++) {
temp = array[i];
array[i] = array[size - i - 1];
array[size - i - 1] = temp;
}
}

该函数通过循环将数组中的元素逆序，具体实现是将数组的第一个元素与最后一个元素交换，第二个元素与倒数第二个元素交换，以此类推，直到数组中间位置。

相关问题

用指针将数组中的元素逆序存放

### 回答1：
可以使用两个指针分别指向数组的首尾元素，然后交换它们所指向的元素，直到它们相遇为止。下面是一个示例代码：

void reverse_array(int *arr, int len) {
    int *p1 = arr, *p2 = arr + len - 1;
    while (p1 < p2) {
        int temp = *p1;
        *p1 = *p2;
        *p2 = temp;
        p1++;
        p2--;
    }
}

在这个函数中，`arr` 是指向数组首元素的指针，`len` 是数组的长度。首先，定义两个指针 `p1` 和 `p2`，分别指向数组的首尾元素。然后，通过一个循环，每次交换 `p1` 和 `p2` 所指向的元素，并将 `p1` 向后移动一位，将 `p2` 向前移动一位，直到 `p1` 和 `p2` 相遇为止，此时数组中的元素已经逆序存放了。

### 回答2：
通过使用指针，可以将数组中的元素逆序存放。假设有一个整型数组arr，包含n个元素。首先，定义两个指针，分别指向数组的起始位置和末尾位置，记为ptr_start和ptr_end。然后，通过循环的方式，将ptr_start指向的元素与ptr_end指向的元素进行交换，然后分别将ptr_start指针向后移动一位，ptr_end指针向前移动一位，直到ptr_start指针大于等于ptr_end指针时停止交换。这样就能够将数组中的元素逆序存放。具体的算法步骤如下：

1. 定义指向数组起始位置的指针ptr_start，指向数组末尾位置的指针ptr_end。
2. 进入循环，判断ptr_start指针是否小于ptr_end指针。
3. 如果条件成立，执行以下操作：
- 交换ptr_start指针和ptr_end指针所指向的元素。
- 将ptr_start指针向后移动一位。
- 将ptr_end指针向前移动一位。
4. 循环结束后，数组中的元素就被逆序存放了。

下面是一个示例代码的实现：

#include <iostream>
using namespace std;

void reverseArray(int* arr, int n) {
    int* ptr_start = arr;
    int* ptr_end = arr + n - 1;
    while (ptr_start < ptr_end) {
        int temp = *ptr_start;
        *ptr_start = *ptr_end;
        *ptr_end = temp;
        ptr_start++;
        ptr_end--;
    }
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int n = sizeof(arr) / sizeof(arr[0]);

    cout << "原始数组：";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    reverseArray(arr, n);

    cout << "逆序数组：";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    return 0;
}

输出结果为：
原始数组：1 2 3 4 5
逆序数组：5 4 3 2 1

通过以上的算法，我们可以逆序存放数组中的元素。

### 回答3：
要用指针将数组中的元素逆序存放，可以采取以下步骤：

首先，定义一个指向数组首元素的指针和一个指向数组末尾元素的指针。

然后，使用循环将这两个指针逐渐向中间靠拢，交换它们所指向的元素。具体步骤如下：

1. 定义一个整数变量i，令其初始值为0，表示数组的首元素的下标。

2. 定义一个整数变量j，令其初始值为数组长度减1，表示数组的末尾元素的下标。

3. 使用循环，当i小于j时，执行以下操作：

a. 使用临时变量temp，将指针p1所指向的元素的值存储起来。

b. 将指针p2所指向的元素的值赋给指针p1所指向的元素。

c. 将temp的值赋给指针p2所指向的元素。

d. 将指针p1后移一位，即p1++。

e. 将指针p2前移一位，即p2--。

f. 将i的值增加1，即i++。

4. 循环结束后，数组中的元素逆序存放完成。

上述步骤可以通过以下代码实现：

void reverseArray(int* arr, int size) {
    int* p1 = arr; // 指向数组首元素的指针
    int* p2 = arr + size - 1; // 指向数组末尾元素的指针
    while (p1 < p2) {
        int temp = *p1;
        *p1 = *p2;
        *p2 = temp;
        p1++;
        p2--;
    }
}

调用该函数时，传入数组的首地址和数组的长度即可实现将数组元素逆序存放的功能。

12.c++编写一个动态数组类，包括基本功能：对数组的查找、添加/删除元素、 逆序等功能(可自行添加额外功能)。

下面是一个简单的动态数组类实现，包含了基本的查找、添加/删除元素、逆序等功能：

#include <iostream>
using namespace std;

class DynamicArray {
private:
    int size;
    int capacity;
    int* data;

public:
    DynamicArray(int capacity) {
        this->size = 0;
        this->capacity = capacity;
        this->data = new int[capacity];
    }

    ~DynamicArray() {
        delete[] data;
    }

    int getSize() {
        return size;
    }

    int getCapacity() {
        return capacity;
    }

    bool isEmpty() {
        return size == 0;
    }

    bool isFull() {
        return size == capacity;
    }

    int get(int index) {
        if (index < 0 || index >= size) {
            cout << "Index out of bounds" << endl;
            return -1;
        }
        return data[index];
    }

    void set(int index, int value) {
        if (index < 0 || index >= size) {
            cout << "Index out of bounds" << endl;
            return;
        }
        data[index] = value;
    }

    void add(int value) {
        if (isFull()) {
            int* newData = new int[capacity * 2];
            for (int i = 0; i < size; i++) {
                newData[i] = data[i];
            }
            delete[] data;
            data = newData;
            capacity *= 2;
        }
        data[size++] = value;
    }

    void insert(int index, int value) {
        if (index < 0 || index > size) {
            cout << "Index out of bounds" << endl;
            return;
        }
        if (isFull()) {
            int* newData = new int[capacity * 2];
            for (int i = 0; i < size; i++) {
                newData[i] = data[i];
            }
            delete[] data;
            data = newData;
            capacity *= 2;
        }
        for (int i = size; i > index; i--) {
            data[i] = data[i - 1];
        }
        data[index] = value;
        size++;
    }

    void remove(int index) {
        if (index < 0 || index >= size) {
            cout << "Index out of bounds" << endl;
            return;
        }
        for (int i = index; i < size - 1; i++) {
            data[i] = data[i + 1];
        }
        size--;
    }

    void reverse() {
        for (int i = 0; i < size / 2; i++) {
            int temp = data[i];
            data[i] = data[size - i - 1];
            data[size - i - 1] = temp;
        }
    }
};

int main() {
    DynamicArray arr(5);
    arr.add(1);
    arr.add(2);
    arr.add(3);
    arr.add(4);
    arr.add(5);

    cout << "Original array: ";
    for (int i = 0; i < arr.getSize(); i++) {
        cout << arr.get(i) << " ";
    }
    cout << endl;

    arr.insert(2, 6);
    cout << "After inserting 6: ";
    for (int i = 0; i < arr.getSize(); i++) {
        cout << arr.get(i) << " ";
    }
    cout << endl;

    arr.remove(3);
    cout << "After removing element at index 3: ";
    for (int i = 0; i < arr.getSize(); i++) {
        cout << arr.get(i) << " ";
    }
    cout << endl;

    arr.reverse();
    cout << "After reversing: ";
    for (int i = 0; i < arr.getSize(); i++) {
        cout << arr.get(i) << " ";
    }
    cout << endl;

    return 0;
}

在这个示例中，我们定义了一个 `DynamicArray` 类，它包含了一些基本的成员函数，如获取数组大小、获取数组容量、判断数组是否为空或满、获取指定位置的元素、设置指定位置的元素、添加元素、插入元素、删除元素、逆序等功能。

在 `add` 函数中，当数组已满时，我们将数组的容量增加为原来的两倍，并重新分配内存空间；在 `insert` 函数中，我们先判断插入位置是否合法，再判断数组是否已满，如果已满则扩容，最后将插入位置后面的元素依次向后移动一个位置，并将要插入的元素放到指定位置；在 `remove` 函数中，我们先判断删除位置是否合法，然后将删除位置后面的元素依次向前移动一个位置，并将数组大小减一；在 `reverse` 函数中，我们将数组中的元素倒序排列。

最后，在 `main` 函数中，我们创建了一个 `DynamicArray` 对象，并对它进行了一些基本操作，如添加元素、插入元素、删除元素、逆序等，并输出了每次操作后的结果。