排序算法
最近学习数据结构算法，学习了简书上一篇博客python的八大排序算法，想着试着通过不同语言去实现一下各种排序算法，由于语法不一样，实现起来也有很大差异（感觉js和python语法风格上非常近似），相比之下，python真是简洁便利和通俗易懂啊
1 冒泡法
冒泡排序(Bubble Sort)是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端
步骤
- 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
- 针对所有的元素重复以上的步骤，除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
- python代码实现：
def bubble_sort(list):
length = len(list)
# 第一级遍历
for index in range(length):
# 第二级遍历
for j in range(1, length - index):
if list[j - 1] > list[j]:
# 交换两者数据，这里没用temp是因为python 特性元组。
list[j - 1], list[j] = list[j], list[j - 1]
return list # 这里语句其实可以省略，传入的list已经发生改变
a = [2,5,3,47,46,19,15,26,36,4,50,48,44,27,38]
print(bubble_sort(a))
- js代码实现：
function bubble(list){
var len = list.length;
for (let i = 0; i<len; i++){
for(let j = 1; j<len - i; j++){
if (list[j-1] > list[j]){
var temp = list[j-1];
list[j-1] = list[j];
list[j] = temp;
}
}
}
return list; // 这里甚至可以省略返回值，因为数组对象在函数中是引用传递
}
- PHP代码实现
<?php
$arr = [2,5,3,47,46,19,15,26,36,4,50,48,44,27,38];
function bubble($lst){
for ($i = 0;$i<count($lst);$i++){
for ($j = 1;$j<count($lst)-$i;$j++){
if ($lst[$j-1]>$lst[$j]){
$temp = $lst[$j-1];
$lst[$j-1] = $lst[$j];
$lst[$j] = $temp;
}
}
}
return $lst;
}
print_r(bubble($arr));
- matlab 代码实现
function [lst_out] = bubble(lst_in)
for ii = 1:length(lst_in) % matlab数组的索引从1开始
for jj = 2:length(lst_in)-ii
if lst(jj-1)>lst(jj)
temp = lst(jj-1);
lst(jj-1) = lst(jj);
lst(jj) = temp;
end
end
end
lst_out = lst_in;
return
2 选择排序
选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理大致是将后面的元素最小元素一个个取出然后按顺序放置
步骤
-
在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，
-
再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
-
重复第二步，直到所有元素均排序完毕。
- python代码实现
def selection_sort(list):
n=len(list)
for i in range (0,n):
min = i
for j in range(i+1,n):
if list[j]<list[min]:
min=j
list[min],list[i]=list[i],list[min]
return list
- js 代码实现
function select(lst){
let len = lst.length;
for (let i = 0; i< len; i++){
let min = i;
for (let j = i+1;j< len; j++){
if (lst[min]>lst[j]){
min = j;
}
}
let temp = lst[i];
lst[i] = lst[min];
lst[min] = temp;
}
return lst;
}
- PHP 代码实现
<?php
$arr = [1,2,5,7,9,6,8,4,3];
for($i = 0,$len = count($arr);$i<$len-1;$i++){
for ($j = $i+1,$len = count($arr);$j<$len;$j++){
// $min = $arr[$i];
$min = $i;
if ($arr[$min]>$arr[$j]){
/* $temp = $arr[$i];
$arr[$i] = $arr[$j];
$arr[$j] = $temp; */ // 这种在元素比较时，交换了多次
$min = $j;
}
}
if ($min != $i){
$temp = $arr[$min];
$arr[$min] = $arr[$i];
$arr[$i] = $temp; // 这种可以直接提取索引，只进行一次交换
}
}
print_r($arr);
- matlab
function [lst_out] = selection(lst_in)
len = length(lst_in);
for ii = 1:len
min = ii;
for jj = (ii+1):len
if(lst_in(min)>lst(jj))
min = jj;
end
end
temp = lst_in(ii);
lst_in(ii) = lst_in(min);
lst_in(min) = temp;
end
return
3 插入排序
插入排序（Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入
步骤
- 从第一个元素开始，该元素可以认为已经被排序
- 取出下一个元素，在已经排序的元素序列中从后向前扫描
- 如果该元素（已排序）大于新元素，将该元素移到下一位置
- 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
- 将新元素插入到该位置后
- 重复步骤2~5
- python代码实现
def insert_sort(list):
n = len(list)
for i in range(1, n):
# 后一个元素和前一个元素比较
# 如果比前一个小
if list[i] < list[i - 1]:
# 将这个数取出
temp = list[i]
# 保存下标
index = i
# 从后往前依次比较每个元素
for j in range(i - 1, -1, -1):
# 和比取出元素大的元素交换
if list[j] > temp:
list[j + 1] = list[j]
index = j
else:
break
# 插入元素
list[index] = temp
return list
a = [2,5,3,47,46,19,15,26,36,4,50,48,44,27,38]
print(insert_sort(a))
- js代码实现
function insert_sort(arr){
let len = arr.length;
for (let i = 1; i<len; i++){
let flag = i;
let compare = arr[i];
for (let j = i - 1; j>0; j--){
if (arr[j]>compare){
flag = j;
arr[j+1] = arr[j];
}
}
arr[flag] = compare;
}
return arr;
}
// 测试
var arr = [2,5,3,47,46,19,15,26,36,4,50,48,44,27,38]
console.log(insert_sort(arr))
- PHP代码实现
<?php
function insert_sort($arr){
$len = count($arr);
for($i = 1; $i < $len; $i++){
$flag = $i;
$compare = $arr[$i];
for ($j = $i-1;$j>0;$j--){
if ($compare<$arr[$j]){
$flag = $j;
$arr[$j+1] = $arr[$j];
}
}
$arr[$flag] = $compare;
}
return $arr;
}
// 测试
$arr = [2,5,3,47,46,19,15,26,36,4,50,48,44,27,38];
print_r(insert_sort($arr));
- matlab代码实现
function [lst_out] = insert_sort(lst_in)
len = length(lst_in);
for ii = 2:len
flag = ii;
compare = lst_in(ii);
for jj = ii-1:-1:1
if compare<lst_in(jj)
flag = jj;
lst_in(jj+1) = lst_in(jj);
end
end
lst_in(flag) = compare;
end
lst_out = lst_in;
return
4 希尔排序
希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本（带步长）。希尔排序是非稳定排序算法。
希尔排序是基于插入排序的以下两点性质而提出改进方法的：
插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率
但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位。
步骤
每次以一定步长(就是跳过等距的数)进行排序，直至步长为1.
- python代码实现
def shell_sort(list):
n = len(list)
# 初始步长
gap = n // 2
while gap > 0:
for i in range(gap, n):
# 每个步长进行插入排序
temp = list[i]
j = i
# 插入排序
while j >= gap and list[j - gap] > temp:
list[j] = list[j - gap]
j -= gap
list[j] = temp
# 得到新的步长
gap = gap // 2
return list
- js代码
function shell_sort(list){
let n = list.length;
// 初始步长
let gap = Math.floor(n / 2);
while(gap>0){
for (let i = gap; i < n; i++){
let temp = list[i];
let j = i;
while (j>=gap && list[j-gap]>temp){
list[j] = list[j-gap];
j-=gap;
}
list[j] = temp;
}
gap = Math.floor(gap / 2);
}
return list;
}
- PHP 代码
<?php
function shell_sort($arr){
$n = count($arr);
$gap = floor($n / 2);
while ($gap > 0){
for ($i = $gap;$i < $n; $i++){
$temp = $arr[$i];
$j = $i;
while (($j>=$gap) && ($temp < $arr[$j - $gap])){
$arr[$j] = $arr[$j - $gap];
$j -= $gap;
}
$arr[$j] = $temp;
}
$gap = floor($gap / 2);
}
return $arr;
}
// 测试
$arr = [2,5,3,47,46,19,15,26,36,4,50,48,44,27,38];
print_r(shell_sort($arr));
- matlab代码
function [lst_out] = shell_sort(lst_in)
n = length(lst_in);
gap = floor(n/2);
while gap > 0
for ii = gap:n
temp = lst_in(ii);
jj = ii;
while (jj>gap) && (temp < lst_in(jj-gap))
lst_in(jj) = lst_in(jj-gap);
jj = jj - gap;
end
lst_in(jj) = temp;
end
gap = floor(gap/2);
end
lst_out = lst_in;
return
5 归并排序
归并操作(归并算法)，指的是将两个已经排序的序列合并成一个序列的操作。归并排序算法依赖归并操作。
步骤
- 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
- 设定两个指针，最初位置分别为两个已经排序序列的起始位置，比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
- 重复步骤3直到某一指针到达序列尾
- 将另一序列剩下的所有元素直接复制到合并序列尾
- python代码实现
# 方式一：迭代法实现两个有序序列合并
def merge_sort(list1, list2):
length_list1 = len(list1)
length_list2 = len(list2)
list3 = []
j = 0
for i in range(length_list1):
while j<length_list2 and list2[j] < list1[i]:
list3.append(list2[j])
j = j+1
list3.append(list1[i])
if j<(length_list2-1): # 最后剩下的元素直接追加进入列表尾
for k in range(j, length_list2):
list3.append(list2[k])
return list3
list1 = [1 3 5 6 9 10]
list2 = [ 2 4 6 7 8 12 15]
print(merge_sort(list1, list2))
# 方式二：分治法实现单个无序序列转为有序序列
def merge_sort2(list):
# 认为长度不大于1的数列是有序的
if len(list) <= 1:
return list
# 二分列表
middle = len(list) // 2
left = merge_sort2(list[:middle])
right = merge_sort2(list[middle:])
# 最后一次合并
return merge(left, right)
# 合并
def merge(left, right):
l,r=0,0
result=[]
while l<len(left) and r<len(right):
if left[l] <right[r]:
result.append(left[l])
l+=1
else:
result.append(right[r])
r +=1
result += left[l:]
result += right[r:]
return result
if __name__ == "__main__":
a = [2,5,3,47,46,19,15,26,36,4,50,48,44,27,38]
print(merge_sort2(a))
- js代码实现
function merge_sort(arr1, arr2){
let len1 = arr1.length;
let len2 = arr2.length;
let arr3 = [];
let j = 0;
for (let i = 0; i<len1; i++ ){
while (j<len2 && arr2[j]<arr1[i]){
arr3.push(arr2[j]);
j+=1
}
arr3.push(arr1[i])
}
if (j<len2-1){
for (let k = j;k<len2;k++){
arr3.push(arr2[k]);
}
}
return arr3;
}
// 测试
arr1 = [1, 3, 5, 10]
arr2 = [2, 4, 6, 8, 9, 11, 12, 13, 14]
console.log(merge_sort(arr1, arr2))
- PHP代码实现
<?php
function merge_sort($arr1, $arr2){
$len1 = count($arr1);
$len2 = count($arr2);
$arr3 = [];
$j = 0;
for ($i = 0; $i<$len1;$i++){
while ($j<$len2 && $arr2[$j] < $arr1[$i]){
array_push($arr3,$arr2[$j]);
$j+=1;
}
array_push($arr3,$arr1[$i]);
}
if ($j < ($len2-1)){
for ($k = $j; $k < $len2; $k++){
array_push($arr3, $arr2[$k]);
}
}
return $arr3;
}
$arr1 = [1,3,5,10];
$arr2 = [2,4,6,8,9,11,13,14];
echo('<pre>');
print_r(merge_sort($arr1, $arr2));
- matlab代码实现
function [lst_out] = merge_sort(lst1, lst2)
len1 = length(lst1);
len2 = length(lst2);
lst3 = [];
jj = 1;
for ii=1:len1
while jj<len2 && lst1(ii)>lst2(jj)
lst3(length(lst3)+1) = lst2(jj);
jj = jj+1;
end
lst3(length(lst3)+1) = lst1(ii);
end
if jj<len2
for k = jj:len2
lst3(length(lst3)+1) = lst2(k);
end
end
lst_out = lst3;
return
6 快速排序
快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists
步骤
- 从数列中挑出一个元素，称为”基准”（pivot）
- 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作
- 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序
- python代码实现
# 普通版本
def quick_sort(list):
less = []
pivotList = []
more = []
# 递归出口
if len(list) <= 1:
return list
else:
# 将第一个值作为基准
pivot = list[0]
for i in list:
# 将比基准小的值放到less数列
if i<pivot:
less.append(i)
elif i>pivot:
more.append(i)
else:
pivotList.append(i)
# 递归再排序
less = quick_sort(less)
more = quick_sort(more)
return less+pivotList+more
if __name__ == "__main__":
a = [2,5,3,47,46,19,15,26,36,4,50,48,44,27,38]
print(quick_sort(a))
# 优化版本
def qsort(arr):
if len(arr)<=1:
return arr
else:
pivot = arr[0]
less = [x for x in arr[1:] if x < pivot]
greater = [y for y in arr[1:] if x >= pivot]
return qsort(less) + [pivot] + qsort(greater)
# 语法糖
qs = lambda xs:((len(xs) <=1 and [xs]) or [qs([x for x in xs[1:] if x < xs[0]])+ [xs[0]] + qs([x for x in xs[1:] if x > xs[0]])])[0]
- js代码实现
/*
function qsort(arr){
if (arr.length<=1)
return arr;
else{
var pivot = arr[0]; // 这里不能用let定义变量，会将变量限制在结构中，下一次函数调用访问不到
var less = arr.filter((ele)=>{return ele<arr[0]});
var greater = arr.filter((ele)=>{return ele>=arr[0]});
}
return qsort(less).concat([pivot]).concat(qsort(greater)) // 报错，递归深度问题
return [...qsort(less),pivot,...qsort(greater)] // 报错，递归深度问题
}
*/
var quickSort = function(arr) {
if (arr.length <= 1) { return arr; }
var pivotIndex = Math.floor(arr.length / 2);
var pivot = arr.splice(pivotIndex, 1)[0];
var left = [];
var right = [];
for (var i = 0; i < arr.length; i++){
if (arr[i] < pivot) {
left.push(arr[i]);
} else {
right.push(arr[i]);
}
}
return quickSort(left).concat([pivot], quickSort(right));
};
- PHP 代码实现
<?php
function quick_sort($arr){
$len = count($arr);
if ($len <= 1){
return $arr;
}
$left = $right = [];
for ($i=1;$i<$len;$i++){
// 第一个元素为比较元素
// 小的元素放在left中，大的元素放在right中
if ($arr[$i]<$arr[0]){
$left[] = $arr[$i];
}
else{
$right[] = $arr[$i];
}
}
return array_merge(quick_sort($left),(array)$arr[0],quick_sort($right)); // 强制转换$arr[0]为数组元素进行连接
}
- matlab代码实现
function [lst_out] = quick_sort(lst_in)
len = length(lst_in);
if len<= 1
lst_out = lst_out
else
left = [];
right = [];
for ii = 2:len
if lst_in(ii) < lst_in(1)
left(length(left)+1) = lst_in(ii);
else
right(length(right)+1) = lst_in(ii);
end
end
lst_out = cat(2, quick_sort(left), lst_in(1), quick_sort(right));
end
return
7 堆排序
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点
步骤
- 创建最大堆:将堆所有数据重新排序，使其成为最大堆
- 最大堆调整:作用是保持最大堆的性质，是创建最大堆的核心子程序
- 堆排序:移除位在第一个数据的根节点，并做最大堆调整的递归运算
- python代码实现
def heap_sort(list):
# 创建最大堆
for start in range((len(list)-2) // 2, -1, -1):
sift_down(list,start,len(list)-1)
# 堆排序
for end in range(len(list) - 1, 0, -1):
list[0], list[end] = list[end], list[0] # 一次取出最大放入列表末尾，然后重新调整最大堆（end依次-1）
sift_down(list, 0, end-1)
return list
# 最大堆调整
def sift_down(lst, start, end):
root = start # 设置初始节点
while True:
child = 2*root + 1 # 左儿子索引，右儿子索引为child+1
if child>end:
break
if child+1 <= end and lst[child] < lst[child+1]:
child += 1 # 选取节点中的最大者
if lst[root] < lst[child]:
lst[root], lst[child] = lst[child], lst[root]
root = child # 继续判断下一节点
else:
break
- js代码实现
function heap_sort(list){
// 创建最大堆
for (let i = Math.floor((list.length-2)/2); i>=0;i--){
sift_down(list, i, list.length - 1);
}
// 最大堆调整
for (let j = list.length - 1; j>0; j--){
[list[0], list[j]] = [list[j], list[0]]; // ES6 结构赋值
sift_down(list, 0, j-1);
}
return list;
}
// 调整最大堆
function sift_down(list, start, end){
var root = start;
var child;
while(true){
child = 2*root + 1;
if (child>end)
break;
if (child + 1 <= end && list[child] < list[child+1])
child += 1;
if (list[root]<list[child]){
[list[root],list[child]] = [list[child],list[root]]; // ES6 结构赋值
root = child;
}
else
break;
}
}
- PHP代码实现
<?php
function heap_sort($arr){
// 创建最大堆
for ($i = floor((count($arr) - 2)/2); $i>=0; $i--){
sift_down($arr, $i, count($arr) -1);
}
// 堆排序
for ($j = count($arr)-1; $j >0; $j--){
// print_r($arr);
[$arr[0],$arr[$j]] = [$arr[$j], $arr[0]]; // 结构赋值
// $temp = $arr[0];
// $arr[0] = $arr[$j];
// $arr[$j] = $temp;
sift_down($arr, 0, $j-1);
}
return $arr;
}
// 调整堆函数
// 使用引用传递将数组传入
function sift_down(&$arr, $start, $end){
$root = $start;
while (true) {
$child = 2 * $root + 1;
if ($child > $end)
break;
if ($child + 1 <= $end && $arr[$child] < $arr[$child + 1]){
$child += 1;
}
if ($arr[$root] < $arr[$child]){
[$arr[$root], $arr[$child]] = [$arr[$child], $arr[$root]];
// $temp = $arr[$root];
// $arr[$root] = $arr[$child];
// $arr[$child] = $temp;
$root = $child;
}
else
break;
}
}
$a = [2,5,3,47,46,19,15,26,36,4,50,48,44,27,38];
echo '<pre>';
print_r(heap_sort($a));
// 上述代码实际运行后为错误输出（还是原数组），查找逻辑错误为sift_down应该传入&$arr;
// 还没有理解为啥需要使用引用传递，数组应该默认是引用传递啊（深拷贝和浅拷贝？）
- matlab 代码实现
function lst_in = heap_sort(lst_in)
len = length(lst_in);
for ii = floor(len/2):-1:1
lst_in = sift_down(lst_in, ii, len);
end
for jj = len:-1:1
temp = lst_in(1);
lst_in(1) = lst_in(jj);
lst_in(jj) = temp;
lst_in = sift_down(lst_in, 1, jj-1);
end
return
%% 调整堆函数
function lst_in = sift_down(lst_in, starts, ends)
root = starts;
while 1
child = 2*root;
if child >ends
break
end
if child + 1 <= ends && lst_in(child)<lst_in(child+1)
child = child + 1;
end
if lst_in(root) < lst_in(child)
temp = lst_in(root);
lst_in(root) = lst_in(child);
lst_in(child) = temp;
root = child;
else
break;
end
end
% 控制窗口中
a = [3 0 5 8 9 4 2 1 7 6];
b = heap_sort(a)
8 计数排序
当输入的元素是n个0到k之间的整数时，它的运行时间是Θ(n + k)。计数排序不是比较排序，排序的速度快于任何比较排序算法。
由于用来计数的数组C的长度取决于待排序数组中数据的范围（等于待排序数组的最大值与最小值的差加上1），这使得计数排序对于数据范围很大的数组，需要大量时间和内存。例如：计数排序是用来排序0到100之间的数字的最好的算法，但是它不适合按字母顺序排序人名。但是，计数排序可以用在基数排序算法中，能够更有效的排序数据范围很大的数组。
步骤
- 找出待排序的数组中最大和最小的元素
- 统计数组中每个值为i的元素出现的次数，存入数组 C 的第 i 项
- 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）
- 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1
- python代码实现
def count_sort(list):
min = 2147483647
max = 0
# 获取最大值和最小值
for x in list:
if x < min:
min = x
if x > max:
max = x
count = [0] * (max - min + 1)
for index in list:
count[index-min] += 1
index = 0
# 填值
for a in range(max-min + 1):
for c in range(count[a]):
list[index] = a + min
index += 1
return list
- js代码实现
function count_sort(list){
var min = 2147483647;
var max = 0;
// 获取最大值和最小值
for (let val of list){
if (val < min)
min = val;
if (val > max)
max = val;
}
var count = [];
for (let i = 0;i<max-min+1; i++){
count.push(0);
}
for (let index of list){
count[index-min]+=1;
}
var index = 0;
for (let a = 0; a<max-min+1; a++){
for (let b = 0; b<count[a]; b++){
list[index] = a + min;
index += 1;
}
}
return list;
}
- PHP代码实现
<?php
function count_sort($arr){
$min = 2147483647;
$max = 0;
// 取得最大值和最小值
foreach ($arr as $key => $val){
if ($val < $min){
$min = $val;
}
if ($val > $max){
$max = $val;
}
}
// 创建数组
$arr_count = [];
for ($i = 0; $i<$max-$min+1; $i++){
$arr_count[] = 0;
}
foreach($arr as $key=>$val){
$arr_count[$val-$min] += 1;
}
$index = 0;
for ($a = 0;$a<$max - $min + 1; $a++){
for ($b = 0; $b< $arr_count[$a]; $b++){
$arr[$index] = $a + $min;
$index += 1;
}
}
return $arr;
}
$a = [2,5,3,47,46,19,15,26,36,4,50,48,44,27,38];
echo '<pre>';
print_r(count_sort($a));
- matlab代码实现
function lst = count_sort(lst)
min = 2797373661;
max = 0;
for a = lst
if a < min
min = a;
end
if a > max
max = a
end
end
count = zeros(1, max-min+1);
for val = lst
kk = val - min + 1;
count(kk) = count(kk) + 1；
end
index = 1;
for ii = 1:max-min+1
for jj = 1:count(ii)
lst(index) = ii+min-1;
index = index + 1;
end
end
return
9 总结
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
