JS实现数据结构及算法之排序算法
发布时间：2018-09-14, 16:09:37 分类：HTML | 编辑 off 网址 | 辅助
图集1/7
正文 4760字数 678,786阅读
冒泡排序
冒泡排序是最慢的排序算法之一，数据值会像起跑一样从数组的一端漂浮到另一端
冒泡排序是最慢的排序算法之一，数据值会像起跑一样从数组的一端漂浮到另一端
var CArray = function () {
this.dataStore = [9,5,6,8,2,7,3,4,1] //定义数组
this.swap = swap; //数值交换位置
this.bubbleSort = bubbleSort //冒泡排序
}
function swap(arr, index1, index2) {
var temp = arr[index1]
arr[index1] = arr[index2]
arr[index2] = temp
}
function bubbleSort() {
var data = this.dataStore
var numlength = data.length
for(var outer = numlength; outer>=2; --outer) {
for(var inner = 0; inner<=outer -1;inner ++) {
if(data[inner] > data[inner + 1]){
this.swap(this.dataStore, inner, inner+1)
}
}
}
}
var aa= new CArray()
aa.bubbleSort()
console.log(aa.dataStore)Run code
Cut to clipboard
选择排序
从数组的开头开始，将第一个元素和其他元素相比，最小的元素放在第一个位置，再从第二个位置开始
从数组的开头开始，将第一个元素和其他元素相比，最小的元素放在第一个位置，再从第二个位置开始
var CArray = function () {
this.dataStore = [9,5,6,8,2,7,3,4,1] //定义数组
this.swap = swap; //数值交换位置
this.selectSort = selectSort //选择排序
}
function swap(arr, index1, index2) {
var temp = arr[index1]
arr[index1] = arr[index2]
arr[index2] = temp
}
function selectSort() {
var min
for(var outer = 0; outer < this.dataStore.length -2; ++outer) {
min = outer
for(var inner = outer +1; inner <= this.dataStore.length -1; ++inner) {
if(this.dataStore[inner] < this.dataStore[min]){
min = inner
}
}
this.swap(this.dataStore, outer, min)
}
}
var aa= new CArray()
aa.selectSort()
console.log(aa.dataStore)Run code
Cut to clipboard
插入排序
类似人们按数字或字母顺序对数据进行排序，后面的要为前面的腾位置
类似人们按数字或字母顺序对数据进行排序，后面的要为前面的腾位置
var CArray = function () {
this.dataStore = [9,5,6,8,2,7,3,4,1] //定义数组
this.insertSort = insertSort //插入排序
}
function insertSort() {
var temp, inner
for(var outer = 1; outer < this.dataStore.length; ++outer) {
temp = this.dataStore[outer]
inner = outer
while(inner>0 && (this.dataStore[inner -1]) >= temp){
this.dataStore[inner] = this.dataStore[inner -1]
// console.log('inner->',this.dataStore)
inner --
}
this.dataStore[inner] = temp
// console.log('outer->',this.dataStore)
}
}
var aa= new CArray()
aa.insertSort()
console.log(aa.dataStore)Run code
Cut to clipboard
希尔排序
它会首先比较较远的元素而非相邻的元素，让元素尽快回到正确的位置。
通过定义一个间隔序列来表示在排序过程中进行的元素间隔。
公开的间隔序列是701，301，132，57，23，10，4，1
它会首先比较较远的元素而非相邻的元素，让元素尽快回到正确的位置。
通过定义一个间隔序列来表示在排序过程中进行的元素间隔。
公开的间隔序列是701，301，132，57，23，10，4，1
var CArray = function () {
this.dataStore = [99,5,6,8,2,7,3,4,1,23,12,67,43,89] //定义数组
this.shellSort = shellSort //希尔排序
this.gaps = [5,3,1] //希尔间隔
this.dynamiSort = dynamiSort //动态的希尔排序
this.swap = swap; //数值交换位置
}
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
}
console.log('调换后-》', this.dataStore)
}
}
//动态的希尔排序
function dynamiSort() {
var N = this.dataStore.length
var h = 1
while(h < N/3) {
h = h*3+1
}
while(h>=1) {
for(var i = h; i < N; ++i) {
for(var j = i; j>=h && this.dataStore[j] < this.dataStore[j - h] ; j-=h) {
console.log(j)
this.swap(this.dataStore, j, j-h)
}
}
console.log('调整后-》',this.dataStore)
h = (h-1) / 3
}
}
function swap(arr, index1, index2) {
var temp = arr[index1]
arr[index1] = arr[index2]
arr[index2] = temp
}
var aa= new CArray()
// aa.shellSort()
aa.dynamiSort()
console.log(aa.dataStore)Run code
Cut to clipboard
归并排序
把一系列排好序的子序列合并成为一个大的完整有序序列
把一系列排好序的子序列合并成为一个大的完整有序序列
// 归并排序
function mergeSort(arr) {
var len = arr.length;
if(len < 2) {
return arr;
}
var middle = Math.floor(len / 2)
var left = arr.slice(0, middle)
var right = arr.slice(middle)
return mergeArray(mergeSort(left), mergeSort(right));
}
//融合两个有序数组
function mergeArray(left, right) {
var arr = []
while(left.length && right.length) {
if(left[0] > right[0]) {
arr.push(right.shift())
} else {
arr.push(left.shift())
}
}
return arr.concat(left, right)
}
var arr = [2,3,4,12,324,34,5,89,7654,8,9]
console.log(mergeSort(arr))Run code
Cut to clipboard
快速排序
在列表中选择一个元素为基准值，排序围绕这个基准值进行，将列表中小于基准值得放底部，大于的放顶部
在列表中选择一个元素为基准值，排序围绕这个基准值进行，将列表中小于基准值得放底部，大于的放顶部
// 快速排序
function qSort(list) {
if( list.length === 0) return []
var pivot = list[0]
var lesser = []
var greater = []
for(var i = 1; i < list.length; i++) {
if(list[i] < pivot) {
lesser.push(list[i])
} else {
greater.push(list[i])
}
}
return qSort(lesser).concat(pivot, qSort(greater))
}
var arr = [4,3,5,2]
console.log(qSort(arr))Run code
Cut to clipboard
（支付宝）给作者钱财以资鼓励 （微信）→
有过 2 条评论 »
2. 当你进行函数调用的时候，add（1, 2），这里的1和2就是实参。
1、形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量。
2、实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值。
3、实参和形参在数量上，类型上、顺序上应严格一致，否则就会发生类型不匹配的错误。
4、在一般传值调用的机制中只能把实参传送给形参，而不能把形参的值反向地传送给实参。因此在函数调用过程中，形参值发生改变，而实参中的值不会变化。而在引用调用的机制当中是将实参引用的地址传递给了形参，所以任何发生在形参上的改变实际上也发生在实参变量上。
function formatDate(date) { var d = new Date(date), month = '' + (d.getMonth() + 1), day = '' + d.getDate(), year = d.getFullYear(); if (month.length < 2) month = '0' + month; if (day.length < 2) day = '0' + day; return [year, month, day].join('-'); }使用方法：
console.log(formatDate('Sun May 13,2016'));
输出：
2016-05-13
2014-05-11
<script language="javascript"> var now = new Date(); now.setDate(now.getDate()+1); alert(now); </script>//选择预约日期时间默认 var now = new Date(); var timestamp = Date.parse(new Date())/1000; var begin_date=that.formatDate_new(now); that.setData({ 'begin_date':begin_date ,'begin_date_start':begin_date }); //console.log('1',begin_date); var service_time_index=that.data.service_time_index; var yuyue_time=that.data.service_time[service_time_index]['time']; yuyue_time=yuyue_time.split('-'); var nowdate= (new Date(begin_date+' '+yuyue_time[1]))/1000; // ios兼容处理 var date = begin_date.split(/[-]/); var time = yuyue_time[1].split(/[:]/); nowdate= new Date(date[0], date[1] - 1, date[2], time[0], time[1], '00').getTime() / 1000;let stopTime = new Date('2017-08-12 23:00:00'.replace(/-/g, '/')).getTime();兼容ios let stopTime = new Date('2017/08/12 23:00:00').getTime(); 这样的格式在ios和android上都可以进行显示