编写程序实现对顺序表逆置

编写程序实现顺序表（数组或者链表）逆置通常涉及到两个步骤：首先，我们需要遍历整个列表并将元素存储到临时位置；然后，再将这些元素按照相反的顺序放回原列表的位置。这里以数组为例，给出一个简单的Python实现：

def reverse_array(arr):
    # 初始化两个指针，一个指向开始，一个指向结束
    start = 0
    end = len(arr) - 1
    
    # 循环直到两个指针相遇
    while start < end:
        # 交换当前位置的元素
        arr[start], arr[end] = arr[end], arr[start]
        
        # 移动指针
        start += 1
        end -= 1
    
    return arr

# 示例：
original_list = [1, 2, 3, 4, 5]
reversed_list = reverse_array(original_list)
print("逆置后的列表：", reversed_list)

相关问题

用c编写程序实现对顺序表逆置

在 C 语言中，我们可以使用两个指针（一个指向列表开头，另一个指向结尾）逐步交换元素来实现顺序表（数组）的逆置。以下是一个简单的示例：

#include <stdio.h>

// 定义顺序表结构体
typedef struct {
    int data;
    struct Node* next; // 指向下一个元素的指针
} Node;

// 创建一个新的节点
Node* createNode(int value) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = value;
    newNode->next = NULL;
    return newNode;
}

// 逆置顺序表
void reverseList(Node** head) {
    Node* prev = NULL; // 初始化前一个节点为NULL
    Node* current = *head; // 当前节点初始化为头节点

    while (current != NULL) { // 只要还有元素
        Node* temp = current->next; // 保存当前元素的下一个节点
        current->next = prev; // 将当前元素链接到前一个
        prev = current; // 更新前一个节点为当前节点
        current = temp; // 移动到下一个元素
    }
    *head = prev; // 最后，将新的头节点设置为原尾节点
}

// 打印顺序表
void printList(Node* head) {
    Node* temp = head;
    while (temp != NULL) {
        printf("%d ", temp->data);
        temp = temp->next;
    }
    printf("\n");
}

int main() {
    // 创建一个顺序表并填充数据（这里仅做演示，实际应用需要根据实际情况添加）
    Node* list = createNode(1);
    list->next = createNode(2);
    list->next->next = createNode(3);
    
    printf("Original List: ");
    printList(list);

    // 逆置顺序表
    reverseList(&list);

    printf("Reversed List: ");
    printList(list);

    return 0;
}

在这个例子中，`reverseList` 函数接收一个指向顺序表头节点的指针，并通过改变节点之间的连接将其逆置。

编写程序实现对顺序表逆置（C语言）

在C语言中，编写程序实现顺序表（如数组）的逆置，通常需要创建一个新的逆序存储空间，并将原列表中的元素逐个复制到新空间的对应位置。这里是一个简单的示例：

#include <stdio.h>

// 定义顺序表结构体
typedef struct {
    int* data; // 存储数据的指针
    int size;   // 列表大小
    int capacity; // 最大容量
} List;

// 函数声明：用于初始化列表
void create(List* list, int capacity);

// 函数声明：逆置列表
void reverse(List* list);

// 函数声明：打印列表
void print(List* list);

int main() {
    List my_list;
    create(&my_list, 10); // 初始化列表

    // ... (添加一些元素)

    printf("Original List:\n");
    print(&my_list);
    
    reverse(&my_list); // 逆置列表

    printf("\nReversed List:\n");
    print(&my_list);

    return 0;
}

// 初始化函数
void create(List* list, int capacity) {
    list->data = malloc(capacity * sizeof(int));
    if (!list->data) {
        printf("Memory allocation failed.\n");
        exit(1);
    }
    list->size = 0;
    list->capacity = capacity;
}

// 逆置函数
void reverse(List* list) {
    int temp;
    for (int i = 0; i < list->size / 2; i++) {
        temp = list->data[i];
        list->data[i] = list->data[list->size - i - 1];
        list->data[list->size - i - 1] = temp;
    }
}

// 打印函数
void print(List* list) {
    for (int i = 0; i < list->size; i++) {
        printf("%d ", list->data[i]);
    }
    printf("\n");
}

在这个例子中，`create()`函数用于初始化一个顺序表，`reverse()`函数通过交换相邻元素的位置来逆置列表，`print()`函数用于显示列表内容。运行这个程序会先输出原始列表，然后输出逆置后的列表。