常用排序算法脚本实现

冒泡排序

 

Public Sub BubbleSort(ByRef foldArray() As String)
    Dim iOuter As Long
    Dim iInner As Long
    Dim iLBound As Long
    Dim iUBound As Long
    Dim iTemp As Long

    iLBound = LBound(lngArray)
    iUBound = UBound(lngArray)

    For iOuter = iLBound To iUBound - 1
        For iInner = iLBound To iUBound - iOuter - 1
            If lngArray(iInner) < foldArray(iInner + 1) Then
                iTemp = lngArray(iInner)
                foldArray(iInner) = foldArray(iInner + 1)
                foldArray(iInner + 1) = iTemp
            End If
        Next iInner
    Next iOuter
End Sub

 

def bubble_sort(sort_list):
    iter_len = len(sort_list)
    if iter_len < 2:
        return sort_list
    for i in range(iter_len-1):
        for j in range(iter_len-i-1):
            if sort_list[j] > sort_list[j+1]:
                sort_list[j], sort_list[j+1] = sort_list[j+1], sort_list[j]
    return sort_list
 

选择排序

 

Public Sub SelectionSort(ByRef lngArray() As Long)
    Dim iOuter As Long
    Dim iInner As Long
    Dim iLBound As Long
    Dim iUBound As Long
    Dim iTemp As Long
    Dim iLocation As Long

    iLBound = LBound(lngArray)
    iUBound = UBound(lngArray)

    For iOuter = iLBound To iUBound - 1
        iLocation = iOuter
        For iInner = iOuter To iUBound
            If lngArray(iInner) > lngArray(iLocation) Then iLocation = iInner
        Next iInner
        
        If iLocation <> iOuter Then
            iTemp = lngArray(iLocation)
            lngArray(iLocation) = lngArray(iOuter)
            lngArray(iOuter) = iTemp
        End If
    Next iOuter
End Sub

 

def selection_sort(sort_list):
    iter_len = len(sort_list)
    if iter_len < 2:
        return sort_list
    for i in range(iter_len-1):
        smallest = sort_list[i]
        location = i
        for j in range(i, iter_len):
            if sort_list[j] < smallest:
                smallest = sort_list[j]
                location = j
        if i != location:
            sort_list[i], sort_list[location] = sort_list[location], sort_list[i]
    return sort_list
 

插入排序

 

Public Sub InsertSort(ByRef lngArray() As Long)
    Dim iOuter As Long
    Dim iInner As Long
    Dim iLBound As Long
    Dim iUBound As Long
    Dim iTemp As Long
    
    iLBound = LBound(lngArray)
    iUBound = UBound(lngArray)
    
    For iOuter = iLBound + 1 To iUBound
        iTemp = lngArray(iOuter)
        
        For iInner = iOuter - 1 To iLBound Step -1
            If lngArray(iInner) >= iTemp Then Exit For
            lngArray(iInner + 1) = lngArray(iInner)
        Next iInner
        
        lngArray(iInner + 1) = iTemp
    Next iOuter
End Sub

 

def insertion_sort(sort_list):
    iter_len = len(sort_list)
    if iter_len < 2:
        return sort_list
    for i in range(1, iter_len):
        key = sort_list[i]
        j = i - 1
        while j>=0 and sort_list[j]>key:
            sort_list[j+1] = sort_list[j]
            j -= 1
        sort_list[j+1] = key
    return sort_list
 

 

 

 

 

 

 

 

 

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
好的,我可以为你介绍一些常见的排序算法实现,使用shell脚本来进行排序。 1. 冒泡排序 冒泡排序是一种简单的排序算法,它重复地遍历要排序的列表,比较每对相邻的项,并在必要时交换它们的位置。 以下是冒泡排序的shell脚本实现: ```bash #!/bin/bash # 冒泡排序 function bubble_sort() { local arr=("$@") local len=${#arr[@]} for ((i=0; i<$len-1; i++)); do for ((j=0; j<$len-i-1; j++)); do if [[ ${arr[$j]} -gt ${arr[$j+1]} ]]; then local temp=${arr[$j+1]} arr[$j+1]=${arr[$j]} arr[$j]=$temp fi done done echo "${arr[@]}" } # 测试 arr=(2 1 5 4 3) echo "排序前:${arr[@]}" arr_sorted=($(bubble_sort "${arr[@]}")) echo "排序后:${arr_sorted[@]}" ``` 2. 插入排序 插入排序是一种简单直观的排序算法。它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。 以下是插入排序的shell脚本实现: ```bash #!/bin/bash # 插入排序 function insertion_sort() { local arr=("$@") local len=${#arr[@]} for ((i=1; i<$len; i++)); do local temp=${arr[$i]} local j=$i while ((j>0 && arr[j-1] > temp)); do arr[$j]=${arr[$j-1]} ((j--)) done arr[$j]=$temp done echo "${arr[@]}" } # 测试 arr=(2 1 5 4 3) echo "排序前:${arr[@]}" arr_sorted=($(insertion_sort "${arr[@]}")) echo "排序后:${arr_sorted[@]}" ``` 3. 快速排序 快速排序是一种常用排序算法,采用分治的思想。它的基本思想是通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列的目的。 以下是快速排序的shell脚本实现: ```bash #!/bin/bash # 快速排序 function quick_sort() { local arr=("$@") local len=${#arr[@]} if [[ $len -le 1 ]]; then echo "${arr[@]}" return fi local pivot=${arr[0]} local left=() local right=() for ((i=1; i<$len; i++)); do if [[ ${arr[$i]} -lt $pivot ]]; then left+=(${arr[$i]}) else right+=(${arr[$i]}) fi done echo "$(quick_sort "${left[@]}") $pivot $(quick_sort "${right[@]}")" } # 测试 arr=(2 1 5 4 3) echo "排序前:${arr[@]}" arr_sorted=($(quick_sort "${arr[@]}")) echo "排序后:${arr_sorted[@]}" ``` 以上是三种常见的排序算法的shell脚本实现,可以根据需要选择适合的算法来进行排序

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值