当前位置： 首页 > article >正文

将一个数组逆序输出。-多语言

article 2024/12/5 3:41:07

目录

C 语言实现

方法 1: 交换元素

方法 2: 使用辅助数组

方法 3: 使用递归

 方法 4: 使用标准库函数（C99及以上）

总结

Python 实现

方法 1: 交换元素

方法 2: 使用切片 

方法 3: 使用 reversed() 函数

方法 4: 使用 list.reverse() 方法

方法 5: 使用 for 循环和 append()

总结

Java 实现

方法 1: 交换元素

方法 2: 使用 Collections.reverse() 方法（适用于对象数组）

方法 3: 使用递归方法

方法 4: 使用 Java 8 的流（Streams）

Js 实现

题目：将一个数组逆序输出。

程序分析：用第一个与最后一个交换。

C 语言实现

这个程序的功能是反转一个数组。

方法 1: 交换元素

#include <stdio.h>
#define N 10

int main() {
    int a[N] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; // 初始化数组
    int i, t;

    // 打印原始数组
    printf("原始数组是:\n");
    for (i = 0; i < N; i++) {
        printf("%d ", a[i]);
    }

    // 反转数组
    for (i = 0; i < N / 2; i++) {
        t = a[i];
        a[i] = a[N - 1 - i];
        a[N - 1 - i] = t;
    }

    // 打印反转后的数组
    printf("\n反转后的数组:\n");
    for (i = 0; i < N; i++) {
        printf("%d ", a[i]);
    }
    printf("\n");

    return 0;
}
  1. 数组初始化：数组 a 被初始化为包含 0 到 9 的整数。
  2. 打印原始数组：使用循环打印原始数组的内容。
  3. 反转数组：
    • 使用一个循环遍历数组的前半部分，将每个元素与其对应的后半部分元素交换。
    • 通过临时变量 t 来完成交换。
  4. 打印反转后的数组：再次使用循环打印反转后的数组内容。

方法 2: 使用辅助数组

我们可以创建一个辅助数组来存储反转后的结果，然后将其复制回原数组。

#include <stdio.h>
#define N 10

int main() {
    int a[N] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; // 初始化数组
    int b[N]; // 辅助数组
    int i;

    // 打印原始数组
    printf("原始数组是:\n");
    for (i = 0; i < N; i++) {
        printf("%d ", a[i]);
    }

    // 使用辅助数组反转
    for (i = 0; i < N; i++) {
        b[i] = a[N - 1 - i]; // 将原数组的元素反向存储到辅助数组
    }

    // 将辅助数组复制回原数组
    for (i = 0; i < N; i++) {
        a[i] = b[i];
    }

    // 打印反转后的数组
    printf("\n反转后的数组:\n");
    for (i = 0; i < N; i++) {
        printf("%d ", a[i]);
    }
    printf("\n");

    return 0;
}

方法 3: 使用递归

我们还可以使用递归的方法来反转数组。

#include <stdio.h>
#define N 10

void reverseArray(int arr[], int start, int end) {
    if (start >= end) {
        return; // 基本情况
    }
    // 交换元素
    int temp = arr[start];
    arr[start] = arr[end];
    arr[end] = temp;

    // 递归调用
    reverseArray(arr, start + 1, end - 1);
}

int main() {
    int a[N] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; // 初始化数组
    int i;

    // 打印原始数组
    printf("原始数组是:\n");
    for (i = 0; i < N; i++) {
        printf("%d ", a[i]);
    }

    // 反转数组
    reverseArray(a, 0, N - 1);

    // 打印反转后的数组
    printf("\n反转后的数组:\n");
    for (i = 0; i < N; i++) {
        printf("%d ", a[i]);
    }
    printf("\n");

    return 0;
}

 方法 4: 使用标准库函数（C99及以上）

如果使用 C99 或更高版本，可以使用 memcpy 和 memmove 函数来反转数组。

#include <stdio.h>
#include <string.h> // 包含 memcpy 和 memmove 函数
#define N 10

int main() {
    int a[N] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; // 初始化数组
    int i;

    // 打印原始数组
    printf("原始数组是:\n");
    for (i = 0; i < N; i++) {
        printf("%d ", a[i]);
    }

    // 反转数组
    for (i = 0; i < N / 2; i++) {
        // 使用 memmove 进行反转
        int temp = a[i];
        memmove(&a[i], &a[N - 1 - i], sizeof(int));
        memmove(&a[N - 1 - i], &temp, sizeof(int));
    }

    // 打印反转后的数组
    printf("\n反转后的数组:\n");
    for (i = 0; i < N; i++) {
        printf("%d ", a[i]);
    }
    printf("\n");

    return 0;
}

总结

以上是四种不同的方法来反转数组。每种方法都有其优缺点，选择哪种方法取决于具体的需求和上下文。使用辅助数组的方法简单直观，递归方法优雅而富有表现力，而使用标准库函数则可以提高代码的可读性和简洁性。

Python 实现

这个程序的功能是反转一个数组，并打印原始数组和反转后的数组。

方法 1: 交换元素

def main():
    a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]  # 初始化数组

    # 打印原始数组
    print("原始数组是:")
    print(" ".join(map(str, a)))

    # 反转数组
    for i in range(len(a) // 2):
        a[i], a[len(a) - 1 - i] = a[len(a) - 1 - i], a[i]  # 交换元素

    # 打印反转后的数组
    print("反转后的数组:")
    print(" ".join(map(str, a)))

if __name__ == "__main__":
    main()
  1. 数组初始化：数组 a 被初始化为包含 0 到 9 的整数。
  2. 打印原始数组：使用 join 和 map 函数将数组元素转换为字符串并打印。
  3. 反转数组：
    • 使用一个循环遍历数组的前半部分，将每个元素与其对应的后半部分元素交换。
    • 通过 Python 的元组解包语法来完成交换。
  4. 打印反转后的数组：再次使用 join 和 map 函数打印反转后的数组内容。

方法 2: 使用切片 

Python 的切片功能非常强大，可以用来简洁地反转数组。

def main():
    a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]  # 初始化数组

    # 打印原始数组
    print("原始数组是:")
    print(" ".join(map(str, a)))

    # 使用切片反转数组
    a = a[::-1]

    # 打印反转后的数组
    print("反转后的数组:")
    print(" ".join(map(str, a)))

if __name__ == "__main__":
    main()

方法 3: 使用 reversed() 函数

Python 提供了一个内置的 reversed() 函数，可以返回一个反转的迭代器。

def main():
    a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]  # 初始化数组

    # 打印原始数组
    print("原始数组是:")
    print(" ".join(map(str, a)))

    # 使用 reversed() 函数反转数组
    a = list(reversed(a))

    # 打印反转后的数组
    print("反转后的数组:")
    print(" ".join(map(str, a)))

if __name__ == "__main__":
    main()

方法 4: 使用 list.reverse() 方法

Python 的列表对象有一个 reverse() 方法，可以就地反转列表。

def main():
    a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]  # 初始化数组

    # 打印原始数组
    print("原始数组是:")
    print(" ".join(map(str, a)))

    # 使用 list.reverse() 方法反转数组
    a.reverse()

    # 打印反转后的数组
    print("反转后的数组:")
    print(" ".join(map(str, a)))

if __name__ == "__main__":
    main()

方法 5: 使用 for 循环和 append()

可以使用一个新的空列表，通过循环将原列表的元素反向添加到新列表中。

def main():
    a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]  # 初始化数组

    # 打印原始数组
    print("原始数组是:")
    print(" ".join(map(str, a)))

    # 使用 for 循环反转数组
    reversed_a = []
    for i in range(len(a) - 1, -1, -1):
        reversed_a.append(a[i])

    # 打印反转后的数组
    print("反转后的数组:")
    print(" ".join(map(str, reversed_a)))

if __name__ == "__main__":
    main()

总结

以上是几种不同的方法来反转数组。每种方法都有其优缺点，选择哪种方法取决于具体的需求和上下文。使用切片的方法简洁明了，reversed() 函数和 list.reverse() 方法也非常方便，而使用循环和 append() 方法则展示了更基础的操作。

Java 实现

方法 1: 交换元素

public class ReverseArray {
    public static void main(String[] args) {
        int[] a = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; // 初始化数组

        // 打印原始数组
        System.out.println("原始数组是:");
        for (int num : a) {
            System.out.print(num + " ");
        }

        // 反转数组
        for (int i = 0; i < a.length / 2; i++) {
            // 交换元素
            int temp = a[i];
            a[i] = a[a.length - 1 - i];
            a[a.length - 1 - i] = temp;
        }

        // 打印反转后的数组
        System.out.println("\n反转后的数组:");
        for (int num : a) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}
  1. 数组初始化：数组 a 被初始化为包含 0 到 9 的整数。
  2. 打印原始数组：使用增强的 for 循环打印原始数组的内容。
  3. 反转数组：
    • 使用一个循环遍历数组的前半部分，将每个元素与其对应的后半部分元素交换。
    • 通过临时变量 temp 来完成交换。
  4. 打印反转后的数组：再次使用增强的 for 循环打印反转后的数组内容。

方法 2: 使用 Collections.reverse() 方法（适用于对象数组）

如果你使用的是对象数组（例如 Integer[]），可以利用 Collections.reverse() 方法来反转数组。首先需要将数组转换为列表。

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class ReverseArray {
    public static void main(String[] args) {
        Integer[] a = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; // 使用对象数组

        // 打印原始数组
        System.out.println("原始数组是:");
        System.out.println(Arrays.toString(a));

        // 反转数组
        List<Integer> list = Arrays.asList(a);
        Collections.reverse(list);
        a = list.toArray(new Integer[0]); // 转换回数组

        // 打印反转后的数组
        System.out.println("反转后的数组:");
        System.out.println(Arrays.toString(a));
    }
}

方法 3: 使用递归方法

可以使用递归来反转数组。以下是一个简单的递归实现：

public class ReverseArray {
    public static void main(String[] args) {
        int[] a = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; // 初始化数组

        // 打印原始数组
        System.out.println("原始数组是:");
        for (int num : a) {
            System.out.print(num + " ");
        }

        // 反转数组
        reverseArray(a, 0, a.length - 1);

        // 打印反转后的数组
        System.out.println("\n反转后的数组:");
        for (int num : a) {
            System.out.print(num + " ");
        }
        System.out.println();
    }

    public static void reverseArray(int[] arr, int start, int end) {
        if (start >= end) {
            return; // 基本情况
        }
        // 交换元素
        int temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;

        // 递归调用
        reverseArray(arr, start + 1, end - 1);
    }
}

方法 4: 使用 Java 8 的流（Streams）

如果你使用的是 Java 8 或更高版本，可以利用流来反转数组：

import java.util.Arrays;
import java.util.Collections;

public class ReverseArray {
    public static void main(String[] args) {
        int[] a = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; // 初始化数组

        // 打印原始数组
        System.out.println("原始数组是:");
        System.out.println(Arrays.toString(a));

        // 反转数组
        int[] reversedArray = Arrays.stream(a)
                .boxed() // 转换为流对象
                .sorted(Collections.reverseOrder()) // 反转排序
                .mapToInt(Integer::intValue) // 转换回基本类型
                .toArray();

        // 打印反转后的数组
        System.out.println("反转后的数组:");
        System.out.println(Arrays.toString(reversedArray));
    }
}

Js 实现

以下是一个使用 JavaScript 实现的示例，展示了如何反转一个数组并打印原始和反转后的数组：

// 初始化数组
const a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

// 打印原始数组
console.log("原始数组是:", a);

// 反转数组
const reversedArray = a.slice().reverse(); // 使用 slice() 创建数组的副本并反转

// 打印反转后的数组
console.log("反转后的数组:", reversedArray);
  1. 初始化数组：我们创建了一个包含数字的数组 a。
  2. 打印原始数组：使用 console.log 打印原始数组。
  3. 反转数组：
    • a.slice() 创建了数组 a 的一个副本，以避免直接修改原始数组。
    • reverse() 方法反转了这个副本。
  4. 打印反转后的数组：使用 console.log 打印反转后的数组。

http://www.kler.cn/a/420638.html

相关文章：

  • 非标自动化行业ERP选型与案例展示！
  • SpringBoot3.4.0和OpenFeign4.1.4不兼容
  • 开源ISP介绍（1）——开源ISP的Vivado框架搭建
  • 在21世纪的我用C语言探寻世界本质——字符函数和字符串函数(2)
  • 【C++】STL——map和set
  • mysql一个事务最少几次IO操作
  • 【SQL】实战--组合两个表
  • 一、文本预处理
  • mysql order by后进行limit分页查询出现重复数据
  • shell脚本30个案例（五）
  • Spring AI 框架介绍
  • WuCup网络安全技能大赛WP
  • Java 单例模式：深度解析与应用
  • mysql线上问题集合
  • Stable Diffusion 3 论文
  • 淘宝商品数据获取：Python爬虫技术的应用与实践
  • 大数据营销
  • Flink四大基石之窗口（Window）使用详解
  • 如何实现人机环境之间动态交互的事实与价值编排组合
  • 前端面试热门题（二）[html\css\js\node\vue)
  • Docker 容器隔离关键技术：SELinux
  • el-table 组件二次封装（vue2）
  • 【MATLAB源码-第230期】基于matlab的32QAM系统相位偏移估计HOS算法仿真，对比补偿前后的星座图误码率。
  • 机器学习算法（六）---逻辑回归
  • Qt Serial Bus 前置介绍篇
  • ​导游|基于SprinBoot+vue的在线预约导游系统