冒泡排序通过相邻元素比较交换，将最大值逐步移到末尾；2. 选择排序每次从未排序区选最小值插入已排序区末尾；3. 插入排序将未排序元素插入已排序序列的正确位置；4. 快速排序以基准分治递归排序左右子数组；5. 归并排序通过二分后合并有序子数组实现整体有序。
排序与搜索是算法中最基础也最常用的部分。JavaScript 作为一门灵活的编程语言，可以轻松实现各种经典排序和搜索算法。下面介绍几种常见的排序与搜索算法及其 JavaScript 实现。
常见排序算法实现
1. 冒泡排序（Bubble Sort）
冒泡排序通过重复遍历数组，比较相邻元素并交换位置，将最大值“冒泡”到末尾。
function bubbleSort(arr) {
const len = arr.length;
for (let i = 0; i < len; i++) {
for (let j = 0; j < len - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
}
}
}
return arr;
}
2. 选择排序（Selection Sort）
立即学习“Java免费学习笔记（深入）”；
每次从未排序部分找出最小元素，放到已排序序列的末尾。
function selectionSort(arr) {
const len = arr.length;
for (let i = 0; i < len; i++) {
let minIndex = i;
for (let j = i + 1; j < len; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
if (minIndex !== i) {
[arr[i], arr[minIndex]] = [arr[minIndex], arr[i]];
}
}
return arr;
}
3. 插入排序（Insertion Sort）
将每个元素插入到前面已排序部分的正确位置。
function insertionSort(arr) {
for (let i = 1; i < arr.length; i++) {
let current = arr[i];
let j = i - 1;
while (j >= 0 && arr[j] > current) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = current;
}
return arr;
}
4. 快速排序（Quick Sort）
采用分治法，选择一个基准值，将数组分为小于和大于基准的两部分，递归排序。
本文档主要讲述的是基于VC与Matlab的混合编程实现图像的三维显示；介绍了VC++与Matlab混合编程的一般实现方法，并实现对二维影像图的三维效果显示。 MATLAB既是一种直观、高效的计算机语言,同时又是一个科学计算平台。它为数据分析和数据可视化、算法和应用程序开发提供了最核心的数学和高级图形工具。希望本文档会给有需要的朋友带来帮助；感兴趣的朋友可以过来看看
function quickSort(arr) {
if (arr.length <= 1) return arr;
const pivot = arr[Math.floor(arr.length / 2)];
const left = arr.filter(x => x < pivot);
const middle = arr.filter(x => x === pivot);
const right = arr.filter(x => x > pivot);
return [...quickSort(left), ...middle, ...quickSort(right)];
}
5. 归并排序（Merge Sort）
将数组不断二分，直到单个元素，再合并有序子数组。
function mergeSort(arr) {
if (arr.length <= 1) return arr;
<p>const mid = Math.floor(arr.length / 2);
const left = mergeSort(arr.slice(0, mid));
const right = mergeSort(arr.slice(mid));</p><p>return merge(left, right);
}</p><p>function merge(left, right) {
let result = [];
let i = 0, j = 0;
while (i < left.length && j < right.length) {
if (left[i] < right[j]) {
result.push(left[i++]);
} else {
result.push(right[j++]);
}
}
return result.concat(left.slice(i)).concat(right.slice(j));
}</p>常见搜索算法实现
1. 线性搜索（Linear Search）
从头开始逐个检查元素，直到找到目标值。
function linearSearch(arr, target) {
for (let i = 0; i < arr.length; i++) {
if (arr[i] === target) return i;
}
return -1;
}
2. 二分搜索（Binary Search）
适用于已排序数组，通过不断缩小搜索范围，提高效率。
function binarySearch(arr, target) {
let left = 0;
let right = arr.length - 1;
while (left <= right) {
const mid = Math.floor((left + right) / 2);
if (arr[mid] === target) return mid;
if (arr[mid] < target) {
left = mid + 1;
} else {
right = mid - 1;
}
}
return -1;
}
使用建议与性能对比
不同算法在时间复杂度上有明显差异：
- 冒泡、选择、插入排序：平均时间复杂度 O(n²)，适合小数据集
- 快速排序：平均 O(n log n)，实际应用广泛
- 归并排序：稳定 O(n log n)，适合需要稳定排序的场景
- 线性搜索：O(n)，通用但效率低
- 二分搜索：O(log n)，要求数据有序
在实际开发中，虽然 JavaScript 提供了 Array.prototype.sort() 和 indexOf() 等内置方法，理解底层原理有助于优化性能和处理特殊需求。
基本上就这些。掌握这些基础算法，能为更复杂的逻辑打下坚实基础。
