④十大语言来实现-希尔排序算法

最新推荐文章于 2024-06-21 17:14:10 发布

「已注销」

最新推荐文章于 2024-06-21 17:14:10 发布

阅读量65

点赞数 1

分类专栏：算法文章标签：排序算法算法数据结构

本文链接：https://blog.csdn.net/HanYanHua_2023/article/details/129782546

版权

算法专栏收录该内容

10 篇文章 0 订阅

订阅专栏

算法对于我们今天生活十分重要，怎样宣扬也不会夸张。它们在虚拟世界中无处不在，从金融机构到交友网站。但是，相比于其他算法，其中有一些算法更大程度上改变并控制着我们的世界。本文列举了《数据结构与算法》中最基本的算法

关于时间复杂度

平方阶 (O(n2)) 排序各类简单排序：直接插入、直接选择和冒泡排序。

线性对数阶 (O(nlog2n)) 排序快速排序、堆排序和归并排序；

O(n1+§)) 排序，§ 是介于 0 和 1 之间的常数。希尔排序

线性阶 (O(n)) 排序基数排序，此外还有桶、箱排序。

关于稳定性

稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序。

不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。

名词解释：

n：数据规模
k："桶"的个数
In-place：占用常数内存，不占用额外内存
Out-place：占用额外内存
稳定性：排序后 2 个相等键值的顺序和排序之前它们的顺序相同

在这里插入图片描述

1 希尔排序

希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。

希尔排序是基于插入排序的以下两点性质而提出改进方法的：

插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；
但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位；

希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。

希尔排序是以它的创造者（Donald Shell）命名的。这个算法在插入排序的基础上做了很大的改善。希尔排序的核心理念与插入排序不同，它会首先比较距离较远的元素，而非相邻的元素。和简单地比较相邻元素相比，使用这种方案可以使离正确位置很远的元素更快地回到合适的位置。当开始用这个算法遍历数据集时，所有元素之间的距离会不断减小，直到处理到数据集的末尾，这时算法比较的就是相邻元素了。

希尔排序的工作原理是，通过定义一个间隔序列来表示在排序过程中进行比较的元素之间有多远的间隔。我们可以动态定义间隔序列，不过对于大部分的实际应用场景，算法要用到的间隔序列可以提前定义好。有一些公开定义的间隔序列，使用它们会得到不同的结果。在这里我们用到了 Marcin Ciura 在他 2001 年发表的论文“Best Increments for the Average Case of Shell Sort”（http:bit.ly/1b04YFv,2001）中定义的间隔序列。这个间隔序列是：701, 301, 132, 57, 23, 10, 4, 1。在用它进行日常编码之前，我们先通过一个小的数据集合来看看这个算法是怎么运行的。

一个简单的希尔排序的例子如3节内容所示

1.1 算法步骤

选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；

按增量序列个数 k，对序列进行 k 趟排序；

每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

1.2 动图演示

2.十大语言实现-选择排序

2.1 JavaScript 代码实现实例

function shellSort(arr) {
    var len = arr.length,
        temp,
        gap = 1;
    while(gap < len/3) {          //动态定义间隔序列
        gap =gap*3+1;
    }
    for (gap; gap > 0; gap = Math.floor(gap/3)) {
        for (var i = gap; i < len; i++) {
            temp = arr[i];
            for (var j = i-gap; j >= 0 && arr[j] > temp; j-=gap) {
                arr[j+gap] = arr[j];
            }
            arr[j+gap] = temp;
        }
    }
    return arr;
}

2.2 Python 代码实现实例

def shellSort(arr):
    import math
    gap=1
    while(gap < len(arr)/3):
        gap = gap*3+1
    while gap > 0:
        for i in range(gap,len(arr)):
            temp = arr[i]
            j = i-gap
            while j >=0 and arr[j] > temp:
                arr[j+gap]=arr[j]
                j-=gap
            arr[j+gap] = temp
        gap = math.floor(gap/3)
    return arr

2.3 Go 代码实现实例

func shellSort(arr []int) []int {
        length := len(arr)
        gap := 1
        for gap < length/3 {
                gap = gap*3 + 1
        }
        for gap > 0 {
                for i := gap; i < length; i++ {
                        temp := arr[i]
                        j := i - gap
                        for j >= 0 && arr[j] > temp {
                                arr[j+gap] = arr[j]
                                j -= gap
                        }
                        arr[j+gap] = temp
                }
                gap = gap / 3
        }
        return arr
}

2.4 Java 代码实现实例

public static void shellSort(int[] arr) {
    int length = arr.length;
    int temp;
    for (int step = length / 2; step >= 1; step /= 2) {
        for (int i = step; i < length; i++) {
            temp = arr[i];
            int j = i - step;
            while (j >= 0 && arr[j] > temp) {
                arr[j + step] = arr[j];
                j -= step;
            }
            arr[j + step] = temp;
        }
    }
}

2.5 PHP 代码实现实例

function shellSort($arr)
{
    $len = count($arr);
    $temp = 0;
    $gap = 1;
    while($gap < $len / 3) {
        $gap = $gap * 3 + 1;
    }
    for ($gap; $gap > 0; $gap = floor($gap / 3)) {
        for ($i = $gap; $i < $len; $i++) {
            $temp = $arr[$i];
            for ($j = $i - $gap; $j >= 0 && $arr[$j] > $temp; $j -= $gap) {
                $arr[$j+$gap] = $arr[$j];
            }
            $arr[$j+$gap] = $temp;
        }
    }
    return $arr;
}

2.6 C 代码实现实例

void shell_sort(int arr[], int len) {
        int gap, i, j;
        int temp;
        for (gap = len >> 1; gap > 0; gap >>= 1)
                for (i = gap; i < len; i++) {
                        temp = arr[i];
                        for (j = i - gap; j >= 0 && arr[j] > temp; j -= gap)
                                arr[j + gap] = arr[j];
                        arr[j + gap] = temp;
                }
}

2.7 C++ 代码实现实例

template<typename T>
void shell_sort(T array[], int length) {
    int h = 1;
    while (h < length / 3) {
        h = 3 * h + 1;
    }
    while (h >= 1) {
        for (int i = h; i < length; i++) {
            for (int j = i; j >= h && array[j] < array[j - h]; j -= h) {
                std::swap(array[j], array[j - h]);
            }
        }
        h = h / 3;
    }
}

2.8 C# 代码实现实例

无

2.9 Ruby 代码实现实例

无

2.10 Swift 代码实现实例

无

3.一个简单的希尔排序的例子

下图演示了在希尔排序中间隔序列是如何运行的

在这里插入图片描述

我们先来看下希尔排序算法的代码

function shellsort() {
	for (var g = 0; g < this.gaps.length; ++g) {
		for (var i = this.gaps[g]; i < this.dataStore.length; ++i) {
			var temp = this.dataStore[i];
			for (var j = i; j >= this.gaps[g] &&
						this.dataStore[j-this.gaps[g]] > temp;
			j -= this.gaps[g]) {
			this.dataStore[j] = this.dataStore[j - this.gaps[g]];
			}
			this.dataStore[j] = temp;
		}
	}
}
//为了能让这个程序在 CArray 类测试平台中运行，我们需要在这个类的定义里增加一个对间
//隔序列的定义。请将下面代码添加到 CArray 的构造函数中
this.gaps = [5,3,1];
//然后在代码中添加一个函数:
function setGaps(arr) {
this.gaps = arr;
}

最后，在 CArray 构造函数中添加 shellsort() 代码及对 shellsort() 函数的引用。
外循环控制间隔序列的移动。也就是说，算法在第一次处理数据集时，会检查所有间隔为
5 的元素。下一次遍历会检查所有间隔为 3 的元素。最后一次则会对间隔为 1 的元素，也
就是相邻元素执行标准插入排序。在开始做最后一次处理时，大部分元素都将在正确的位
置，算法就不必对很多元素进行交换。这就是希尔排序比插入排序更高效的地方。图 12-3
演示了如何使用间隔序列为 5, 3, 1 的希尔排序算法，对一个包含 10 个随机数字的数据集
合进行排序。
现在通过实例来看看这个算法是如何运行的。我们在 shellsort() 中添加一个 print() 语
句来跟踪这个算法的执行过程。每一个间隔，以及该间隔的排序结果都会被打印出来。

例 对小数据集合执行希尔排序

load("CArray.js")
var nums = new CArray(10);
nums.setData();
print(" 希尔排序前：\n");
print(nums.toString());
print("\n 希尔排序中：\n");
nums.shellsort();
print("\n 希尔排序后：\n");
print(nums.toString())

-------------------------------------
//以上代码输出的结果为
希尔排序前：
6 0 2 9 3 5 8 0 5 4

希尔排序中：
5 0 0 5 3 6 8 2 9 4 // 间隔 5
4 0 0 5 2 6 5 3 9 8 // 间隔 3
0 0 2 3 4 5 5 6 8 9 // 间隔 1

希尔排序后：
0 0 2 3 4 5 5 6 8 9

要理解希尔排序是如何运行的，可以对比数组的初始状态和执行完间隔序列为 5 的排序后
的状态。初始状态时的第一个元素 6，和它后面的第 5 个元素 5，进行了互换，因为 5 < 6。
现在我们来比较 gap 5 和 gap 3 这两行。在 gap 5 这行中的数字 3 和数字 2 进行了互换，
因为 2 < 3，并且 2 是 3 后面的第 3 个元素。从循环中当前元素所在位置往后数，简单地数
到第 gap 个数的位置，然后比较这个位置和当前元素所在位置上的两个数字，就可以对希
尔排序过程中的任何步骤进行跟踪。
现在我们来详细看一下希尔排序是如何运行的，我们对一个更大的数据集合（100 个元
素），使用一个使用更大的间隔序列来执行希尔排序算法。以下是输出结果

--------------------------
希尔排序前：
19 19 54 60 66 69 45 40 36 90 22
93 23 0 88 21 70 4 46 30 69
75 41 67 93 57 94 21 75 39 50
17 8 10 43 89 1 0 27 53 43
51 86 39 86 54 9 49 73 62 56
84 2 55 60 93 63 28 10 87 95
59 48 47 52 91 31 74 2 59 1
35 83 6 49 48 30 85 18 91 73
90 89 1 22 53 92 84 81 22 91
34 61 83 70 36 99 80 71 1

希尔排序后：
0 0 1 1 1 1 2 2 4 6 8
9 10 10 17 18 19 19 21 21 22
22 22 23 27 28 30 30 31 34 35
36 36 39 39 40 41 43 43 45 46
47 48 48 49 49 50 51 52 53 53
54 54 55 56 57 59 59 60 60 61
62 63 66 67 69 69 70 70 71 73
73 74 75 75 80 81 83 83 84 84
85 86 86 87 88 89 89 90 90 91
91 91 92 93 93 93 94 95 99

「已注销」

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
④十大语言来实现-希尔排序算法

2.1 JavaScript 代码实现希尔排序2.2 Python 代码实现希尔排序2.3 Go代码实现希尔排序2.4 Java 代码实现希尔排序2.5 PHP代码实现希尔排序2.6C代码实现希尔排序2.7 C+＋代码实现希尔排序2.8 C#代码实现希尔排序2.9 Ruby代码实现希尔排序2.10 Swift 代码实现希尔排序3.一个简单的希尔排序的例子
复制链接

扫一扫