Perl基本数组排序方法介绍

2023-12-30 15:54:53

六种基本排序算法简介

在计算机科学的浩瀚世界中，排序算法扮演着至关重要的角色。它能够将一组数据按照特定的顺序排列，让数据分析和处理变得轻而易举。在Perl语言中，内建的sort()函数为我们提供了强大的排序能力，让处理数组变得轻而易举。

排序算法的类型

排序算法五花八门，各有千秋，针对不同的数据结构和应用场景，选择合适的算法至关重要。下面我们逐一介绍六种基础且实用的排序算法。

冒泡排序

冒泡排序，顾名思义，就像泡泡一样，将最大的元素逐步“浮”到数组末尾。它通过不断比较相邻元素，将较大的元素向后移动一位，直到数组有序。虽然直观易懂，但冒泡排序的时间复杂度为O(n^2)，不适合处理大规模数据。

sub bubble_sort {
    my @arr = @_;
    my $len = scalar @arr;

    for (my $i = 0; $i < $len - 1; $i++) {
        for (my $j = 0; $j < $len - 1 - $i; $j++) {
            if ($arr[$j] > $arr[$j + 1]) {
                my $temp = $arr[$j];
                $arr[$j] = $arr[$j + 1];
                $arr[$j + 1] = $temp;
            }
        }
    }

    return @arr;
}

选择排序

选择排序，如同其名，依次找出数组中的最小（或最大）元素，并将其与数组首位交换。这种逐个选取的方式，使其平均时间复杂度同样为O(n^2)，也适用于小规模数据集。

sub selection_sort {
    my @arr = @_;
    my $len = scalar @arr;

    for (my $i = 0; $i < $len - 1; $i++) {
        my $min_index = $i;
        for (my $j = $i + 1; $j < $len; $j++) {
            if ($arr[$j] < $arr[$min_index]) {
                $min_index = $j;
            }
        }

        my $temp = $arr[$i];
        $arr[$i] = $arr[$min_index];
        $arr[$min_index] = $temp;
    }

    return @arr;
}

插入排序

插入排序，如同插入一个新元素到已排序数组中一样，将每个元素依次插入到有序子数组中。这种插入的方式，使得其时间复杂度为O(n^2)，但对于基本有序的数组，其效率将显著提升。

sub insertion_sort {
    my @arr = @_;
    my $len = scalar @arr;

    for (my $i = 1; $i < $len; $i++) {
        my $key = $arr[$i];
        my $j = $i - 1;

        while ($j >= 0 && $key < $arr[$j]) {
            $arr[$j + 1] = $arr[$j];
            $j--;
        }

        $arr[$j + 1] = $key;
    }

    return @arr;
}

快速排序

快速排序，如同其名，通过分治法将数组划分为两个子数组，子数组中分别包含比基准值小的元素和比基准值大的元素。这种分而治之的方式，使其平均时间复杂度为O(n log n)，效率极高。

sub quick_sort {
    my @arr = @_;
    my $len = scalar @arr;

    return @arr if $len <= 1;

    my $pivot = $arr[int(rand($len))];
    my @left;
    my @right;

    for (my $i = 0; $i < $len; $i++) {
        if ($arr[$i] < $pivot) {
            push @left, $arr[$i];
        } elsif ($arr[$i] > $pivot) {
            push @right, $arr[$i];
        }
    }

    return (quick_sort(@left), $pivot, quick_sort(@right));
}

归并排序

归并排序，同样采用分治法，将数组一分为二，并递归地对两个子数组进行排序。然后，将排好序的子数组合并成一个排序后的数组。这种分治合并的方式，使其时间复杂度稳定为O(n log n)，即使数组基本有序也不例外。

sub merge_sort {
    my @arr = @_;
    my $len = scalar @arr;

    return @arr if $len <= 1;

    my $mid = int($len / 2);
    my @left = merge_sort(@arr[0 .. $mid - 1]);
    my @right = merge_sort(@arr[$mid .. $len - 1]);

    return merge(@left, @right);
}

sub merge {
    my @left = @_[0];
    my @right = @_[1];
    my @merged;

    while (@left && @right) {
        if ($left[0] <= $right[0]) {
            push @merged, shift @left;
        } else {
            push @merged, shift @right;
        }
    }

    push @merged, @left, @right;

    return @merged;
}

堆排序

堆排序，通过将数组构建成一个堆数据结构，然后依次从堆中弹出最大元素，并将其插入到数组末尾。这种堆的特性，使其时间复杂度稳定为O(n log n)，但在处理几乎有序的数据时，效率会略有下降。

sub heap_sort {
    my @arr = @_;
    my $len = scalar @arr;

    build_max_heap(\@arr, $len);

    for (my $i = $len - 1; $i >= 0; $i--) {
        my $temp = $arr[0];
        $arr[0] = $arr[$i];
        $arr[$i] = $temp;

        heapify(\@arr, 0, $i);
    }

    return @arr;
}

sub build_max_heap {
    my $arr_ref = $_[0];
    my $len = $_[1];

    for (my $i = int($len / 2) - 1; $i >= 0; $i--) {
        heapify($arr_ref, $i, $len);
    }
}

sub heapify {
    my $arr_ref = $_[0];
    my $i = $_[1];
    my $len = $_[2];

    my $left = 2 * $i + 1;
    my $right = 2 * $i + 2;
    my $largest = $i;

    if ($left < $len && $arr_ref->[$left] > $arr_ref->[$largest]) {
        $largest = $left;
    }

    if ($right < $len && $arr_ref->[$right] > $arr_ref->[$largest]) {
        $largest = $right;
    }

    if ($largest != $i) {
        my $temp = $arr_ref->[$i];
        $arr_ref->[$i] = $arr_ref->[$largest];
        $arr_ref->[$largest] = $temp;

        heapify($arr_ref, $largest, $len);
    }
}

比较与总结

以下表格对六种排序算法的时间复杂度和稳定性进行比较：

算法	平均时间复杂度	最坏情况下的时间复杂度	稳定性
冒泡排序	O(n^2)	O(n^2)	否
选择排序	O(n^2)	O(n^2)	否
插入排序	O(n^2)	O(n^2)	是
快速排序	O(n log n)	O(n^2)	否
归并排序	O(n log n)	O(n log n)	是
堆排序	O(n log n)	O(n log n)	否