当前位置： 首页 > news >正文

认证网站所有权要添加代码wordpress页面列表

news 2025/11/2 6:06:50
认证网站所有权要添加代码,wordpress页面列表,集团网站建,鄂州网站建设1、希尔排序 希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。 希尔排序是基于插入排序的以下两点性质而提出改进方法的： 插入排序在对几乎已经排好序的数据操作时，效率高&…

1、希尔排序

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

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

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

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

1. 算法步骤

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

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

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

2. 示意图

代码实现

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;}

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

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}

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;}}
}

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;
}

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;}
}

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、归并排序 

归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

作为一种典型的分而治之思想的算法应用，归并排序的实现由两种方法：

  • 自上而下的递归（所有递归的方法都可以用迭代重写，所以就有了第 2 种方法）；
  • 自下而上的迭代；

在《数据结构与算法 JavaScript 描述》中，作者给出了自下而上的迭代方法。但是对于递归法，作者却认为：

However, it is not possible to do so in JavaScript, as the recursion goes too deep for the language to handle.

然而，在 JavaScript 中这种方式不太可行，因为这个算法的递归深度对它来讲太深了。

说实话，我不太理解这句话。意思是 JavaScript 编译器内存太小，递归太深容易造成内存溢出吗？还望有大神能够指教。

和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是 O(nlogn) 的时间复杂度。代价是需要额外的内存空间。

2. 算法步骤

  1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
  2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置；
  3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
  4. 重复步骤 3 直到某一指针达到序列尾；
  5. 将另一序列剩下的所有元素直接复制到合并序列尾。

3. 示意图

代码实现

JavaScript

实例

function mergeSort(arr) {// 采用自上而下的递归方法var len = arr.length;if(len < 2) {return arr;}var middle = Math.floor(len / 2),left = arr.slice(0, middle),right = arr.slice(middle);return merge(mergeSort(left), mergeSort(right));}function merge(left, right){var result = [];while (left.length && right.length) {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());return result;
}

Python

实例

def mergeSort(arr):import mathif(len(arr)<2):return arrmiddle = math.floor(len(arr)/2)left, right = arr[0:middle], arr[middle:]return merge(mergeSort(left), mergeSort(right))def merge(left,right):result = []while left and right:if left[0] <= right[0]:result.append(left.pop(0))else:result.append(right.pop(0));while left:result.append(left.pop(0))while right:result.append(right.pop(0));return result

Go

实例

func mergeSort(arr []int) []int {length := len(arr)if length < 2 {return arr}middle := length / 2left := arr[0:middle]right := arr[middle:]return merge(mergeSort(left), mergeSort(right))}func merge(left []int, right []int) []int {var result []intfor len(left) != 0 && len(right) != 0 {if left[0] <= right[0] {result = append(result, left[0])left = left[1:]} else {                        
result = append(result, right[0])right = right[1:]}}for len(left) != 0 {result = append(result, left[0])left = left[1:]}for len(right) != 0 {result = append(result, right[0])right = right[1:]}return result
}

Java

实例

public class MergeSort implements IArraySort {@Overridepublic int[] sort(int[] sourceArray) throws Exception {// 对 arr 进行拷贝，不改变参数内容int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);if (arr.length < 2) {return arr;}int middle = (int) Math.floor(arr.length / 2);int[] left = Arrays.copyOfRange(arr, 0, middle);int[] right = Arrays.copyOfRange(arr, middle, arr.length);return merge(sort(left), sort(right));}protected int[] merge(int[] left, int[] right) {int[] result = new int[left.length + right.length];int i = 0;while (left.length > 0 && right.length > 0) {if (left[0] <= right[0]) {result[i++] = left[0];                
left = Arrays.copyOfRange(left, 1, left.length);} else {result[i++] = right[0];right = Arrays.copyOfRange(right, 1, right.length);}}while (left.length > 0) {result[i++] = left[0];left = Arrays.copyOfRange(left, 1, left.length);}while (right.length > 0) {result[i++] = right[0];right = Arrays.copyOfRange(right, 1, right.length);}return result;}
}

PHP

实例

function mergeSort($arr){$len = count($arr);if ($len < 2) {return $arr;}$middle = floor($len / 2);$left = array_slice($arr, 0, $middle);$right = array_slice($arr, $middle);return merge(mergeSort($left), mergeSort($right));}function merge($left, $right){    $result = [];while (count($left) > 0 && count($right) > 0) {if ($left[0] <= $right[0]) {$result[] = array_shift($left);} else {$result[] = array_shift($right);}}while (count($left))$result[] = array_shift($left);while (count($right))$result[] = array_shift($right);return $result;
}

C

实例

int min(int x, int y) {return x < y ? x : y;
}
void merge_sort(int arr[], int len) {int *a = arr;int *b = (int *) malloc(len * sizeof(int));int seg, start;for (seg = 1; seg < len; seg += seg) {for (start = 0; start < len; start += seg * 2) {int low = start, mid = min(start + seg, len), high = min(start + seg * 2, len);int k = low;int start1 = low, end1 = mid;int start2 = mid, end2 = high;while (start1 < end1 && start2 < end2)b[k++] = a[start1] < a[start2] ? a[start1++] : a[start2++];while (start1 < end1)b[k++] = a[start1++];while (start2 < end2)b[k++] = a[start2++];}int *temp = a;a = b;b = temp;}if (a != arr) {int i;for (i = 0; i < len; i++)b[i] = a[i];b = a;}free(b);
}

递归版：

实例

void merge_sort_recursive(int arr[], int reg[], int start, int end) {if (start >= end)return;int len = end - start, mid = (len >> 1) + start;int start1 = start, end1 = mid;int start2 = mid + 1, end2 = end;merge_sort_recursive(arr, reg, start1, end1);merge_sort_recursive(arr, reg, start2, end2);int k = start;while (start1 <= end1 && start2 <= end2)reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];while (start1 <= end1)reg[k++] = arr[start1++];while (start2 <= end2)reg[k++] = arr[start2++];for (k = start; k <= end; k++)arr[k] = reg[k];
}void merge_sort(int arr[], const int len) {int reg[len];merge_sort_recursive(arr, reg, 0, len - 1);
}

C++

迭代版：

实例

template<typename T> // 整數或浮點數皆可使用,若要使用物件(class)時必須設定"小於"(<)的運算子功能
void merge_sort(T arr[], int len) {T *a = arr;T *b = new T[len];for (int seg = 1; seg < len; seg += seg) {for (int start = 0; start < len; start += seg + seg) {int low = start, mid = min(start + seg, len), high = min(start + seg + seg, len);int k = low;int start1 = low, end1 = mid;int start2 = mid, end2 = high;while (start1 < end1 && start2 < end2)b[k++] = a[start1] < a[start2] ? a[start1++] : a[start2++];while (start1 < end1)b[k++] = a[start1++];while (start2 < end2)b[k++] = a[start2++];}T *temp = a;a = b;b = temp;}if (a != arr) {for (int i = 0; i < len; i++)b[i] = a[i];b = a;}delete[] b;
}

递归版：

实例

void Merge(vector<int> &Array, int front, int mid, int end) {// preconditions:// Array[front...mid] is sorted// Array[mid+1 ... end] is sorted// Copy Array[front ... mid] to LeftSubArray// Copy Array[mid+1 ... end] to RightSubArrayvector<int> LeftSubArray(Array.begin() + front, Array.begin() + mid + 1);vector<int> RightSubArray(Array.begin() + mid + 1, Array.begin() + end + 1);int idxLeft = 0, idxRight = 0;LeftSubArray.insert(LeftSubArray.end(), numeric_limits<int>::max());RightSubArray.insert(RightSubArray.end(), numeric_limits<int>::max());// Pick min of LeftSubArray[idxLeft] and RightSubArray[idxRight], and put into Array[i]for (int i = front; i <= end; i++) {if (LeftSubArray[idxLeft] < RightSubArray[idxRight]) {Array[i] = LeftSubArray[idxLeft];idxLeft++;} else {Array[i] = RightSubArray[idxRight];idxRight++;}}
}void MergeSort(vector<int> &Array, int front, int end) {if (front >= end)return;int mid = (front + end) / 2;MergeSort(Array, front, mid);MergeSort(Array, mid + 1, end);Merge(Array, front, mid, end);
}

C#

实例

public static List<int> sort(List<int> lst) {if (lst.Count <= 1)return lst;int mid = lst.Count / 2;List<int> left = new List<int>();// 定义左侧ListList<int> right = new List<int>(); 
// 定义右侧List// 以下兩個循環把 lst 分為左右兩個 Listfor (int i = 0; i < mid; i++)        
left.Add(lst[i]);for (int j = mid; j < lst.Count; j++)right.Add(lst[j]);left = sort(left);right = sort(right);return merge(left, right);}
/// <summary>
/// 合併兩個已經排好序的List
/// </summary>
/// <param name="left">左側List</param>
///<param name="right">右側List</param><returns></returns>static List<int> merge(List<int> left, List<int> right) {List<int> temp = new List<int>();while (left.Count > 0 && right.Count > 0) {if (left[0] <= right[0]) {temp.Add(left[0]);left.RemoveAt(0);} else {temp.Add(right[0]);right.RemoveAt(0);}}if (left.Count > 0) {for (int i = 0; i < left.Count; i++)temp.Add(left[i]);}    if (right.Count > 0) {for (int i = 0; i < right.Count; i++)temp.Add(right[i]);}return temp;}

Ruby

实例

def merge listreturn list if list.size < 2pivot = list.size / 2# Merge lambda { |left, right|final = []until left.empty? or right.empty?final << if left.first < right.first; left.shift else right.shiftendendfinal + left + right}.call merge(list[0...pivot]), merge(list[pivot..-1])
end

http://www.yayakq.cn/news/192523/

相关文章：

  • 新建网站的缺点网站建设前期需要准备什么资料
  • 网站关键词seo怎么做河南省建筑资质查询
  • 网站设计与制作教程1网站深圳
  • 贵阳做网站电话新媒体营销期末试卷及答案
  • 从化建网站科技与生活
  • 做统计的网站吗厦门人才网官网招聘信息网
  • 最便宜的免费建站建设集团公司
  • 怎么用安卓机顶盒做网站服务器成都有哪些网站建设的公司
  • 做网站地图邮什么好处遵义网站
  • 重庆建设部网站官网工商网站如何做实名
  • 手机网站建设价格低义乌市住房和城乡建设局网站
  • 交友平台网站建设wordpress 站点维护
  • 泰兴网站建设公司义乌义亭招工做网站养猪工作
  • 网站建设怎么设置多语言怎样免费申请永久域名
  • 北京制作网站的基本流程网站首页怎么制作过程
  • 太原经济型网站建设价格网站推广策划书范文
  • 网站建设网页设计师做网站需要人员
  • 工作室 网站经营性备案wordpress 多站点共享
  • 青岛网站关键字优化中企动力300官网
  • 化妆品网站建设目的如何写wordpress主题
  • 如何申请建设网站首页南宁企业网站建设技术公司
  • 网站正在建设中的图片大全wordpress 手机端发帖
  • 网站seo分析报告网页设计规范
  • 黑龙江省城乡和建设厅网站首页中企动力网站建设 长春
  • 官方网站怎么写临沂科技网站建设
  • 做一个网站需要多少钱大概网站建设的实习报告
  • 网站优化工具升上去通过高权重网站做长尾关键词
  • 网站建设增值服务福田网站建设深圳信科
  • 辽宁住房城乡建设部官方网站郑州短视频代运营
  • 做电影网站心得网站建设 的系统公式