常見排序及查找算法的JS實現
1.冒泡排序
function bubbleSort(arr) {
var temp; //臨時交換變量
let n = arr.length; //記錄數組長度
let count=0; //計數，記錄一共進行了多少次交換
//document.write('數組長度爲：'+n+'<br />') //輸出數組成都
for (let i=0; i<n; i++) { //外層循環,排序出數組的arr[i]的值
let flag=0; //交換標誌
for (let j=n-1; j>i; j-- ) { //內層循環，從底往上冒泡，將小泡浮到arr[i]位置
//alert(0);
if (arr[j-1]>arr[j]) { //比較兩個元素大小，並交換位置
temp=arr[j-1];
arr[j-1]=arr[j];
arr[j]=temp;
flag=flag+1; //肯定交換標誌
count=count+1; //記錄比較元素的次數
//console.log(flag);
//console.log('共交換了：'+count+'次');
}
//console.log(arr) //輸出數組
}
if (flag==0) { //跳出循環
break;
}
}
document.write('冒泡排序執行次數爲：'+count+'<br />')
return arr; //返回數組
}
2.簡單選擇排序
function selectSort(arr) {
let temp;
let n = arr.length;
let count =0;
for (let i=0; i<n; i++) {
for (let j= i+1; j<n; j++) {
count++;
if (arr[j]<arr[i]) {
temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}
}
}
document.write('簡單選擇排序執行次數爲：'+count);
return arr;
}
3.直接插入排序
function insertSort(arr) {
let i,j;
let n= arr.length;
let count = 0;
for (i=1; i<n; i++) {
if (arr[i]<arr[i-1]) {
arr[-1] = arr[i]; //將i位置的值給哨兵
for (j=i-1; arr[j]>arr[-1];j--) { //當i位置前面的值比哨兵小，後移i位置的值，並插入哨兵到原先i位置
arr[j+1] = arr[j];
arr[j] = arr[-1];
count++;
}
}
}
document.write('直接插入排序執行次數爲：'+count);
return arr;
}
4.希爾排序
function shellSort(arr) {
let d = arr.length;
let i;
let temp; //暫存
do {
//設置增量
d = Math.floor(d / 3) + 1;
for (i = d ; i < arr.length; i++) {
if (arr[i] < arr[i - d]) {
temp = arr[i];
for (var j = i - d; j >= 0 && temp < arr[j]; j -=d) {
arr[j + d] = arr[j];
arr[j] = temp;
}
}
}
}
while (d > 1)
return arr;
}
5.去重算法
function unique(arr) {
let brr=[];
for (let i=0; i<arr.length; i++) {
if (brr.indexOf(arr[i]) < 0) {
brr.push(arr[i]);
}
}
return brr;
}
6.快速排序
function partition(arr,low,high) {
let temp=arr[low], //基準值
changetemp; //用於交換的臨時變量
while (low<high) {
while (low<high && arr[high]>=temp) {
high--;
} //當從high往前掃時，大於基準值時，high--
//swap(arr, low, high); //當從high往前掃時，小於基準值時，交換基準值和arr[high]位置
changetemp=arr[low];
arr[low]=arr[high];
arr[high]=changetemp;
while(low<high && arr[low]<=temp) {
low++;
} //當從low日後掃時，小於基準值時，low++
//swap(arr, low, high); //當從low日後掃時，大於基準值時，交換基準值和arr[low]的位置
changetemp=arr[low];
arr[low]=arr[high];
arr[high]=changetemp;
}
return low;
}
//快速排序
function quick(arr,low,high) {
let pivot; //定義樞軸值
if (low < high) {
pivot = partition(arr,low,high); //求得第一個基準值第一次排序完的位置做爲樞軸值
quick(arr,low,pivot-1); //對樞軸值前面的序列排序
document.write(pivot+'<br />');
quick(arr, pivot+1, high); //對樞軸值後面的序列排序
}
//return pivot; //返回樞軸值
return arr; //返回排序後的數組
}
7.使用JS方法並將形參減小爲僅輸入一個數組的快排
function quickSort (arr) {
if (arr.length<=1) {
return arr;
}
let left = [],
right = [],
pivotIndex = Math.floor(arr.length/2);
let pivot = arr.splice(pivotIndex,1)[0];
for (let i=0; i<arr.length; i++) {
if (arr[i] <= pivot) {
left.push(arr[i]);
} else {
right.push(arr[i]);
}
}
return quickSort(left).concat(pivot,quickSort(right));
}
8.JS實現歸併排序
function mergeSort (arr) {
//合併兩個有序數組爲一個數組
function merge(left,right) {
let arr=[];
while (left.length && right.length) {
if (left[0] < right[0]) {
arr.push(left.shift());
} else {
arr.push(right.shift());
}
}
return arr.concat(left,right);
}
let len=arr.length;
if (len <= 1) {
return arr;
} else {
let index = Math.floor(len/2),
left = arr.slice(0,index),
right = arr.slice(index);
return merge(mergeSort(left),mergeSort(right));//用遞歸對數組進行拆分，再返回合併後的數組
}
}
9.堆排序
function heapSort(array) {
var result = array.slice(0);
function swap(array, i, j) {
var temp = array[i];
array[i] = array[j];
array[j] = temp;
}
function maxHeapify(array, index, heapSize) {
var iMax, iLeft, iRight;
while (true) {
iMax = index;
iLeft = 2 * index + 1;
iRight = 2 * (index + 1);
if (iLeft < heapSize && array[index] < array[iLeft]) {
iMax = iLeft;
}
if (iRight < heapSize && array[iMax] < array[iRight]) {
iMax = iRight;
}
if (iMax != index) {
swap(array, iMax, index);
index = iMax;
} else {
break;
}
}
}
function buildMaxHeap(array) {
var i, iParent = Math.floor(array.length / 2) - 1;
for (i = iParent; i >= 0; i--) {
maxHeapify(array, i, array.length);
}
}
function sort(array) {
buildMaxHeap(array);
for (var i = array.length - 1; i > 0; i--) {
swap(array, 0, i);
maxHeapify(array, 0, i);
}
return array;
}
return sort(result);
}
10.JS實現順序查找
function listSearch(arr,data) {
var result;
for (var i = 0;i<arr.length; i++) {
if (arr[i] === data) {
result = i;
break;
}
}
if (result === undefined) {
result = -1;
}
return result
}
11.JS實現二分查找
function binarySearch(arr,key) {
var low = 0,
high = arr.length-1;
while (low <= high) {
var mid = parseInt((low+high)/2);
if (key < arr[mid]) {
high = mid-1;
} else if (key > arr[mid]) {
low = mid+1;
} else {
return mid;
}
}
return -1;
}
12.統計字符串中出現次數最多的字符
function count(str) {
var obj = {},
mostStr = "",
key;
for(var i = 0; i<str.length; i++) {
if (!obj[str[i]]) {
obj[str[i]] = 1;
} else {
obj[str[i]]++;
}
}
for(key in obj) {
if (mostStr === "" || obj[key] > obj[mostStr]) {
mostStr = key
}
}
return [mostStr,obj[mostStr]]
}
13.斐波拉契數列遞歸寫法
function fibonicco(n) {
if (n ===1 || n === 2) {
return 1;
} else {
return fibonicco(n-1)+fibonicco(n-2);
}
}
14.斐波拉契數列迭代寫法
function fibonicco(n) {
var a,b,res;
a = b = res =1;
for (var i =3; i<=n; i++) {
res = a+b;
a = b;
b = res;
}
return res;
}
相關文章
- 1. 常見的排序算法——JS實現
- 2. js常見排序算法實現
- 3. 常見排序算法及JAVA實現
- 4. 常見排序算法及實現
- 5. 常見查找算法(Java實現)
- 6. 常見查找算法-JAVA實現
- 7. java實現常見查找算法
- 8. JS常見的排序算法
- 9. 常見算法——七大查找算法和八大排序
- 10. 面試常見算法-排序查找算法
- 更多相關文章...
- • Eclipse 查找 - Eclipse 教程
- • ADO 排序 - ADO 教程
- • 算法總結-二分查找法
- • 算法總結-歸併排序
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 常見的排序算法——JS實現
- 2. js常見排序算法實現
- 3. 常見排序算法及JAVA實現
- 4. 常見排序算法及實現
- 5. 常見查找算法(Java實現)
- 6. 常見查找算法-JAVA實現
- 7. java實現常見查找算法
- 8. JS常見的排序算法
- 9. 常見算法——七大查找算法和八大排序
- 10. 面試常見算法-排序查找算法