在这篇文章中。我会向大家展示一些排序算法的可视化过程。我还写了一个工具。大家可对照查看某两种排序算法。

引言

首先，我觉得是最重要的是要理解什么是“排序算法”。依据维基百科。排序算法（Sorting algorithm）是一种能将一串数据按照特定排序方式进行排列的一种算法。

最经常使用到的排序方式是数值顺序以及字典顺序。有效的排序算法在一些算法（比如搜索算法与合并算法）中是重要的，如此这些算法才干得到正确解答。排序算法也用在处理文字数据以及产生人类可读的输出结果。

接下来。我会说明一些算法。全部算法皆由C#代码实现，大部分的算法思想都能够在维基百科上找到。 所呈现的算法有：

  • 双向冒泡排序
  • 冒泡排序
  • 桶排序
  • 梳排序
  • 循环排序
  • 地精排序
  • 堆排序
  • 插入排序
  • 归并排序
  • 奇偶排序
  • 鸽笼排序
  • 高速排序
  • 使用冒泡的快排
  • 选择排序
  • 希尔排序

我已经决定要创建GUI可视化的排序算法。该项目还同意用户保存为GIF图像及设置动画输出排序速度。

使用代码

该解决方式由两个项目组成。第一个项目称为组件提供的创建GIF动绘图像类。该项目是基于NGIF项目的。关于这个项目的很多其它信息能够在这里找到。

第二个项目能够称为排序比較，它是解决方式的主要组成部分。当中。通过一个名为frmMain的结构能够选择排序算法。设置你想要排序，排序的速度，排序数量。并选择是否要创建动态图片。

在窗口上放置两个面板称为pnlSort1和pnlSort2，当中分拣可视化的呈现方式。

每一个算法都都通过自己的排序方式进行命名。并接受一个IList參数。并返回一个IList对象。

DrawSamples方法能够在面板上进行画图。产生的随机样本之后就会调用它。通过点击随机button生成的样本会保存在数组中。

1
2
3
4
5
6
7
8
9
10
11
12
13
private

void
DrawSamples()
{
    g.Clear(Color.White);
 
    for

(int

i = 0;
i < array.Count; i++)
    {
        int

x = (int)(((double)pnlSamples.Width
/ array.Count) * i);
 
        Pen
pen = new

Pen(Color.Black);
        g.DrawLine(pen,
new

Point(x, pnlSamples.Height),
          new

Point(x, (int)(pnlSamples.Height
- (int)array[i])));
    }
}

该方法随机产生数据放于数组中。

1
2
3
4
5
6
7
8
9
10
11
12
13
public

void
Randomize(IList list)
{
    for

(int

i = list.Count - 1; i > 0; i--)
    {
        int

swapIndex = rng.Next(i + 1);
        if

(swapIndex != i)
        {
            object

tmp = list[swapIndex];
            list[swapIndex]
= list[i];
            list[i]
= tmp;
        }
    }
}

在排序过程中，当复选框创建的动画被选中，数组中两个数交换的话就会产生图像。

此图像索引从0到n。当中n代表交换的次数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
private

void
SavePicture()
{
    ImageCodecInfo
myImageCodecInfo = this.getEncoderInfo("image/gif");
    EncoderParameter
myEncoderParameter = new

EncoderParameter(
      System.Drawing.Imaging.Encoder.Compression,
(long)EncoderValue.CompressionLZW);
    EncoderParameter
qualityParam =
      new

EncoderParameter(System.Drawing.Imaging.Encoder.Quality, 0L);
    EncoderParameters
myEncoderParameters = new

EncoderParameters(1);
 
    EncoderParameters
encoderParams = new

EncoderParameters(2);
    encoderParams.Param[0]
= qualityParam;
    encoderParams.Param[1]
= myEncoderParameter;
 
    string

destPath =
      System.IO.Path.Combine(txtOutputFolder.Text,
imgCount + ".gif");
    bmpsave.Save(destPath,
myImageCodecInfo, encoderParams);
    imgCount++;
}

排序算法

冒泡排序

冒泡排序也被称为下沉排序。是一个简单的排序算法，通过多次反复比較每对相邻的元素，并按规定的顺序交换他们。终于把数列进行排好序。

一直反复下去，直到结束。该算法得名于较小元素“气泡”会“浮到”列表顶部。因为仅仅使用了比較操作，所以这是一个比較排序。

冒泡排序算法的运作例如以下：

  1. 比較相邻的元素。假设第一个比第二个大。就交换他们两个。
  2. 对每一对相邻元素作相同的工作，从開始第一对到结尾的最后一对。

    这步做完后，最后的元素会是最大的数。

  3. 针对全部的元素反复以上的步骤，除了最后一个。

  4. 持续每次对越来越少的元素反复上面的步骤，直到没有不论什么一对数字须要比較。

因为它的简洁，冒泡排序通常被用来对于程序设计入门的学生介绍算法的概念。但相同简单的插入排序比冒泡排序性能更好，所以有些人觉得不须要再教冒泡排序了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public

IList BubbleSort(IList arrayToSort)
{
    int

n = arrayToSort.Count - 1;
    for

(int

i = 0; i < n; i++)
    {
        for

(int

j = n; j > i; j--)
        {
            if

(((IComparable)arrayToSort[j - 1]).CompareTo(arrayToSort[j]) > 0)
            {
                object

temp = arrayToSort[j - 1];
                arrayToSort[j
- 1] = arrayToSort[j];
                arrayToSort[j]
= temp;
                RedrawItem(j);
                RedrawItem(j
- 1);
                pnlSamples.Refresh();
                if

(chkCreateAnimation.Checked)
                    SavePicture();
            }
        }
    }
    return

arrayToSort;
}
Worst case performance: O(n2)
Best case performance: O(n)
Average case performance: O(n2)
Worst case space complexity: O(1) auxiliary

双向冒泡排序

鸡尾酒排序，也称为双向冒泡排序、调酒器排序、搅拌排序（能够參考选择排序的一个变种）、纹波排序、接送排序，或欢乐时光排序。它由冒泡排序变化而来，是一种稳定的比較排序算法。该算法不同于冒泡排序，它在排序上由两个方向同一时候进行。该排序算法仅仅是比冒泡排序稍难实现，但攻克了冒泡排序中的“乌龟问题”（数组尾部的小值）。

首先从左向右方向为大元素移动方向，从右向左方向为小元素移动方向，然后每一个元素都依次运行。在第 i 次移动后。前 i 个元素和后个 i 元素都放到了正确的位置，也不须要在检查一次。

每次缩短已排序的那部分列表，都能够减半操作次数。

可是在乱数序列的状态下，双向冒泡排序与冒泡排序的效率都非常差劲。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
public

IList BiDerectionalBubleSort(IList arrayToSort)
{
    int

limit = arrayToSort.Count;
    int

st = -1;
    bool

swapped = false;
    do
    {
        swapped
= false;
        st++;
        limit--;
 
        for

(int

j = st; j < limit; j++)
        {
            if

(((IComparable)arrayToSort[j]).CompareTo(arrayToSort[j + 1]) > 0)
            {
                object

temp = arrayToSort[j];
                arrayToSort[j]
= arrayToSort[j + 1];
                arrayToSort[j
+ 1] = temp;
                swapped
= true;
                RedrawItem(j);
                RedrawItem(j
+ 1);
                pnlSamples.Refresh();
                if(chkCreateAnimation.Checked)
                    SavePicture();
 
            }
        }
        for

(int

j = limit - 1; j >= st; j--)
        {
            if

(((IComparable)arrayToSort[j]).CompareTo(arrayToSort[j + 1]) > 0)
            {
                object

temp = arrayToSort[j];
                arrayToSort[j]
= arrayToSort[j + 1];
                arrayToSort[j
+ 1] = temp;
                swapped
= true;
                RedrawItem(j);
                RedrawItem(j
+ 1);
 
                pnlSamples.Refresh();
                if

(chkCreateAnimation.Checked)
                    SavePicture();
 
            }
        }
 
    }
while

(st < limit && swapped);
 
    return

arrayToSort;
}
Worst case performance: O(n2)
Best case performance: O(n)
Average case performance: O(n2)
Worst case space complexity: O(1) auxiliary

桶排序

桶排序，或称为箱排序，是一种把数列划分成若干个桶的排序算法。在每一个桶内各自排序，或者使用不同的排序算法，或通过递归方式继续使用桶排序算法。

这是一个分布排序。是最能体现出数字意义的一种基数排序。桶排序是鸽巢排序的一种归纳结果。

当要被排序的数组内的数值是均匀分配的时候，桶排序使用线性时间（Θ（n））。但桶排序并非 比較排序，他不受到 O(n log n) 下限的影响。

桶排序的流程：

  1. 设置一个定量的数组当作空桶子。
  2. 寻訪串行，而且把项目一个一个放到相应的桶子去。
  3. 对每一个不是空的桶子进行排序。
  4. 从不是空的桶子里把项目再放回原来的串行中。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
public

IList BucketSort(IList arrayToSort)
{
    if

(arrayToSort == null

|| arrayToSort.Count == 0) return

arrayToSort;
 
    object

max = arrayToSort[0];
    object

min = arrayToSort[0];
 
    for

(int

i = 0; i  0)
        {
            max
= arrayToSort[i];
        }
 
        if

(((IComparable)arrayToSort[i]).CompareTo(min) < 0)
        {
            min
= arrayToSort[i];
        }
    }
    ArrayList[]
holder = new

ArrayList[(int)max
- (int)min
+ 1];
 
    for

(int

i = 0; i < holder.Length; i++)
    {
        holder[i]
= new

ArrayList();
    }
 
    for

(int

i = 0; i < arrayToSort.Count; i++)
    {
        holder[(int)arrayToSort[i]
- (int)min].Add(arrayToSort[i]);
    }
 
    int

k = 0;
 
    for

(int

i = 0; i  0)
        {
            for

(int

j = 0; j < holder[i].Count; j++)
            {
                arrayToSort[k]
= holder[i][j];
                RedrawItem(k);
                pnlSamples.Refresh();
                if

(chkCreateAnimation.Checked)
                    SavePicture();
                k++;
            }
        }
    }
 
    return

arrayToSort;
}
Worst case performance: O(n2.k)
Best case performance: -
Average case performance: O(n.k)
Worst case space complexity: O(n.k)

梳排序

梳排序是一个相对简单的排序算法。最初它由Wlodzimierz Dobosiewicz于1980年设计出来。

后来由斯蒂芬和理查德又一次发现和推广。他们的文章在1991年4月发表在字节杂志上。梳排序改善了冒泡排序和类似高速排序的竞争算法。

其要旨在于消除乌龟，亦即在阵列尾部的小数值，这些数值是造成冒泡排序缓慢的主因。

相对地，兔子，亦即在阵列前端的大数值，不影响冒泡排序的效能。

在冒泡排序中。不论什么两个元素进行比較时，他们总是距离彼此为1。梳排序的基本思想是能够不是1。

梳排序中，開始时的间距设定为列表长度，然后每一次都会除以损耗因子(一般为1.3)。必要的时候。间距能够四舍五入，不断反复，直到间距变为1。然后间距就保持为1。并排完整个数列。

最后阶段就相当于一个冒泡排序。但此时大多数乌龟已经处理掉，此时的冒泡排序就高效了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public

IList CombSort(IList arrayToSort)
{
    int

gap = arrayToSort.Count;
    int

swaps = 0;
 
    do
    {
        gap
= (int)(gap
/ 1.247330950103979);
        if

(gap  0)
            {
                object

temp = arrayToSort[i];
                arrayToSort[i]
= arrayToSort[i + gap];
                arrayToSort[i
+ gap] = temp;
                RedrawItem(i);
                RedrawItem(i
+ gap);
                pnlSamples.Refresh();
                if

(chkCreateAnimation.Checked)
                    SavePicture();
                swaps
= 1;
            }
            i++;
        }
while

(!(i + gap >= arrayToSort.Count));
 
    }
while

(!(gap == 1 && swaps == 0));
 
    return

arrayToSort;
}
Worst case performance: -
Best case performance: -
Average case performance: -
Worst case space complexity: O(1)

圈排序

Cycle sort is an in-place, unstable sorting
algorithm, a comparison sort that is theoretically optimal in terms
of the total number of writes to the original array, unlike
any other in-place sorting algorithm. It is based on the idea that the permutation to
be sorted can be factored into cycles, which can individually
be rotated to give a sorted result.

Unlike nearly every other sort, items are never written elsewhere in the array simply to push them out of the way of the action. Each value is either written zero times, if it’s already in its correct
position, or written one time to its correct position. This matches the minimal number of overwrites required for a completed in-place sort.

它是一个就地、不稳定的排序算法。依据原始的数组，一种理论上最优的比較，而且与其他就地排序算法不同。它的思想是把要排的数列分解为圈，即能够分别旋转得到排序结果。

不同于其他排序的是，元素不会被放入数组的中任何位置从而推动排序。

每一个值假设它已经在其正确的位置则不动，否则只须要写一次就可以。

也就是说只最小覆盖就能完毕排序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public

IList CycleSort(IList arrayToSort)
{
    int

writes = 0;
    for

(int

cycleStart = 0; cycleStart < arrayToSort.Count; cycleStart++)
    {
        object

item = arrayToSort[cycleStart];
        int

pos = cycleStart;
 
        do
        {
            int

to = 0;
            for

(int

i = 0; i < arrayToSort.Count; i++)
            {
                if

(i != cycleStart && ((IComparable)arrayToSort[i]).CompareTo(item) < 0)
                {
                    to++;
                }
            }
            if

(pos != to)
            {
                while

(pos != to && ((IComparable)item).CompareTo(arrayToSort[to]) == 0)
                {
                    to++;
                }
 
                object

temp = arrayToSort[to];
                arrayToSort[to]
= item;
                RedrawItem(to);
                item
= temp;
                RedrawItem(cycleStart);
                pnlSamples.Refresh();
                if

(chkCreateAnimation.Checked)
                    SavePicture();
                writes++;
                pos
= to;
            }
        }
while

(cycleStart != pos);
    }
    return

arrayToSort;
}
Worst case performance: O(n2)
Best case performance: -
Average case performance: O(n2)
Worst case space complexity: O(1)

地精排序

地精排序（gnome sorting。大部分地方翻成“侏儒排序”。“地精排序”明明更好听呀，本文就这么用了。

）最初由哈米德在2000年的时候提出。当时称为傻瓜排序。之后被迪克说明而且命名为“地精排序”。除了某个元素是经过一系列的互换（类似冒泡排序）才到了它的正确位置之外。它和插入排序挺相似。

它在概念上非常easy，不须要嵌套循环。执行时间是O(n2)，假设列表基本有序，则时间为O(n)。实际上，它和插入排序一样，平均执行时O(n2)。

The algorithm always finds the first place where two adjacent elements are in the wrong order, and swaps them. It takes advantage of the fact that performing a swap can introduce a new out-of-order adjacent pair only right before or after the two swapped elements.
It does not assume that elements forward of the current position are sorted, so it only needs to check the position directly before the swapped elements.

地精算法总是发现第一个 【两个相邻元素存在错误的顺序】，然后把他们交换。原理是，交换一对乱序元素后，会产生一对新的无序相邻元素，而这两个元素要么交换前有序，要么交换后有序。它不觉得元素当前的位置是有序的。所以它仅仅须要在交换元素前直接检查位置。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public

IList GnomeSort(IList arrayToSort)
{
    int

pos = 1;
    while

(pos = 0)
        {
            pos++;
        }
        else
        {
            object

temp = arrayToSort[pos];
            arrayToSort[pos]
= arrayToSort[pos - 1];
            RedrawItem(pos);
 
            arrayToSort[pos
- 1] = temp;
            RedrawItem(pos
- 1);
            RefreshPanel(pnlSamples);
            if

(savePicture)
                SavePicture();
            if

(pos > 1)
            {
                pos--;
            }
        }
    }
    return

arrayToSort;
}
Worst case performance: O(n2)
Best case performance: -
Average case performance: -
Worst case space complexity: O(1)

堆排序

堆排序是从数据集构建一个数据堆。然后提取最大元素，把它放到部分有序的数组的末尾。提取最大元素后。又一次构建新堆，然后又接着提取新堆这的最大元素。

反复这个过程，直到堆中没有元素而且数组已排好。堆排序的基本实现须要两个数组：一个用于构建堆。还有一个是存放有序的元素。

堆排序把输入数组插入到一个二叉堆的数据结构中。

最大值（大根堆）或最小值（小根堆）会被提取出来。直到堆空为止。提取出来的元素，是已经排好序的。

每次提取后，堆中没变换的元素依旧保留了。所以（堆排序的）唯一消耗就是提取过程。

在提取过程中，所须要的空间，就是用于存放堆的空间。为了实现恒定的空间开销。堆是存储在输入数组中还没有完毕排序的那部分空间中。

堆排序使用了两个堆操作：插入和根删除。

每一个提取的元素放到数组的最后一个空位置。

数组剩余位置存放待排元素。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
public

IList HeapSort(IList list)
{
    for

(int

i = (list.Count - 1) / 2; i >= 0; i--)
        Adjust(list,
i, list.Count - 1);
 
    for

(int

i = list.Count - 1; i >= 1; i--)
    {
        object

Temp = list[0];
        list[0]
= list[i];
        list[i]
= Temp;
        RedrawItem(0);
        RedrawItem(i);
        pnlSamples.Refresh();
        if

(chkCreateAnimation.Checked)
            SavePicture();
        Adjust(list,
0, i - 1);
 
    }
 
    return

list;
}
 
public

void
Adjust(IList list, int

i, int

m)
{
    object

Temp = list[i];
    int

j = i * 2 + 1;
    while

(j <= m)
    {
        if

(j < m)
            if

(((IComparable)list[j]).CompareTo(list[j + 1]) < 0)
                j
= j + 1;
 
        if

(((IComparable)Temp).CompareTo(list[j]) < 0)
        {
            list[i]
= list[j];
            RedrawItem(i);
            pnlSamples.Refresh();
            if

(chkCreateAnimation.Checked)
                SavePicture();
            i
= j;
            j
= 2 * i + 1;
        }
        else
        {
            j
= m + 1;
        }
    }
    list[i]
= Temp;
    RedrawItem(i);
    pnlSamples.Refresh();
    if

(chkCreateAnimation.Checked)
        SavePicture();
}
Worst case performance: O(n log n)
Best case performance: O(n log n)
Average case performance: O(n log n)
Worst case space complexity: O(1)

插入排序

插入排序的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到对应位置并插入。插入排序在实现上，通常採用in-place排序（即仅仅需用到O(1)的额外空间的排序）。因而在从后向前扫描过程中，须要重复把已排序元素逐步向后挪位。为最新元素提供插入空间。

详细算法描写叙述例如以下：

  1. 从第一个元素開始，该元素能够觉得已经被排序
  2. 取出下一个元素，在已经排序的元素序列中从后向前扫描
  3. 假设该元素（已排序）大于新元素，将该元素移到下一位置
  4. 反复步骤3，直到找到已排序的元素小于或者等于新元素的位置
  5. 将新元素插入到该位置后
  6. 反复步骤2~5
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public

IList InsertionSort(IList arrayToSort)
{
    for

(int

i = 1; i < arrayToSort.Count; i++)
    {
        object

val = arrayToSort[i];
        int

j = i - 1;
        bool

done = false;
        do
        {
            if

(((IComparable)arrayToSort[j]).CompareTo(val) > 0)
            {
                arrayToSort[j
+ 1] = arrayToSort[j];
                RedrawItem(j
+ 1);
                pnlSamples.Refresh();
                if

(chkCreateAnimation.Checked)
                    SavePicture();
                j--;
                if

(j < 0)
                {
                    done
= true;
                }
            }
            else
            {
                done
= true;
            }
 
        }
while

(!done);
        arrayToSort[j
+ 1] = val;
 
        RedrawItem(j
+ 1);
        pnlSamples.Refresh();
        if

(chkCreateAnimation.Checked)
            SavePicture();
    }
    return

arrayToSort;
}
Worst case performance: O(n2)
Best case performance: O(n)
Average case performance: O(n2)
Worst case space complexity: O(1)

归并排序

从概念上讲。归并排序的工作原理例如以下：

  • 假设列表的长度是0或1，那么它已经有序。

    否则：

  • 未排序的部分平均划分为两个子序列。

  • 每一个子序列。递归使用归并排序。
  • 合并两个子列表。使之总体有序。

归并排序包括两个主要观点。以改善其执行时：

  • 一个小列表排序的花费少于大列表。
  • 把两个有序表合并，要比直接排列一个无序表花费更少的步骤。

    比如，您仅仅须要遍历每一个有序列表一次就可以(见以下的合并功能)。

归并操作的步骤例如以下：

  1. 申请空间，使其大小为两个已经排序序列之和。该空间用来存放合并后的序列
  2. 设定两个指针。最初位置分别为两个已经排序序列的起始位置
  3. 比較两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
  4. 反复步骤3直到某一指针到达序列尾
  5. 将还有一序列剩下的全部元素直接拷贝到合并序列尾
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
public

IList MergeSort(IList a, int

low, int

height)
{
    int

l = low;
    int

h = height;
 
    if

(l >= h)
    {
        return

a;
    }
 
    int

mid = (l + h) / 2;
 
    MergeSort(a,
l, mid);
    MergeSort(a,
mid + 1, h);
 
    int

end_lo = mid;
    int

start_hi = mid + 1;
    while

((l <= end_lo) && (start_hi <= h))
    {
        if

(((IComparable)a[l]).CompareTo(a[start_hi]) < 0)
        {
            l++;
        }
        else
        {
            object

temp = a[start_hi];
            for

(int

k = start_hi - 1; k >= l; k--)
            {
                a[k
+ 1] = a[k];
                RedrawItem(k
+ 1);
                pnlSamples.Refresh();
                if

(chkCreateAnimation.Checked)
                    SavePicture();
            }
            a[l]
= temp;
            RedrawItem(l);
            pnlSamples.Refresh();
            if

(chkCreateAnimation.Checked)
                SavePicture();
            l++;
            end_lo++;
            start_hi++;
        }
    }
    return

a;
}
Worst case performance: O(n log n)
Best case performance: O(n log n)
Average case performance: O(n log n)
Worst case space complexity:  

奇偶排序

Odd-even sort is a relatively simple sorting algorithm. It is a comparison sort based on bubble sort with which it shares many characteristics. It functions by comparing all (odd, even)-indexed pairs of adjacent elements in the list and, if a pair is in the
wrong order (the first is larger than the second) the elements are switched. The next step repeats this for (even, odd)-indexed pairs (of adjacent elements). Then it alternates between (odd, even) and (even, odd) steps until the list is sorted. It can be thought
of as using parallel processors, each using bubble sort but starting at different points in the list (all odd indices for the first step). This sorting algorithm is only marginally more difficult than bubble sort to implement.

奇偶排序是一个相对简单的排序算法。它是一种基于冒泡排序的比較算法，它们有着很多共同点。它通过比較全部相邻的(奇数偶)对进行排序。假设某对存在错误的顺序(第一个元素大于第二个)，则交换。下一步针对｛偶奇对｝反复这一操作。

然后序列就在(奇。偶)和(偶。奇)之间变换，直到列表有序。它能够看作是是使用并行处理器。每一个都用了冒泡排序，但仅仅是起始点在列表的不同位置(全部奇数位置可做第一步)。

这个排序算法实现起来仅仅是稍微比冒泡排序复杂一些。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public

IList OddEvenSort(IList arrayToSort)
{
    bool

sorted = false;
    while

(!sorted)
    {
        sorted
= true;
        for

(var i = 1; i < arrayToSort.Count - 1; i += 2)
        {
            if

(((IComparable)arrayToSort[i]).CompareTo(arrayToSort[i + 1]) > 0)
            {
                object

temp = arrayToSort[i];
                arrayToSort[i]
= arrayToSort[i + 1];
                RedrawItem(i);
                arrayToSort[i
+ 1] = temp;
                RedrawItem(i+1);
                pnlSamples.Refresh();
                if

(chkCreateAnimation.Checked)
                    SavePicture();
                sorted
= false;
            }
        }
 
        for

(var i = 0; i < arrayToSort.Count - 1; i += 2)
        {
            if

(((IComparable)arrayToSort[i]).CompareTo(arrayToSort[i + 1]) > 0)
            {
                object

temp = arrayToSort[i];
                arrayToSort[i]
= arrayToSort[i + 1];
                arrayToSort[i
+ 1] = temp;
                RedrawItem(i);
                RedrawItem(i+1);
                pnlSamples.Refresh();
                if

(chkCreateAnimation.Checked)
                    SavePicture();
                sorted
= false;
            }
        }
    }
    return

arrayToSort;
}

鸽巢排序

鸽巢排序。也被称为 count sort （不要和 counting sort 搞混了）。当数组元素的元素数量（n）和可能的键值数（key value，N）大约同样时。这样的排序算法有用。它的时间复杂度为O(n+N)。

（在不可避免遍历每个元素而且排序的情况下效率最好的一种排序算法。但它仅仅有在差值(或者可被映射在差值)非常小的范围内的数值排序的情况下有用。

）

算法流程例如以下：

  • Given an array of values to be sorted, set up an auxiliary array of initially empty “pigeonholes”, one pigeonhole for each key through the range of the original array. 如果有个一个待排序的数组，给它建立了一个空的辅助数组（称为“鸽巢”）。

    把原始数组中的每一个值作为一个key(“格子”)。

  • Going over the original array, put each value into the pigeonhole corresponding to its key, such that each pigeonhole eventually contains a list of all values with that key. 遍历原始数组。依据每一个值放入辅助数组相应的“格子”
  • Iterate over the pigeonhole array in order, and put elements from non-empty pigeonholes back into the original array. 顺序遍历“鸽巢”数组（辅助数组），把非空鸽巢中的元素放回原始数组。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public

IList PigeonHoleSort(IList list)
{
    object

min = list[0], max = list[0];
    foreach

(object

x in

list)
    {
        if

(((IComparable)min).CompareTo(x) > 0)
        {
            min
= x;
        }
        if

(((IComparable)max).CompareTo(x) < 0)
        {
            max
= x;
        }
        Thread.Sleep(speed);
    }
 
    int

size = (int)max
- (int)min
+ 1;
 
    int[]
holes = new

int[size];
 
    foreach

(int

x in

list)
        holes[x
- (int)min]++;
 
    int

i = 0;
    for

(int

count = 0; count < size; count++)
        while

(holes[count]-- > 0)
        {
 
            list[i]
= count + (int)min;
            RedrawItem(i);
            i++;
            RefreshPanel(pnlSamples);
            Thread.Sleep(speed);
        }
    return

list;
}
Worst case performance: O(n+2k)
Best case performance: -
Average case performance: O(n+2k)
Worst case space complexity: O(2k)

高速排序

高速排序採用分而治之的策略，把一个列表划分为两个子列表。步骤是：

  • 从列表中，选择一个元素，称为基准（pivot）。
  • 又一次排序列表。把全部数值小于枢轴的元素排到基准之前。全部数值大于基准的排基准之后(相等的值能够有较多的选择)。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。

  • 分别递归排序较大元素的子列表和较小的元素的子列表。

递归的结束条件是列表元素为零或一个。即已不须要排序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public

IList QuickSort(IList a, int

left, int

right)
{
    int

i = left;
    int

j = right;
    double

pivotValue = ((left + right) / 2);
    int

x = (int)a[int.Parse(pivotValue.ToString())];
 
    while

(i <= j)
    {
        while

(((IComparable)a[i]).CompareTo(x) < 0)
        {
            i++;
        }
        while

(((IComparable)x).CompareTo(a[j]) < 0)
        {
            j--;
        }
        if

(i <= j)
        {
            object

temp = a[i];
            a[i]
= a[j];
            RedrawItem(i);
            i++;
            a[j]
= temp;
            RedrawItem(j);
            j--;
            pnlSamples.Refresh();
            if

(chkCreateAnimation.Checked)
                SavePicture();
        }
    }
    if

(left < j)
    {
        QuickSort(a,
left, j);
    }
    if

(i < right)
    {
        QuickSort(a,
i, right);
    }
    return

a;
}
Worst case performance: O(n2)
Best case performance: O(n log n)
Average case performance: O(n log n)
Worst case space complexity: O(log n)

使用冒泡的高速排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
public

IList BubbleSort(IList arrayToSort, int

left, int

right)
{
    for

(int

i = left; i < right; i++)
    {
        for

(int

j = right; j > i; j--)
        {
            if

(((IComparable)arrayToSort[j - 1]).CompareTo(arrayToSort[j]) > 0)
            {
                object

temp = arrayToSort[j - 1];
                arrayToSort[j
- 1] = arrayToSort[j];
                RedrawItem(j-1);
                arrayToSort[j]
= temp;
                RedrawItem(j);
                pnlSamples.Refresh();
                if

(chkCreateAnimation.Checked)
                    SavePicture();
            }
        }
    }
 
    return

arrayToSort;
}
 
public

IList QuickSortWithBubbleSort(IList a, int

left, int

right)
{
    int

i = left;
    int

j = right;
 
    if

(right - left <= 6)
    {
        BubbleSort(a,
left, right);
        return

a;
    }
 
    double

pivotValue = ((left + right) / 2);
    int

x = (int)a[int.Parse(pivotValue.ToString())];
 
    a[(left
+ right) / 2] = a[right];
    a[right]
= x;
    RedrawItem(right);
    pnlSamples.Refresh();
    if

(chkCreateAnimation.Checked)
        SavePicture();
 
    while

(i <= j)
    {
        while

(((IComparable)a[i]).CompareTo(x) < 0)
        {
            i++;
        }
        while

(((IComparable)x).CompareTo(a[j]) < 0)
        {
            j--;
        }
 
        if

(i <= j)
        {
            object

temp = a[i];
            a[i++]
= a[j];
            RedrawItem(i
- 1);
            a[j--]
= temp;
            RedrawItem(j
+ 1);
            pnlSamples.Refresh();
            if

(chkCreateAnimation.Checked)
                SavePicture();
        }
    }
    if

(left < j)
    {
        QuickSortWithBubbleSort(a,
left, j);
    }
    if

(i < right)
    {
        QuickSortWithBubbleSort(a,
i, right);
    }
 
    return

a;
}

选择排序

原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。然后。再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推。直到全部元素均排序完成。

算法步骤例如以下：

  • 找到列表中的最小值，
  • 把它和第一个位置的元素交换，
  • 列表其余部分反复上面的步骤(从第二个位置開始，且每次加1).

列表被有效地分为两个部分：从左到右的有序部分，和余下待排序部分。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public

IList SelectionSort(IList arrayToSort)
{
    int

min;
    for

(int

i = 0; i < arrayToSort.Count; i++)
    {
        min
= i;
        for

(int

j = i + 1; j < arrayToSort.Count; j++)
        {
            if

(((IComparable)arrayToSort[j]).CompareTo(arrayToSort[min]) < 0)
            {
                min
= j;
            }
        }
        object

temp = arrayToSort[i];
        arrayToSort[i]
= arrayToSort[min];
        arrayToSort[min]
= temp;
 
        RedrawItem(i);
        RedrawItem(min);
        pnlSamples.Refresh();
        if

(chkCreateAnimation.Checked)
            SavePicture();   
    }
 
    return

arrayToSort;
}
Worst case performance: O(n2)
Best case performance: O(n2)
Average case performance: O(n2)
Worst case space complexity: O(1)

希尔排序

希尔排序通过将比較的所有元素分为几个区域来提升插入排序的性能。

这样能够让一个元素能够一次性地朝终于位置前进一大步。然后算法再取越来越小的步长进行排序，算法的最后一步就是普通的插入排序，可是到了这步，需排序的数据差点儿是已排好的了（此时插入排序较快）。

如果有一个非常小的数据在一个已按升序排好序的数组的末端。如果用复杂度为O(n2)的排序（冒泡排序或插入排序），可能会进行n次的比較和交换才干将该数据移至正确位置。

而希尔排序会用较大的步长移动数据，所以小数据仅仅需进行少数比較和交换就可以到正确位置。

一个更好理解的希尔排序实现：将数组列在一个表中并对列排序（用插入排序）。反复这过程，只是每次用更长的列来进行。

最后整个表就唯独一列了。

将数组转换至表是为了更好地理解这算法。算法本身只对原数组进行排序（通过添加索引的步长，比如是用i += step_size而不是i++）。

比如，如果有这样一组数[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ]，如果我们以步长为5開始进行排序，我们能够通过将这列表放在有5列的表中来更好地描写叙述算法，这样他们就应该看起来是这样：

13 14 94 33 82

25 59 94 65 23

45 27 73 25 39

10

然后我们对每列进行排序：

10 14 73 25 23

13 27 94 33 39

25 59 94 65 82

45

将上述四行数字。依序接在一起时我们得到：[ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ].这时10已经移至正确位置了，然后再以3为步长进行排序：

10 14 73

25 23 13

27 94 33

39 25 59

94 65 82

45

排序之后变为：

10 14 13

25 23 33

27 25 59

39 65 73

45 94 82

94

最后以1步长进行排序（此时就是简单的插入排序了）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public

IList ShellSort(IList arrayToSort)
{
    int

i, j, increment;
    object

temp;
 
    increment
= arrayToSort.Count / 2;
 
    while

(increment > 0)
    {
        for

(i = 0; i < arrayToSort.Count; i++)
        {
            j
= i;
            temp
= arrayToSort[i];
            while

((j >= increment) &&
                  (((IComparable)arrayToSort[j
- increment]).CompareTo(temp) > 0))
            {
                arrayToSort[j]
= arrayToSort[j - increment];
                RedrawItem(j);
                pnlSamples.Refresh();
                if

(chkCreateAnimation.Checked)
                    SavePicture();
                j
= j - increment;
            }
            arrayToSort[j]
= temp;
            RedrawItem(j);
            pnlSamples.Refresh();
            if

(chkCreateAnimation.Checked)
                SavePicture();
        }
        if

(increment == 2)
            increment
= 1;
        else
            increment
= increment * 5 / 11;
    }
 
    return

arrayToSort;
}
Worst case performance: -
Best case performance: n
Average case performance: O(n log2 n)
Worst case space complexity: O(1)

最后。感谢给与我帮助的人，有了你们的帮助，本文的质量有了更大的提高，谢谢。

【Unity3D自学记录】可视化对照十多种排序算法（C#版）的更多相关文章

  1. 秒杀9种排序算法(JavaScript版)

    一:你必须知道的 1> JS原型 2> 排序中的有序区和无序区 3> 二叉树的基本知识 如果你不知道上面三个东西,还是去复习一下吧,否则,看下面的东西有点吃力. 二:封装丑陋的原型方 ...

  2. 排序算法Java版，以及各自的复杂度，以及由堆排序产生的top K问题

    常用的排序算法包括: 冒泡排序:每次在无序队列里将相邻两个数依次进行比较,将小数调换到前面, 逐次比较,直至将最大的数移到最后.最将剩下的N-1个数继续比较,将次大数移至倒数第二.依此规律,直至比较结 ...

  3. 排序算法-python版

    总结了一下常见集中排序的算法 归并排序 归并排序也称合并排序,是分治法的典型应用.分治思想是将每个问题分解成个个小问题,将每个小问题解决,然后合并. 具体的归并排序就是,将一组无序数按n/2递归分解成 ...

  4. 经典排序算法 — C# 版（上）

    提起排序,与我们的息息相关,平时开发的代码少不了排序. 经典的排序算法又非常多,我们怎么评价一个排序算法的好坏呢? 其实可以这样想,要细致的比较排序算法好坏,那我们就从多方面尽可能详细的对比 一.效率 ...

  5. 【Unity3D自学记录】判断物体是否在镜头内

    判断物体是否在镜头内. 其实很简单的方法 代码如下: using UnityEngine; using System.Collections; public class DJH_IsRendering ...

  6. 【Unity3D自学记录】Unity3D网络之Socket聊天室初探

    首先创建一个服务端程序,这个程序就用VS的控制台程序做即可了. 代码例如以下: using System; using System.Collections.Generic; using System ...

  7. 【Unity3D自学记录】利用代码改动图片属性(Inspector)

    这段时间一直都在打包资源,然后每次导入都要改图片的属性.真是麻烦,所以一直在寻找一键改动而且打包的方法. 最终让我找到了,太坑人了. 依据自己的需求改代码哦,相信大家都能看明确. 核心部分: Text ...

  8. 【Unity3D自学记录】Unity3D之自制小钟表

    今天来写一个小钟表,事实上非常easy,就运用到了欧拉角. 首先创建时钟.分钟.秒钟以及4个点(12点.3点.6点.9点)偷懒了~~没弄那么多点. 时钟.分钟.秒钟这三个父级的中心一定要注意,我们旋转 ...

  9. 【Unity3D自学记录】鼠标移动三维物体

    创建一个脚本.例如以下: using UnityEngine; using System.Collections; public class OnMouse : MonoBehaviour { IEn ...

随机推荐

  1. 【LeetCode从零单排】No 3 Longest Substring Without Repeating Characters

    题目 Given a string, find the length of the longest substring without repeating characters. For exampl ...

  2. c#1所搭建的核心基础之类型系统的特征

    类型系统的特征简介 几乎每种编程语言都有某种形式的一个类型系统.类型系统大致被分为:强/弱,安全/不安全,静态/动态,显式/隐式等类型. c#在类型系统世界中的位置 c#1的类型系统是静态的.显式的和 ...

  3. Spring Boot,Spring Data JPA多数据源支持

    1 配置文件 wisely.primary.datasource.driverClassName=oracle.jdbc.OracleDriver wisely.primary.datasource. ...

  4. 【c语言】统计一个数二进制中的1的个数

    // 统计一个数二进制中的1的个数 #include <stdio.h> int count(int a) { int count = 0; while (a) { count++; a ...

  5. 【自由谈】城域网IPv6过渡技术——MAP技术（4）

    本节接着回答MAP技术的第三个问题:“MAP-BR的Pool是如何实现?可靠性如何提升?” 在MAP域中通过将多个MAP-BR放在同一个Pool内实现负载分担和保护倒换的.同一个Pool中的每个MAP ...

  6. Android菜鸟的成长笔记（6）——剖析源码学自定义主题Theme

    原文:Android菜鸟的成长笔记(6)--剖析源码学自定义主题Theme 还记得在Android菜鸟的成长笔记(3)中我们曾经遇到了一个问题吗?"这个界面和真真的QQ界面还有点不同的就是上 ...

  7. Could not find or load main class

    Then add '.' to your $CLASSPATH with CLASSPATH=.:$CLASSPATH or as a paramater with java -classpath . ...

  8. Linux统计文件/目录数量ls -l | grep "^-" | wc -l匹配开头和结尾

    Linux统计文件数量 ls -l | grep "^-" | wc -l “^-”  一般文件 “^d” 目录文件 shell/vim中^表示开头 cat repatterns ...

  9. csdn的登录框好难看

    不好意思说实话了,新的登陆框样式挺难看的,那种橙不明朗,介于黄和橙之间,跟整个网站主色调红和黑很不搭.不过,倒是有点跟风Win8平实的style,但是比Win8更简陋了点. tooltip要不加都不加 ...

  10. 使用Understand获取某个函数（方法）的静态度量指标

    在之前的一篇日志中,我简单总结了调用Understand的Perl API的方法,这里再简单总结一些经验: 在SciTools\doc\manuals\pdf目录下的understand_api.pd ...