在开始之前，我们首先创建一个数组来表示待排序和搜索算法的数据结构。
function ArrayList(){
var array = [];
this.insert = function(item){
array.push(item);
};
this.toString = function(){
return array.join();
};
} ArrayList下的方法，关于排序和搜索的函数
- 冒泡排序： this.bubbleSort
- 选择排序： this.selectionSort
- 插入排序： this.insertionSort
- 并归排序： this.mergeSort
- 快速排序： this.quickSort
- 顺序搜索： this.sequentialSearch
- 二分搜索： this.binarySearch
详细算法如下：
function ArrayList(){
var array = [];
this.insert = function(item){
array.push(item);
};
this.toString = function(){
return array.join();
};
/*
* 冒泡排序: 比较任何两个相邻的元素， 如果第一个比第二个大则交换他们。
时间复杂度: 最好：O(n), 一般情况： O(n2) 最差情况： O(n2) |（n的平方）
打开函数中的console可以看到排序次数和每次移动的元素
*/
this.bubbleSort = function(){
var length = array.length;
for(var i=0; i<length; i++){
for(var j=0; j<length-1-i; j++){
if(array[j] > array[j+1]){
swap(j, j+1); //交换函数后面有定义
//console.log(this.toString());
}
}
}
}
/*
* 选择排序：找到数据结构中的最小值并且放在第一位，接着找到第二小的值放在第二位，依次类推
时间复杂度：O(n2) |最好一般最差都为n的平方。
打开函数中的console可以看到排序次数和每次移动的元素
*/
this.selectSort = function(){
var length = array.length,
indexMin;
for (var i =0; i < length; i++) {
indexMin = i;
for(var j=i; j < length; j++){
if(array[indexMin] > array[j]){
indexMin = j;
}
}
if(i !== indexMin){
swap(i, indexMin);
console.log(this.toString());
}
}
};
var swap = function(index1, index2){
var aux = array[index1];
array[index1] = array[index2];
array[index2] = aux;
};
/*
* 插入排序： 每次排一个数组，以此方式构建组最后的排序数组。首先把要比较的一项放在临时变量temp中拿第二项和第一项比较如果第一项大于第二项则交换，然后拿第三项和第二项比较，如果第二项大于第三项，把第二项放在第三项中，再拿第二项和第一项比较，如果第一项大于第二项把第一项放在第二项上，把temp中的值放到第一项上， 如果第二项不小于第一项，就把temp放到第二项上面，依次类推。。。
时间复杂度： 最好： O(n) 一般： O(n2) 最差 O(n2)
*/
this.insertSort = function(){
var length = array.length,
j, temp;
for(var i = 1; i < length; i++){
j = i;
temp = array[i];
while(j>0 && array[j-1] > temp){
array[j] = array[j-1];
j--;
console.log(this.toString());
}
array[j] = temp;
}
};
/*
* 并归排序：并归排序是一种分治算法， 其思想是将原来的数组切成较小的数组，直到每个小数组只有一个元素，接着将小数组归并为较大的数组， 直到最后一个排序完毕的大数组。
时间复杂度为： 最好一般最差：O(nlogn);
*/
this.mergeSort = function(){
array = mergeSortRec(array);
}
var mergeSortRec = function(array){
var length = array.length;
if (length === 1) {
return array;
}
var mid = Math.floor(length / 2),
left = array.slice(0, mid),
right = array.slice(mid, length);
return merge(mergeSortRec(left), mergeSortRec(right));
};
var merge = function(left, right){
var result = [],
il = 0,
ir = 0;
while(il < left.length && ir < right.length){
if(left[il] < right[ir]){
result.push(left[il++]);
}else{
result.push(right[ir++]);
}
}
while(il < left.length){
result.push(left[il++]);
}
while(ir < right.length){
result.push(right[ir++]);
}
return result;
};
/*
*快速排序: ①首先从数组中选择中间一项作为主元素。②然后创建两个指针，左边一个指向数组的第一项，右边的一个指向数组的最后一项。移动左边的指针直到我们找到一个比主元素大的元素，接着，移动右边的指针直到找到一个比主元素小的元素，然后交换它们，重复这个过程直到左边的指针超过右边的指针。③接着较小的元素组成一个子数组，较大的元素组成一个子数组，重复步骤①②直到数组完全排序。
时间复杂度：最好一般： O(nlogn) 最差 O(n2)
*/
this.quickSort = function(){
quick(array, 0, array.length-1);
};
var quick = function(array, left, right){
var index;
if(array.length > 1){
index = partition(array, left, right);
if(left < index-1 ){
quick(array, left, index - 1 );
}
if(index < right ){
quick(array, index, right);
}
}
}
var partition = function(array, left, right){
var pivot = array[Math.floor((right + left) / 2)],
i = left,
j = right;
while(i <= j){
while(array[i] < pivot){
i++;
}
while(array[j] > pivot){
j--;
}
if(i <= j){
swapQuickStort(array, i, j);
i++;
j--;
}
}
return i;
};
var swapQuickStort = function(array, index1, index2){
var aux = array[index1];
array[index1] = array[index2];
array[index2] = aux;
};
/*
* 查找 直接查找 最差情况:O(n)
*/
this.sequentialSearch = function(item){
for (var i = array.length - 1; i >= 0; i--) {
if(item === array[i]){
return i;
}
}
return -1;
};
/*
*二分法查找 查找前要把要查找的元素排序 最差情况： O(log(n))
*/
this.binarySearch = function(item){
this.quickSort();
var low = 0,
high = array.length -1,
mid, element;
while(low <= high){
mid = Math.floor((low + high)/2);
element = array[mid];
if(element < item){
low = mid +1;
}else if(element > item){
high = mid -1;
}else{
return mid;
}
}
return -1;
}
}
function createNonSortedArray(size){ //为数组添加元素的函数
var array = new ArrayList();
for(var i= size; i>0; i--){
// array.insert(Math.floor(Math.random(1, size)*10));
array.insert(i);
}
return array;
}
var array = createNonSortedArray(7);
console.log("排序前：" + array.toString());
array.bubbleSort();
console.log("冒泡排序：" + array.toString());
array.selectSort();
console.log("选择排序：" + array.toString());
array.insertSort();
console.log("插入排序：" + array.toString());
array.mergeSort();
console.log("并归排序："+ array.toString());
array.quickSort();
console.log("快速排序："+ array.toString());
console.log("直接查找：" + array.sequentialSearch(3));
console.log("二分查找：" + array.binarySearch(3));
运行结果：
