使用typescript写出排序的几种方式
1. 冒泡排序(Bubble Sort)
冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
1.1 算法描述
比较相邻的元素。如果第一个比第二个大，就交换它们两个；
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
1.2 动图演示
1.3 代码实现
//在这里我们提前定义了公用数组
//let sortArr :number [] = [0,2,4,6,8,10,9,7,5,3,1];
/*
1.冒泡排序
时间复杂度(平均) : O(n²)
时间复杂度(最坏) : O(n²)
时间复杂度(最好) : O(n)
空间复杂度 : O(1)
稳定性 : 稳定
*/
function bubbleSort(arr :number[]) :any{
let len :number = arr.length;
if(len < 2) {
console.log(arr);
return arr
}
for(let i :number = 0; i < len - 1; i++){
for(let j :number = 0; j < len -1; j++){
if(arr[j] > arr[j + 1]){ // 相邻元素两两对比
let temp :number = arr[j + 1]; // 元素交换
arr[j + 1] = arr[j];
arr[j] = temp;
}
}
}
console.log("bubbleSort",arr);
return arr;
}
bubbleSort(sortArr);
2. 选择排序（Selection Sort）
选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
2.1 算法描述
n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：
- 初始状态：无序区为R[1…n]，有序区为空；
- 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1…i-1]和R(i…n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
- n-1趟结束，数组有序化了。
2.2 动图演示
2.3 代码实现/* 2.选择排序 时间复杂度(平均) : O(n²) 时间复杂度(最坏) : O(n²) 时间复杂度(最好) : O(n²) 空间复杂度 : O(1) 稳定性 : 不稳定 */ function selectionSort(arr :number[]) :any{ let len :number = arr.length; if(len < 2) { console.log(arr); return arr } let minIndex :number , temp :number; for(let i :number = 0; i < len - 1; i++){ minIndex = i; for(let j :number = i + 1; j < len; j++){ if(arr[j] < arr[minIndex]) minIndex = j } temp = arr [i]; arr[i] = arr[minIndex]; arr[minIndex] = temp } console.log('selectionSort:',arr); return arr; } selectionSort(sortArr);3. 插入排序（Insertion Sort）
插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
3.1 算法描述
一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：
- 从第一个元素开始，该元素可以认为已经被排序；
- 取出下一个元素，在已经排序的元素序列中从后向前扫描；
- 如果该元素（已排序）大于新元素，将该元素移到下一位置；
- 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
- 将新元素插入到该位置后；
- 重复步骤2~5。
3.2 动图演示
3.3 代码实现/* 3.插入排序 时间复杂度(平均) : O(n²) 时间复杂度(最坏) : O(n²) 时间复杂度(最好) : O(n) 空间复杂度 : O(1) 稳定性 : 稳定 */ function insertionSort(arr :number[]) :any{ let len :number = arr.length; if(len < 2) { console.log(arr); return arr } let preIndex :number , current :number; for(let i :number = 1; i < len; i++){ preIndex = i - 1; current = arr[i]; while(preIndex >= 0 && arr[preIndex] > current){ arr[preIndex + 1] = arr[preIndex]; preIndex--; } arr[preIndex + 1] = current; } console.log('insertionSort:',arr); return arr; } insertionSort(sortArr);4. 希尔排序（Shell Sort）
1959年Shell发明，第一个突破O(n2)的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
3.1 算法描述
先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：
- 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
- 按增量序列个数k，对序列进行k 趟排序；
- 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
3.2 动图演示
3.3 代码实现/* 4.希尔排序 时间复杂度(平均) : O(n 的1.3方) 时间复杂度(最坏) : O(n²) 时间复杂度(最好) : O(n) 空间复杂度 : O(1) 稳定性 : 不稳定 */ function shellSort(arr :number[]) :any{ let len :number = arr.length; if(len < 2) { console.log(arr); return arr } let gap :number = Math.floor(len / 2) for(gap; gap > 0; gap = Math.floor(gap / 2)){ for(let i :number = gap; i < len; i++){ let j :number = i; let current :number = arr[i]; while(j - gap >= 0 && current < arr[j - gap]){ arr[j] = arr[j - gap]; j = j - gap; } arr[j] = current; } } console.log('shellSort:',arr); return arr; } shellSort(sortArr);5. 归并排序（Merge Sort）
希尔排序的核心在于间隔序列的设定。既可以提前设定好间隔序列，也可以动态的定义间隔序列。动态定义间隔序列的算法是《算法（第4版）》的合著者Robert Sedgewick提出的。
5.1 算法描述
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
- 把长度为n的输入序列分成两个长度为n/2的子序列；
- 对这两个子序列分别采用归并排序；
- 将两个排序好的子序列合并成一个最终的排序序列。
5.2 动图演示
5.3 代码实现/* 5.归并排序 时间复杂度(平均) : O(nlogn) 时间复杂度(最坏) : O(nlogn) 时间复杂度(最好) : O(nlogn) 空间复杂度 : O(n) 稳定性 : 稳定 */ function mergeSort(arr :number[]) :any{ var len :number = arr.length; if (len < 2) { return arr; } var middle :number = Math.floor(len / 2), left :number[]= arr.slice(0, middle), right :number[]= arr.slice(middle); return merge(mergeSort(left), mergeSort(right)); } function merge(left:number[], right:number[]) :any{ var result :any= []; while (left.length>0 && right.length>0) { if (left[0] <= right[0]) result.push(left.shift()); else result.push(right.shift()); } while (left.length) result.push(left.shift()); while (right.length) result.push(right.shift()); console.log('mergeSort:',result); return result; } mergeSort(sortArr)6.计数排序（Counting Sort）
计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
6.1 算法描述
找出待排序的数组中最大和最小的元素；
- 统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
- 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
- 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。
6.2 动图演示
6.3 代码实现/* 6.计数排序 时间复杂度(平均) : O(n + k) 时间复杂度(最坏) : O(n + k) 时间复杂度(最好) : O(n + k) 空间复杂度 : O(n + k) 稳定性 : 稳定 */ function countingSort(nums :any) :any{ let arr :number[] = []; let max :number = Math.max(...nums); let min :number = Math.min(...nums); for(let i :number = 0, len :number= nums.length; i < len; i++) { let temp :number = nums[i]; arr[temp] = arr[temp] + 1 || 1; } let index :number = 0; for(let i :number = min; i<=max; i++) { while(arr[i] > 0) { nums[index++] = i; arr[i]--; } } console.log('countingSort:',arr); //注意这里的排序 是将数组的索引进行排序 为空的索引不进行排序 return arr } countingSort(sortArr)
扫一扫
742
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
