1. Toy模板网首页
  2. > Toy博客

shell数组（包含排序算法）

9月前 作者：努力拱破蛋壳的猪 分类：Toy博客 阅读(71) 违法举报

这篇具有很好参考价值的文章主要介绍了shell数组（包含排序算法）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

目录

一：数组定义方法

1、方法一

2、方法二

​3、方法三

​4、方法四

 5、判断数组是否完整

（1）方法一

（2）方法二：通过脚本

二：获取数组值

1、获取数组长度

 2、获取数组数据列表

3、获取数组下标列表

4、读取某下标赋值

​5、数组遍历

 6、求数组所有的数值的和

三：数组值的改变

1、数组切片

2、数组替换

（1）临时替换，数组根本不会替换

​（2）永久替换需重新赋值

3、数组删除--unset

4、数组追加元素

（1）方法一

 （2）方法二

​（3）方法三

​（4）方法四

 四：数组传参

1、数组传参

2.、从函数返回数组

 五:数组排序算法

1、冒泡排序介绍

​ 2.、冒泡排序事例

3.直接选择排序介绍

 ​4.直接选择排序事例

 5.插入排序介绍

6. 插入排序事例

 7.反转排序介绍

8.反转排序事例

9. 睡眠排序

10.希尔排序介绍

11. 希尔排序事例

一：数组定义方法

1、方法一

数组名=（value0 value1 value2…）

 2、方法二

数组名=（[0]=value [1]=value [2]=value…）

3、方法三

数组名=“value0 value1 value2…”

数组名=（$列表名）

4、方法四

数组名[0]=“value”

 数组名[1]=“value”

数组名[2]=“value”

数组名[3]=“value”


shell数组（包含排序算法）

 5、判断数组是否完整

思路：通过数组最后一位与列表最后一位进行比对

（1）方法一

shell数组（包含排序算法）

（2）方法二：通过脚本

[root@localhost ~]# vim test.sh

#!/bin/bash
a5=([0]=10 [1]=20 [3]=40 [4]=50)                  #定义数组
length=${#a5[@]}                                  #定义数组的长度
lastnum=$[length - 1]                             #定义最后一位数的下标，长度减一
lastone=${a5[$lastnum]}                           #定义下标
curlast=$(echo ${a5[@]} | awk '{print $NF}')      #定义最后一个字段

echo "a5数组的值为：${a5[@]}"

if [ $lastone -eq $curlast ];then                 #判断最后一位数值是否相等
   echo "a5数组是完整的！"                        #相等则输出完整
else
   echo "a5数组缺失元素！"                        #不相等则输出缺失
fi

shell数组（包含排序算法）

 shell数组（包含排序算法）

二：获取数组值

1、获取数组长度

[root@localhost ~]# echo ${a1[@]} 
10 20 30 40 50 60
[root@localhost ~]# echo ${#a1[@]} 
6
[root@localhost ~]# echo ${#a1[*]} 
6

shell数组（包含排序算法）

 2、获取数组数据列表

[root@localhost ~]# echo ${a1[*]} 
10 20 30 40 50 60
[root@localhost ~]# echo ${a1[@]} 
10 20 30 40 50 60

shell数组（包含排序算法）

3、获取数组下标列表

[root@localhost ~]# echo ${!a1[@]} 
0 1 2 3 4 5

 shell数组（包含排序算法）

4、读取某下标赋值

[root@localhost ~]# echo ${a1[@]} 
10 20 30 40 50 60
[root@localhost ~]# bl=${a1[3]}
[root@localhost ~]# echo $bl
40

 5、数组遍历

[root@localhost ~]# for i in ${a1[@]}
> do
> echo $i
> done
10
20
30
40
50
60

shell数组（包含排序算法）

 6、求数组所有的数值的和

[root@localhost ~]# for i in ${a1[@]}
> do
> sum=$[sum + i]
> done
[root@localhost ~]# echo $sum
210

shell数组（包含排序算法）

三：数组值的改变

1、数组切片

[root@localhost ~]# echo ${a1[@]} 
10 20 30 40 50 60
[root@localhost ~]# echo ${a1[@]:0:2}      #0为第一下标位，2为长度，2个字符
10 20
[root@localhost ~]# echo ${a1[*]:3:3}      #3为第三下表位，3为长度，3个字符
40 50 60

shell数组（包含排序算法）

2、数组替换

（1）临时替换，数组根本不会替换

[root@localhost ~]# echo ${a1[@]} 
10 20 30 40 50 60
[root@localhost ~]# echo ${a1[@]/30/100} 
10 20 100 40 50 60
[root@localhost ~]# echo ${a1[@]} 
10 20 30 40 50 60
[root@localhost ~]# echo ${a1[@]/0/5} 
15 25 35 45 55 65
[root@localhost ~]# echo ${a1[@]} 
10 20 30 40 50 60

shell数组（包含排序算法） （2）永久替换需重新赋值

[root@localhost ~]# a6=(10 20 30 40 50 100)
[root@localhost ~]# echo ${a6[@]}
10 20 30 40 50 100
[root@localhost ~]# b1=${a6[@]/10/60}    #将原数组的数据替换重新赋值一个新变量 
[root@localhost ~]# echo ${b1[@]}
60 20 30 40 50 600                       #100会认为10和0，所有也会替换

shell数组（包含排序算法）

3、数组删除--unset

[root@localhost ~]# echo ${a1[@]} 
10 20 30 40 50 60
[root@localhost ~]# unset a1[3]                  #删除数组下标位3的数值
[root@localhost ~]# echo ${a1[@]}
10 20 30 50 60
[root@localhost ~]# unset a1                     #删除数组
[root@localhost ~]# echo ${a1[@]}

shell数组（包含排序算法）

4、数组追加元素

（1）方法一

格式：数组名[下标位]=元素值

[root@localhost ~]# echo ${a2[@]}
20 30 50 10 40
[root@localhost ~]# a2[5]=77
[root@localhost ~]# echo ${a2[@]}
20 30 50 10 40 77

shell数组（包含排序算法）

 （2）方法二

格式：数组名[${数组名[@]}]=数值

[root@localhost ~]# echo ${a2[@]}
20 30 50 10 40 77
[root@localhost ~]# a2[${#a2[@]}]=88
[root@localhost ~]# echo ${a2[@]}
20 30 50 10 40 77 88

数组完整时，会在数组最后一位追加

shell数组（包含排序算法）

数组不完整时，会替换最后一位数值 

shell数组（包含排序算法） （3）方法三

格式：数组名=（"${数组名[@]}" 元素值 ...）

注:双引号不能省略，否则，当数组中存在空格的元素时会按空格将元素拆分成多个

不能将“@”替换成“*”，如果替换为“*”，不加双引号时与“@”的表现一致，加双引号时，会将数组中的所有元素作为一个元素添加到数组中。

单引号时 

shell数组（包含排序算法）

双引号时

shell数组（包含排序算法） （4）方法四

格式：数组名+=（"元素名" "元素名"）

shell数组（包含排序算法）

 四：数组传参

1、数组传参

[root@localhost ~]# vim abc.sh

#!/bin/bash

test() {
   one=($@)
   echo "函数内的数组的元素列表为：${one[@]}"
   echo $1
   echo $2
   echo $3
   echo $4
   echo $5
}


two=(11 22 33 44 55)
echo "函数外的数组的元素列表为：${two[@]}"

test ${two[@]}

shell数组（包含排序算法）

2.、从函数返回数组

[root@localhost ~]# vim acc.sh

#!/bin/bash

test1() {
    one=($@)                              #函数内的数组的元素列表为${one[@]}
    for ((i=0;i<${#one[@]};i++))          #i小于${one[@]}所包含的数值个数，循环一次自加一
    do
      one[$i]=$[2 * ${one[$i]}]           #定义新的数组值为原来数组值的2倍
    done
     echo ${one[@]}
}


two=(11 22 33 44 55)
echo "函数体外的数组的元素列表为：${two[@]}"

arr=($(test1 ${two[@]}))                  #调用函数
echo "新的数组值为：${arr[@]}"

 shell数组（包含排序算法）

 五:数组排序算法

1、冒泡排序介绍

冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

运行流程：

比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

shell数组（包含排序算法）

shell数组（包含排序算法）

 2.、冒泡排序事例

[root@localhost ~]# vim mpao.sh
#！/bin/bash
MAOPAO(){
arr=($@)
#获取数组的长度
length=${#arr[@]}

#外层循环用来定义比较轮数，比较轮数为数组长度减1，且从1开始
for ((a=1;a<length;a++));do
  #内层循环用来确定比较元素的位置，比较相邻两个元素，较大的元素往后移，并且比较次数会随着比较轮数的增加而减少
  for ((b=0;b<length-a;b++));do
    #获取相邻两个元素的前面元素的值
    first=${arr[$b]}
    #获取相邻两个元素的后面元素的值
    c=$[b + 1]
    second=${arr[$c]}
    #比较两个相邻元素的值大小，如果前面元素的值较大，则与后面元素交换位置
    if [ $first -lt $second ];then
      #使用临时变量保存前面元素的值，实现两个相邻元素交换位置
      tmp=$first
      arr[$b]=$second
      arr[$c]=$tmp
    fi
  done
done

echo "冒泡排序后的数组的值为：${arr[@]}"

}

#### main ####
read -p "请输入一组列表：" num

array=($num)
echo "旧数组的值为：${array[@]}"

MAOPAO ${array[@]}

shell数组（包含排序算法）

shell数组（包含排序算法）

3.直接选择排序介绍

与冒泡排序相比，直接选择排序的交换次数更少，所以速度会快些。

运行流程：

将指定排序位置与其他数组元素分别对比，如果满足条件就交换元素值，注意这里区别冒泡排序，不是交换相邻元素，而是把满足条件的元素与指定的排序位置交换（如从最后一个元素开始排序），这样排序好的位置逐渐扩大，最后整个数组都成为排序好的格式。

shell数组（包含排序算法）

 4.直接选择排序事例

[root@localhost ~]# vim zhipai.sh

#!/bin/bash

arr=(19 30 1 50 66 99)
echo "排序前的数组值为；${arr[@]}"
length=${#arr[@]}
#外层循环定义排序的轮数，为数组长度减1，且从1开始
for ((a=1;a<length;a++))
do
   #每轮比较的初始最大元素的下标，从0开始，即第一个元素
   i=0
   #内层循环定义用于与当前最大元素作比较的元素下标范围，从1开始，且每轮比较的最后一个元素下标会随着轮数增加而减少
   for ((b=1;b<=length-a;b++))
   do
     #通过比较，获取当前轮数中最大元素的下标
     if [ ${arr[$i]} -lt ${arr[$b]} ];then
        i=$b
     fi
   done
   #获取当前轮数的最后一个元素的下标
   last=$[length - a]
   #先用临时变量获取当前轮数的最后一个元素
   tmp=${arr[$last]}
   #将最大元素的值赋给当前轮数的最后一个轮数
   arr[$last]=${arr[$i]}
   #将临时变量的值，即原最后一个元素的值交换
   arr[$i]=$tmp
done
echo "排序后的数组值为：${arr[@]}"

shell数组（包含排序算法）

 5.插入排序介绍

插入排序（Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

shell数组（包含排序算法）

 shell数组（包含排序算法）

6. 插入排序事例

[root@localhost ~]# vim chapai.sh

#!/bin/bash

arr=(9 45 36 2 55 1 68)
echo "排序前数组值为：${arr[@]}"

length=${#arr[@]}
#外层循环定义待排序的元素下标位置
for ((a=1;a<length;a++))
do
    #内层循环定义已排好的序列的元素的元素下标位置范围
    for ((b=0;b<a;b++))
    do
       #将待排序的元素和前面已经排序好的元素依次比较，较小的数会交换到已排好序的元素位置，较大的数会放到待排序的元素位置
       if [ ${arr[$a]} -lt ${arr[$b]} ];then
         tmp=${arr[$a]}
         arr[$a]=${arr[$b]}
         arr[$b]=$tmp
       fi
    done
done
echo "排序后数组的值为：${arr[@]}"

shell数组（包含排序算法）

 7.反转排序介绍

以相反的顺序把原有的数组的内容重新排序

运行流程：

把数组最后一个元素与第一元素替换，倒数第二个元素与第二元素替换，以此类推，直到把所有数组元素反转替换。

8.反转排序事例

[root@localhost ~]# vim daopai.sh

#!/bin/bash

#定义数组
arr=(0 1 2 3 4 5 6 7 8 9)
echo "排序前数组的值为：${arr[@]}"

length=${#arr[@]}

#循环减半
for ((a=0;a<length/2;a++))
do
   #获取第一个元素的值
   tmp=${arr[$a]}
   #获取当前轮数的最后一个元素下标，会随着轮数的增加而减少
   last=$[length-1-a]
   #替换最后一个元素
   arr[$a]=${arr[$last]}
   arr[$last]=$tmp
done

echo "排序后数组的值：${arr[@]}"

shell数组（包含排序算法）

9. 睡眠排序

它的原理是将一组数字按照从小到大的顺序排序。这个算法的特殊之处在于它不使用任何比较操作或交换操作，而是利用了计算机的多线程和睡眠函数。通过数据在后台的睡眠时间进行排序，数值小的睡眠时间短，数值大的睡眠时间长。

[root@localhost ~]# vim shuimian.sh

#!/bin/bash

go() {
    sleep `echo $1*0.01 | bc`             #通过bc，进行浮点运算
    echo $1
}
a=(6 9 2 5 3 78 99)
echo "初始数组值为：${a[@]}"
for i in ${a[@]};do
   go $i &
done
sleep 1

shell数组（包含排序算法）

10.希尔排序介绍

希尔排序（Shell Sort）是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因DL．Shell于1959年提出而得名。 希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

shell数组（包含排序算法） 

shell数组（包含排序算法） 

11. 希尔排序事例

[root@localhost ~]# vim xier.sh

#!/bin/bash
array=(7 6 8 3 1 5 2 4)
echo "原数组值为：${array[*]}"
length=${#array[*]}

#把距离为gap的元素编为一个组，扫描所有组，每次循环减少增量
for ((gap=$length/2; gap>0; gap/=2))
do
    for ((i=gap; i<$length; i++))
    do

          temp=${array[$i]}
          #对距离为gap的元素组进行排序，每一轮比较拿当前轮次最后一个元素与组内其他元素比较，将数组大的往后放
          for ((j=i-gap; j>=0&&temp<${array[$j]}; j-=gap))
          do
        array[$j+$gap]=${array[$j]}

          done
          #和最左边较大的元素调换位置
      array[$j+$gap]=$temp

    done
done
echo "排序后的数组值为：${array[*]}"

shell数组（包含排序算法）

 文章来源地址https://www.toymoban.com/news/detail-442196.html

到了这里，关于shell数组（包含排序算法）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 拓扑排序详解（包含算法原理图解、算法实现过程详解、算法例题变式全面讲解等）

    拓扑排序详解（包含算法原理图解、算法实现过程详解、算法例题变式全面讲解等）

    在图论中，如果一个有向图无法从某个顶点出发经过若干条边回到该点，则这个图是一个有向无环图（DAG图）。 如图所示。 对于一个有向图，若x点指向y点，则称x点为y点的入度。 对于一个有向图，若x点指向y点，则称y点为x点的出度。 队列是一种特殊的线性表，特殊之处在

    2024年02月07日
    浏览(51)

  • C++构造一个包含若干随机数的整数数组并将它按从小到大顺序排序，随机数的范围是0~max

           

    2024年02月11日
    浏览(41)
  • JAVA的sort用法详解（二维数组排序，List＜＞排序,lambada表达式，自定义类型排序）

    JAVA的sort用法详解（二维数组排序，List＜＞排序,lambada表达式，自定义类型排序）

    目录 前言： 一维数组降序： 方法1.Comparator接口： 代码实现： 方法2.Collections.reverseOrder()： 代码实现：  二维数组排序： 代码如下： List排序： 代码如下： 自定义类型比较排序： 按照年龄逆序排序： 按照姓名升序排序： lambada表达式简写： 一维数组逆序代码： 二维数组排

    2024年04月09日
    浏览(59)
  • 【算法训练-数组 五】【二分查找】：旋转排序数组的最小数字、旋转排序数组的指定数字

    【算法训练-数组 五】【二分查找】：旋转排序数组的最小数字、旋转排序数组的指定数字

    废话不多说，喊一句号子鼓励自己：程序员永不失业，程序员走向架构！本篇Blog的主题是【数组的二分查找】，使用【数组】这个基本的数据结构来实现，这个高频题的站点是： CodeTop ，筛选条件为： 目标公司+最近一年+出现频率排序 ，由高到低的去 牛客TOP101 去找，只有两

    2024年02月09日
    浏览(50)

  • 【算法】算法学习二：链表 & 数组 & 选择排序

    链表和数组是常见的数据结构，用于组织和存储数据。它们在内部实现和使用方式上有一些显著的区别。 数组是一个连续的内存块，用于存储相同类型的元素。数组的每个元素通过索引访问，索引从0开始。数组的主要特点包括： 随机访问：由于数组的元素在内存中是连续存

    2024年02月06日
    浏览(77)

  • 算法__数组排序_冒泡排序&直接选择排序&快速排序

    本篇主要讲解数组排序相关的三种算法，冒泡排序，直接排序和快速排序。 在数组中依次比较相邻的两个元素，当满足左侧大于右侧时（升序排序），则两个位置的元素互换。如此重复，最终即可完成数组的排序。 依次找出数组中最小值的索引，并和数组左侧的元素进行位

    2024年02月07日
    浏览(51)
  • Java | 数组排序算法

    Java | 数组排序算法

    冒泡排序的基本思想是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移到数组前面，把较大的元素移到数组后面（也就是交换两个元素的位置），这样较小的元素就像气泡一样从底部升到顶部。 直接选择排序的基本思想是将指定排序位置与其他数组元素分别

    2024年02月15日
    浏览(27)

  • 如何使用快速排序算法对整数数组进行就地排序？

    快速排序算法是最常用的排序算法之一，尤其是对大型列表进行排序时，大多数编程语言、库都以一种或另一种方式实现了它。在 Java 中，Arrays.sort()方法使用由 Joshua Bloch 等人编写的双枢轴 快速排序 算法对原始数据类型进行排序。这种实现为大量数据集提供了更好的性能，

    2024年02月01日
    浏览(45)

  • 【第43天】sort 的复杂运用 | 对二维数组与结构体实现自定义排序

    本文已收录于专栏 🌸《Java入门一百练》🌸

    2024年01月17日
    浏览(38)

  • Java 数组常见的排序和查找算法

    2、数组 2.1、常见的算法： 排序算法： 冒泡排序算法 选择排序算法 2.2、算法实际上在 java 中已经封装好了。 排序可以调用方法。例如：java 中提供了一个数组工具类： java.util.Arrays Arrays 是一个工具类。 其中有一个 sort() 方法，可以排序。静态方法，直接使用类名调用就行。

    2024年01月17日
    浏览(39)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包