冒泡排序:比较任何两个相邻的项,如果左边比右边大,则交换它们(从小到大排序)。
function ArrayList(){
let array = [];
this.insert = function (item) {
array.push(item);
};
this.toString = function () {
return array.join();
};
this.bubbleSort = function () {
let length = array.length;
for(let i = 0; i<length; i++){
for(let j = 0; j<length - 1; j++){
if(array[j] > array[j+1]){
swap(j, j+1); //交换索引为j 和j+1 的数组元素
}
}
}
};
let swap = function (index1, index2) {
let temp = array[index1];
array[index1] = array[index2];
array[index2] = temp;
} ;
}
冒泡排序的工作过程:数组 【5,4,3,2,1】
改进的冒泡排序:冒泡排序每一轮的比较都会排好一个数据,无论是从小到大还是从大到小排序,所以以后的每一轮都可以比前一轮少比较一次
this.modifiedBubbleSort = function () {
let length = array.length;
for(let i = 0; i<length; i++){
for(let j = 0; j < length-i-1; j++){ //内循环减去外循环已跑过的轮数
if(array[j] > array[j+1]){
swap(j, j+1);
}
}
}
};
或者不应该叫改进,冒泡排序本来应该就是那样的。两者的算法复杂度都是O(n*n);
选择排序:大致思路是找到数据结构中的最小值并将其放在第一位,接着找到第二小的值并将其放在第二位,依次类推
this.selectionSort = function () {
let length = array.length;
let indexMin;
for(let i = 0; i<length; i++){
indexMin = i;
for(let j = i; j<length; j++){
if(array[indexMin] > array[j]){
indexMin = j;
}
}
if(i !== indexMin){
swap(i, indexMin);
}
}
};
选择排序的工作流程:
插入排序 :插入排序每次排一个数组项,假定第一项已经排好了,与第二项进行比较,第二项应该在第一项的前面还是后面,然后第三项插进来在进行比较,应该是插进来第一还是第二还是第三的位置。
this.insertionSort = function () {
let length = array.length,
j,temp;
for(let i = 1; i<length; i++){
j = i;
temp = array[i];
while(j>0 && array[j-1] > temp){
array[j] = array[j-1];
j--;
}
array[j] = temp;
}
};
流程:
归并排序:分治算法,将原始数组分割成较小的数组,直到每个小数组只有一个位置,接着将小数组归并成较大的数组,直到最后只有一个排序完毕的数组:
this.mergeSort = function(){
array = mergeSortRec(array);
};
let mergeSortRec = function(array){
let length = array.length;
if(length === 1) {
console.log(array);
return array;
}
let mid = Math.floor(length / 2),
left = array.slice(0, mid),
right = array.slice(mid, length);
return merge(mergeSortRec(left), mergeSortRec(right));
};
let merge = function(left, right){
let 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++]);
}
console.log(result);
return result;
};
流程:
快速排序:比较常用
this.quickSort = function(){
quick(array, 0, array.length - 1);
};
let partition = function(array, left, right) {
let pivot = array[Math.floor((right + left) / 2)],
i = left,
j = right;
console.log('pivot is ' + pivot + '; left is ' + left + '; right is ' + right);
while (i <= j) {
while (array[i] < pivot) {
i++;
console.log('i = ' + i);
}
while (array[j] > pivot) {
j--;
console.log('j = ' + j);
}
if (i <= j) {
console.log('swap ' + array[i] + ' with ' + array[j]);
swapQuickStort(array, i, j);
i++;
j--;
}
}
return i;
};
let swapQuickStort = function(array, index1, index2){
let aux = array[index1];
array[index1] = array[index2];
array[index2] = aux;
};
let quick = function(array, left, right){
let 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);
}
}
return array;
};
顺序搜索算法:顺序迭代整个数组,并将每个数组元素与搜索项作比较
this.findMaxValue = function(){
let max = array[0];
for (let i=1; i<array.length; i++){
if (max < array[i]){
max = array[i];
}
}
return max;
};
this.findMinValue = function(){
let min = array[0];
for (let i=1; i<array.length; i++){
if (min > array[i]){
min = array[i];
}
}
return min;
};
二分搜索:类似数学上的夹逼法则:
this.sequentialSearch = function(item){
for (let i=0; i<array.length; i++){
if (item === array[i]){
return i;
}
}
return -1;
};
this.binarySearch = function(item){
this.quickSort();
let low = 0,
high = array.length - 1,
mid, element;
while (low <= high){
mid = Math.floor((low + high) / 2);
element = array[mid];
console.log('mid element is ' + element);
if (element < item) {
low = mid + 1;
console.log('low is ' + low);
} else if (element > item) {
high = mid - 1;
console.log('high is ' + high);
} else {
console.log('found it');
return mid;
}
}
return -1;
};
}
(看完了相关的数据结构和基本算法,现在又忘记得差不多了,这些当作复盘,也是为了方便以后复习使用)