获得徽章 0
#每天一个知识点#
js获取页面上滚动元素
function findscrollerEl(el) {
el.onscroll = function () {
console.log(el);
};
Array.from(el.children).forEach(findscrollerEl);
}
findscrollerEl(document.body);
查找滚动元素，通过监听元素的onscroll事件，当前元素滚动时会触发onscroll事件，从而得到对应的滚动元素。
通过Array.from(el.children)查找当前元素的下级元素再递归调用findscrollerEl来给页面每个元素绑定onscroll事件。
在控制台执行以上代码，当滚动时，就会打印当前滚动的元素。
js获取页面上滚动元素
function findscrollerEl(el) {
el.onscroll = function () {
console.log(el);
};
Array.from(el.children).forEach(findscrollerEl);
}
findscrollerEl(document.body);
查找滚动元素，通过监听元素的onscroll事件，当前元素滚动时会触发onscroll事件，从而得到对应的滚动元素。
通过Array.from(el.children)查找当前元素的下级元素再递归调用findscrollerEl来给页面每个元素绑定onscroll事件。
在控制台执行以上代码，当滚动时，就会打印当前滚动的元素。
展开
评论
1
#每天一个知识点#
4. 快速排序（Quick Sort）
function quickSort(arr) {
if (arr.length <= 1) {
return arr;
}
const pivotIndex = Math.floor(arr.length / 2);
const pivot = arr.splice(pivotIndex, 1)[0];
const left = [];
const right = [];
for (const item of arr) {
if (item < pivot) {
left.push(item);
} else {
right.push(item);
}
}
return quickSort(left).concat([pivot], quickSort(right));
}
// 示例
const arr = [5, 3, 8, 4, 2];
console.log(quickSort(arr)); // output: [2, 3, 4, 5, 8]
快速排序的时间复杂度为 O(nlogn) 或 O(n^2)，其中n代表数组的长度。快速排序在平均情况下运行速度非常快，但在最坏情况下运行速度会非常慢，因为它每次选取的中轴值可能会是最大值或最小值，导致递归树非常深。
空间复杂度为 O(logn) ~ O(n)，取决于递归层数。快排使用的是分治的思想，它不需要创建额外的数组，空间复杂度比归并排序要低。
快速排序的基本思想是：从数列中挑出一个元素，称为“基准”（pivot），重新排列数列，使得比基准值小的元素放在基准前面，比基准值大的元素放在基准后面。然后分别对基准前后的子序列递归地进行快速排序，直到整个序列有序。
快速排序是最常用的排序算法之一，因为它的实现非常容易，并且具有较高的效率。
4. 快速排序（Quick Sort）
function quickSort(arr) {
if (arr.length <= 1) {
return arr;
}
const pivotIndex = Math.floor(arr.length / 2);
const pivot = arr.splice(pivotIndex, 1)[0];
const left = [];
const right = [];
for (const item of arr) {
if (item < pivot) {
left.push(item);
} else {
right.push(item);
}
}
return quickSort(left).concat([pivot], quickSort(right));
}
// 示例
const arr = [5, 3, 8, 4, 2];
console.log(quickSort(arr)); // output: [2, 3, 4, 5, 8]
快速排序的时间复杂度为 O(nlogn) 或 O(n^2)，其中n代表数组的长度。快速排序在平均情况下运行速度非常快，但在最坏情况下运行速度会非常慢，因为它每次选取的中轴值可能会是最大值或最小值，导致递归树非常深。
空间复杂度为 O(logn) ~ O(n)，取决于递归层数。快排使用的是分治的思想，它不需要创建额外的数组，空间复杂度比归并排序要低。
快速排序的基本思想是：从数列中挑出一个元素，称为“基准”（pivot），重新排列数列，使得比基准值小的元素放在基准前面，比基准值大的元素放在基准后面。然后分别对基准前后的子序列递归地进行快速排序，直到整个序列有序。
快速排序是最常用的排序算法之一，因为它的实现非常容易，并且具有较高的效率。
展开
2
2
#每天一个知识点#
3. 插入排序（Insertion Sort）
function insertionSort(arr) {
const len = arr.length;
for (let i = 1; i < len; i++) {
let j = i - 1;
const current = arr[i];
while (j >= 0 && arr[j] > current) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = current;
}
return arr;
}
// 示例
const arr = [5, 3, 8, 4, 2];
console.log(insertionSort(arr)); // output: [2, 3, 4, 5, 8]
插入排序的时间复杂度为 O(n^2)，其中n代表数组的长度。虽然插入排序时间复杂度和冒泡排序、选择排序同样地为 O(n^2)，但是在数据规模较小的时候，它比冒泡排序和选择排序更快，是一个稳定的排序算法。
空间复杂度为 O(1)，它只需要一个临时变量来存储当前处理的元素，对空间复杂度没有额外的开销。
插入排序的基本思想是：对于每个未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
插入排序相比于冒泡排序和选择排序，不需要进行太多的元素交换操作，而是通过移动元素来完成排序，在一些特定情况下效率更高一些。当数据集合基本有序时，插入排序的时间复杂度将大大降低，甚至可以达到线性级别，优化效果比较明显。
3. 插入排序（Insertion Sort）
function insertionSort(arr) {
const len = arr.length;
for (let i = 1; i < len; i++) {
let j = i - 1;
const current = arr[i];
while (j >= 0 && arr[j] > current) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = current;
}
return arr;
}
// 示例
const arr = [5, 3, 8, 4, 2];
console.log(insertionSort(arr)); // output: [2, 3, 4, 5, 8]
插入排序的时间复杂度为 O(n^2)，其中n代表数组的长度。虽然插入排序时间复杂度和冒泡排序、选择排序同样地为 O(n^2)，但是在数据规模较小的时候，它比冒泡排序和选择排序更快，是一个稳定的排序算法。
空间复杂度为 O(1)，它只需要一个临时变量来存储当前处理的元素，对空间复杂度没有额外的开销。
插入排序的基本思想是：对于每个未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
插入排序相比于冒泡排序和选择排序，不需要进行太多的元素交换操作，而是通过移动元素来完成排序，在一些特定情况下效率更高一些。当数据集合基本有序时，插入排序的时间复杂度将大大降低，甚至可以达到线性级别，优化效果比较明显。
展开
评论
1
#每天一个知识点# 2. 选择排序（Selection Sort）
function selectionSort(arr) {
const len = arr.length;
for (let i = 0; i < len - 1; i++) {
let min = i;
for (let j = i + 1; j < len; j++) {
if (arr[j] < arr[min]) {
min = j;
}
}
if (min !== i) {
[arr[i], arr[min]] = [arr[min], arr[i]];
}
}
return arr;
}
// 示例
const arr = [5, 3, 8, 4, 2];
console.log(selectionSort(arr)); // output: [2, 3, 4, 5, 8]
选择排序的时间复杂度为 O(n^2)，其中n代表数组的长度。和冒泡排序相比，选择排序的性能稍好一些。
空间复杂度为 O(1)，它只需要一个临时变量来记录最小值的下标，对空间复杂度没有额外的开销。
选择排序的基本思想是：每次从未排序的数据中选择最小的一个元素，将其放到已排序数据的末尾，直到所有数据都排完为止。
虽然选择排序的时间复杂度和冒泡排序一样，最坏情况下时间复杂度也是O(n^2)，但在实际应用中，选择排序由于其简单性和不需要额外的存储空间，可能仍然比其他高效的算法更实用。
function selectionSort(arr) {
const len = arr.length;
for (let i = 0; i < len - 1; i++) {
let min = i;
for (let j = i + 1; j < len; j++) {
if (arr[j] < arr[min]) {
min = j;
}
}
if (min !== i) {
[arr[i], arr[min]] = [arr[min], arr[i]];
}
}
return arr;
}
// 示例
const arr = [5, 3, 8, 4, 2];
console.log(selectionSort(arr)); // output: [2, 3, 4, 5, 8]
选择排序的时间复杂度为 O(n^2)，其中n代表数组的长度。和冒泡排序相比，选择排序的性能稍好一些。
空间复杂度为 O(1)，它只需要一个临时变量来记录最小值的下标，对空间复杂度没有额外的开销。
选择排序的基本思想是：每次从未排序的数据中选择最小的一个元素，将其放到已排序数据的末尾，直到所有数据都排完为止。
虽然选择排序的时间复杂度和冒泡排序一样，最坏情况下时间复杂度也是O(n^2)，但在实际应用中，选择排序由于其简单性和不需要额外的存储空间，可能仍然比其他高效的算法更实用。
展开
评论
1
#高考作文大赛#
时间被技术把持，
早晚被科技绑架，
把握时间把握命，
把握时间把握梦，
可是谁又在乎？
把握时间把握机会，
把握时间把握财富，
可是谁又在乎？
把握时间把握自由，
把握时间把握爱情，
可是谁又在乎？
把握时间把握生活，
把握时间把握梦想，
可是谁又在乎？
人们为了把握时间，
拼命加班加点，
可是谁又在乎？
人们为了把握时间，
放弃健康，放弃家庭，
可是谁又在乎？
人们为了把握时间，
放弃梦想，放弃未来，
可是谁又在乎？
把握时间变成仆人，
把握时间变成奴隶，
可是谁又在乎？
把握时间，把握生活，
把握时间，把握幸福，
可是谁又在乎？
把握时间，把握自己，
把握时间，把握未来，
可是谁又在乎？
时间从不会停止，
技术会越来越发达，
可是谁又在乎？
把握时间，把握自己，
把握时间，把握未来，
让时间成为自己的主人！
——《把握时间》
时间被技术把持，
早晚被科技绑架，
把握时间把握命，
把握时间把握梦，
可是谁又在乎？
把握时间把握机会，
把握时间把握财富，
可是谁又在乎？
把握时间把握自由，
把握时间把握爱情，
可是谁又在乎？
把握时间把握生活，
把握时间把握梦想，
可是谁又在乎？
人们为了把握时间，
拼命加班加点，
可是谁又在乎？
人们为了把握时间，
放弃健康，放弃家庭，
可是谁又在乎？
人们为了把握时间，
放弃梦想，放弃未来，
可是谁又在乎？
把握时间变成仆人，
把握时间变成奴隶，
可是谁又在乎？
把握时间，把握生活，
把握时间，把握幸福，
可是谁又在乎？
把握时间，把握自己，
把握时间，把握未来，
可是谁又在乎？
时间从不会停止，
技术会越来越发达，
可是谁又在乎？
把握时间，把握自己，
把握时间，把握未来，
让时间成为自己的主人！
——《把握时间》
展开
2
2
#每天一个知识点#
冒泡排序（Bubble Sort）
function bubbleSort(arr) {
const len = arr.length;
for (let i = 0; i < len; i++) {
for (let j = 0; j < len - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
}
}
}
return arr;
}
// 示例
const arr = [5, 3, 8, 4, 2];
console.log(bubbleSort(arr)); // output: [2, 3, 4, 5, 8]
冒泡排序的优点在于其实现简单，易于理解和编写。它适用于小型数据集合和基本有序的数据集合。
时间复杂度：冒泡排序的时间复杂度为 O(n^2)，其中n代表数组的长度。它的时间复杂度较高，当数据集规模比较大或者数据比较乱的情况下，性能会比较差。
空间复杂度：冒泡排序的空间复杂度为 O(1)，它只需要一个临时变量来交换两个元素的位置，所以它的空间复杂度比较低。
总体来说，冒泡排序的实现非常简单，但性能比较差，所以在实际开发中，一般会选择其他更优秀的排序算法，比如快速排序、归并排序等。
冒泡排序（Bubble Sort）
function bubbleSort(arr) {
const len = arr.length;
for (let i = 0; i < len; i++) {
for (let j = 0; j < len - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
}
}
}
return arr;
}
// 示例
const arr = [5, 3, 8, 4, 2];
console.log(bubbleSort(arr)); // output: [2, 3, 4, 5, 8]
冒泡排序的优点在于其实现简单，易于理解和编写。它适用于小型数据集合和基本有序的数据集合。
时间复杂度：冒泡排序的时间复杂度为 O(n^2)，其中n代表数组的长度。它的时间复杂度较高，当数据集规模比较大或者数据比较乱的情况下，性能会比较差。
空间复杂度：冒泡排序的空间复杂度为 O(1)，它只需要一个临时变量来交换两个元素的位置，所以它的空间复杂度比较低。
总体来说，冒泡排序的实现非常简单，但性能比较差，所以在实际开发中，一般会选择其他更优秀的排序算法，比如快速排序、归并排序等。
展开
评论
1