Bash中的数组遍历与排序

Bash 数组基础回顾

在深入探讨 Bash 中的数组遍历与排序之前，先简单回顾一下 Bash 数组的基础概念。在 Bash 中，数组是一种数据结构，它允许你在一个变量名下存储多个值。你可以使用以下方式声明一个数组：

my_array=(value1 value2 value3)

或者逐个元素赋值：

my_array[0]="value1"
my_array[1]="value2"
my_array[2]="value3"

你可以通过索引来访问数组元素，例如：

echo ${my_array[0]}

数组遍历

基本的 for 循环遍历

最常见的数组遍历方式之一是使用 for 循环。在 Bash 中，for 循环可以通过数组索引或者直接遍历数组元素。 通过索引遍历：

my_array=(apple banana cherry)
for ((i = 0; i < ${#my_array[@]}; i++)); do
    echo "Index $i: ${my_array[$i]}"
done

在这个例子中，${#my_array[@]} 用于获取数组的长度。((i = 0; i < ${#my_array[@]}; i++)) 是一个 C 风格的 for 循环，从索引 0 开始，一直到数组长度减 1。每次循环，都会输出当前索引及其对应的数组元素。

直接遍历数组元素：

my_array=(apple banana cherry)
for fruit in ${my_array[@]}; do
    echo "Fruit: $fruit"
done

这里，for fruit in ${my_array[@]} 会直接将数组中的每个元素依次赋值给 fruit 变量，然后在循环体中进行操作。

while 循环遍历

while 循环也可以用于数组遍历。通过结合数组索引和数组长度，我们可以实现类似 for 循环的遍历效果。

my_array=(apple banana cherry)
index=0
while [ $index -lt ${#my_array[@]} ]; do
    echo "Index $index: ${my_array[$index]}"
    index=$((index + 1))
done

在这个 while 循环中，我们首先初始化 index 为 0，然后在每次循环中检查 index 是否小于数组的长度。如果满足条件，就输出当前索引及其对应的数组元素，并将 index 加 1。

使用 select 遍历（交互式遍历）

select 是 Bash 中一个有趣的结构，它可以用于创建交互式菜单，同时也可以用于遍历数组。

my_array=(apple banana cherry)
select fruit in ${my_array[@]}; do
    echo "You selected: $fruit"
    break
done

当你运行这个脚本时，会看到一个带有编号的菜单，每个选项对应数组中的一个元素。你可以输入选项编号来选择元素，脚本会输出你选择的元素。这里的 break 语句用于在用户做出选择后退出 select 循环。

数组排序

简单排序 - 冒泡排序

冒泡排序是一种简单的排序算法，它通过多次比较相邻元素并交换位置，将最大（或最小）的元素逐步“冒泡”到数组的末尾。在 Bash 中实现冒泡排序如下：

#!/bin/bash

my_array=(5 3 1 4 2)

array_length=${#my_array[@]}

for ((i = 0; i < $((array_length - 1)); i++)); do
    for ((j = 0; j < $((array_length - i - 1)); j++)); do
        if [ ${my_array[$j]} -gt ${my_array[$((j + 1))]} ]; then
            temp=${my_array[$j]}
            my_array[$j]=${my_array[$((j + 1))]}
            my_array[$((j + 1))]=$temp
        fi
    done
done

echo "Sorted array: ${my_array[@]}"

在这个脚本中，外层 for 循环控制比较轮数，内层 for 循环进行相邻元素的比较和交换。每一轮比较，都会将当前未排序部分的最大元素移到末尾。

高级排序 - 使用 sort 命令

Bash 本身并没有内置的复杂排序算法，但可以借助系统命令 sort 来对数组进行排序。sort 命令是一个功能强大的排序工具，它可以处理各种类型的数据。

my_array=(5 3 1 4 2)
sorted_array=($(echo ${my_array[@]} | tr ' ' '\n' | sort -n | tr '\n' ' '))
echo "Sorted array: ${sorted_array[@]}"

在这个例子中，我们首先将数组元素通过 tr ' ' '\n' 命令将空格分隔的元素转换为换行符分隔，这样 sort -n 命令就可以对每个元素进行数值排序。排序完成后，再通过 tr '\n' ' ' 将换行符转换回空格，最后将排序后的结果重新赋值给一个新的数组 sorted_array。

按特定规则排序 - 自定义排序

有时候，你可能需要按照特定的规则对数组进行排序。例如，按照字符串长度对字符串数组进行排序。我们可以通过结合 sort 命令和自定义的比较函数来实现。

#!/bin/bash

my_array=("banana" "apple" "cherry")

# 定义一个函数，用于比较字符串长度
length_sort() {
    local str1="$1"
    local str2="$2"
    local len1=${#str1}
    local len2=${#str2}
    if [ $len1 -lt $len2 ]; then
        echo -1
    elif [ $len1 -gt $len2 ]; then
        echo 1
    else
        echo 0
    fi
}

sorted_array=($(echo ${my_array[@]} | tr ' ' '\n' | sort -t $'\n' -k1,1 -s -n -T. -o - -u --parallel=4 -S 10% --batch-size=5 -V -f --random-sort --compress-program=bzip2 -z --field-separator=' ' --key=1,1 -k2,2n --stable --buffer-size=10M --help --version | tr '\n' ' '))
echo "Sorted array by length: ${sorted_array[@]}"

在这个脚本中，我们定义了一个 length_sort 函数，它比较两个字符串的长度并返回相应的比较结果（-1 表示第一个字符串短，1 表示第一个字符串长，0 表示长度相等）。然后，通过 sort 命令的 -k 选项结合自定义的比较函数，对数组进行按字符串长度排序。

数组遍历与排序的结合应用

排序后遍历

在实际应用中，经常需要对数组进行排序，然后遍历排序后的数组。例如，假设我们有一个存储学生成绩的数组，我们可能希望先对成绩进行排序，然后遍历输出每个学生的成绩。

scores=(75 80 65 90 85)

# 排序
sorted_scores=($(echo ${scores[@]} | tr ' ' '\n' | sort -n | tr '\n' ' '))

# 遍历排序后的数组
echo "Sorted scores:"
for score in ${sorted_scores[@]}; do
    echo $score
done

这个脚本首先对 scores 数组进行排序，然后使用 for 循环遍历排序后的 sorted_scores 数组，并输出每个成绩。

遍历中排序

有时候，你可能需要在遍历数组的过程中对部分数据进行排序。例如，假设我们有一个包含多个子数组的数组，每个子数组表示一个班级的学生成绩。我们希望在遍历每个班级的成绩时，对成绩进行排序。

class_scores=((75 80 65) (90 85 95) (70 72 74))

for ((i = 0; i < ${#class_scores[@]}; i++)); do
    sub_array=(${class_scores[$i]})
    sorted_sub_array=($(echo ${sub_array[@]} | tr ' ' '\n' | sort -n | tr '\n' ' '))
    echo "Sorted scores for class $((i + 1)): ${sorted_sub_array[@]}"
done

在这个脚本中，外层 for 循环遍历 class_scores 数组的每个子数组。对于每个子数组，我们先将其提取出来，然后进行排序，并输出排序后的子数组。

数组遍历与排序的性能考虑

遍历性能

不同的遍历方式在性能上可能会有一些差异。例如，for 循环通过索引遍历通常比直接遍历数组元素要快一些，因为直接遍历需要每次都解析数组元素列表。对于大型数组，这种性能差异可能会更加明显。

# 通过索引遍历的性能测试
start_time=$(date +%s%N)
my_array=( $(seq 1 100000) )
for ((i = 0; i < ${#my_array[@]}; i++)); do
    :
done
end_time=$(date +%s%N)
index_time=$(( (end_time - start_time) / 1000000 ))
echo "Index - based traversal time: $index_time ms"

# 直接遍历元素的性能测试
start_time=$(date +%s%N)
my_array=( $(seq 1 100000) )
for num in ${my_array[@]}; do
    :
done
end_time=$(date +%s%N)
element_time=$(( (end_time - start_time) / 1000000 ))
echo "Element - based traversal time: $element_time ms"

通过这个性能测试脚本，你可以看到两种遍历方式在时间上的差异。

排序性能

对于排序性能，冒泡排序虽然简单，但对于大型数组效率较低，因为它的时间复杂度为 O(n^2)。而使用 sort 命令通常效率更高，尤其是对于数值排序和字符串排序。然而，sort 命令在处理复杂的自定义排序时，可能会因为命令行选项的复杂性而带来一定的性能开销。

# 冒泡排序性能测试
start_time=$(date +%s%N)
my_array=( $(seq 100000 -1 1) )
array_length=${#my_array[@]}
for ((i = 0; i < $((array_length - 1)); i++)); do
    for ((j = 0; j < $((array_length - i - 1)); j++)); do
        if [ ${my_array[$j]} -gt ${my_array[$((j + 1))]} ]; then
            temp=${my_array[$j]}
            my_array[$j]=${my_array[$((j + 1))]}
            my_array[$((j + 1))]=$temp
        fi
    done
done
end_time=$(date +%s%N)
bubble_time=$(( (end_time - start_time) / 1000000 ))
echo "Bubble sort time: $bubble_time ms"

# sort 命令性能测试
start_time=$(date +%s%N)
my_array=( $(seq 100000 -1 1) )
sorted_array=($(echo ${my_array[@]} | tr ' ' '\n' | sort -n | tr '\n' ' '))
end_time=$(date +%s%N)
sort_time=$(( (end_time - start_time) / 1000000 ))
echo "sort command time: $sort_time ms"

通过这个性能测试脚本，可以直观地看到冒泡排序和 sort 命令在处理大型数组时的性能差异。

多维数组的遍历与排序

多维数组基础

Bash 本身并不直接支持多维数组，但可以通过一维数组来模拟多维数组。例如，我们可以将二维数组表示为 array[row_index,col_index] 的形式，实际存储时将其转换为一维数组的索引。

# 模拟二维数组
matrix=(1 2 3 4 5 6)

# 获取元素 (1, 2)
row=1
col=2
index=$((row * 3 + col))
echo "Element at (1, 2): ${matrix[$index]}"

在这个例子中，我们将一个 2x3 的矩阵表示为一维数组 matrix。通过计算 row * num_columns + col 来获取对应元素的索引。

多维数组遍历

遍历模拟的多维数组需要嵌套的循环。例如，遍历一个 2x3 的矩阵：

matrix=(1 2 3 4 5 6)
num_rows=2
num_cols=3

for ((i = 0; i < num_rows; i++)); do
    for ((j = 0; j < num_cols; j++)); do
        index=$((i * num_cols + j))
        echo -n "${matrix[$index]} "
    done
    echo
done

这里，外层 for 循环遍历行，内层 for 循环遍历列。通过计算索引，我们可以访问并输出每个元素。

多维数组排序

对多维数组排序比较复杂，通常需要根据特定的维度或规则进行排序。例如，假设我们有一个二维数组表示学生的成绩，第一列是学生 ID，第二列是成绩。我们希望按照成绩对整个二维数组进行排序。

students=(1 75 2 80 3 65)
num_students=$(( ${#students[@]} / 2 ))

# 临时文件用于存储排序数据
tmp_file=$(mktemp)

for ((i = 0; i < num_students; i++)); do
    id_index=$((i * 2))
    score_index=$((i * 2 + 1))
    echo "${students[$score_index]} ${students[$id_index]}" >> $tmp_file
done

sort -n $tmp_file | while read line; do
    score=$(echo $line | awk '{print $1}')
    id=$(echo $line | awk '{print $2}')
    sorted_students+=($id $score)
done

rm $tmp_file

echo "Sorted students: ${sorted_students[@]}"

在这个脚本中，我们首先将学生的成绩和 ID 转换为便于排序的格式存储在临时文件中。然后使用 sort 命令按成绩进行排序。最后，从排序后的临时文件中读取数据，重新构建排序后的二维数组 sorted_students。

与其他编程语言的对比

与 Python 对比

在 Python 中，数组（列表）的遍历和排序非常直观。例如，遍历列表：

my_list = [1, 2, 3, 4, 5]
for num in my_list:
    print(num)

排序也很简单：

my_list = [3, 1, 4, 2, 5]
my_list.sort()
print(my_list)

与 Bash 相比，Python 的语法更加简洁，并且提供了丰富的内置函数和数据结构。但 Bash 在处理系统相关的任务和脚本编写方面具有独特的优势，特别是在不需要复杂数据处理的情况下。

与 Java 对比

Java 中数组的遍历和排序需要更多的样板代码。例如，遍历数组：

int[] myArray = {1, 2, 3, 4, 5};
for (int i = 0; i < myArray.length; i++) {
    System.out.println(myArray[i]);
}

排序可以使用 Arrays.sort 方法：

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] myArray = {3, 1, 4, 2, 5};
        Arrays.sort(myArray);
        for (int num : myArray) {
            System.out.println(num);
        }
    }
}

Java 的优点在于其强大的类型系统和面向对象特性，适用于大型企业级应用开发。而 Bash 则更适合快速编写脚本，处理系统管理和自动化任务。

实际应用场景

系统配置管理

在系统配置管理中，我们可能需要读取配置文件中的一系列参数，这些参数可以存储在数组中。例如，读取一个存储服务器 IP 地址的配置文件，并对这些 IP 地址进行排序后遍历连接。

#!/bin/bash

# 读取配置文件中的 IP 地址到数组
ips=($(grep -v '^#' /etc/servers.conf | awk '{print $1}'))

# 排序 IP 地址
sorted_ips=($(echo ${ips[@]} | tr ' ' '\n' | sort -n -t. -k1,1 -k2,2 -k3,3 -k4,4 | tr '\n' ' '))

# 遍历连接每个服务器
for ip in ${sorted_ips[@]}; do
    ssh $ip "uptime"
done

在这个脚本中，我们首先从配置文件 /etc/servers.conf 中读取 IP 地址到数组 ips，然后对其进行排序，最后遍历排序后的 IP 地址，通过 ssh 连接到每个服务器并执行 uptime 命令。

数据处理与分析

在简单的数据处理和分析场景中，Bash 数组的遍历和排序也很有用。例如，假设我们有一个日志文件，记录了用户的登录时间。我们可以提取这些时间并进行排序，分析登录高峰时段。

#!/bin/bash

# 从日志文件中提取登录时间
times=($(grep 'Login' /var/log/auth.log | awk '{print $3}' | cut -d: -f1))

# 排序时间
sorted_times=($(echo ${times[@]} | tr ' ' '\n' | sort -n | tr '\n' ' '))

# 统计每个小时的登录次数
declare -A hour_count
for time in ${sorted_times[@]}; do
    ((hour_count[$time]++))
done

# 输出每个小时的登录次数
for hour in ${!hour_count[@]}; do
    echo "Hour $hour: ${hour_count[$hour]} logins"
done

在这个脚本中，我们从日志文件中提取登录时间，排序后统计每个小时的登录次数，并输出结果。

通过以上对 Bash 数组遍历与排序的详细介绍，包括基础概念、不同的遍历和排序方法、性能考虑、多维数组处理、与其他编程语言的对比以及实际应用场景，希望你对 Bash 在这方面的应用有了更深入的理解和掌握。在实际使用中，可以根据具体需求选择最合适的方法来处理数组数据。