算法学习:一维数组的排序算法

【排序算法】八种排序算法可视化过程_哔哩哔哩_bilibili

1,冒泡排序:

冒泡排序(Bubble Sort):

  • 冒泡排序是一种简单的排序算法,它通过重复地交换相邻的元素,直到整个序列有序。
  • 算法思路是:从第一个元素开始,依次比较相邻的两个元素,如果前者大于后者,就交换它们的位置。这样一轮下来,最大的元素就会"冒泡"到数组的末尾。
  • 重复这个过程,直到整个数组有序。

C语言实现: 

void bubble_sort(int arr[], int n) {// 冒泡排序实现for (int i = 0; i < n - 1; i++) {for (int j = 0; j < n - i - 1; j++) {if (arr[j] > arr[j + 1]) {// 交换 arr[j] 和 arr[j+1]int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}
}

python实现: 

def bubble_sort(arr):n = len(arr)for i in range(n):for j in range(0, n - i - 1):if arr[j] > arr[j + 1]:arr[j], arr[j + 1] = arr[j + 1], arr[j]return arr

2,选择排序:

选择排序(Selection Sort):

  • 选择排序是一种简单直观的排序算法。
  • 算法思路是:首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,放到已排序序列的末尾。
  • 重复这个过程,直到整个数组有序。

C语言实现:

void selection_sort(int arr[], int n) {// 选择排序实现for (int i = 0; i < n - 1; i++) {int min_idx = i;for (int j = i + 1; j < n; j++) {if (arr[j] < arr[min_idx]) {min_idx = j;}}// 交换 arr[i] 和 arr[min_idx]int temp = arr[i];arr[i] = arr[min_idx];arr[min_idx] = temp;}
}

python实现:

def selection_sort(arr):n = len(arr)for i in range(n):min_idx = ifor j in range(i+1, n):if arr[j] < arr[min_idx]:min_idx = jarr[i], arr[min_idx] = arr[min_idx], arr[i]return arr

3,插入排序:

插入排序(Insertion Sort):

  • 插入排序是一种简单直观的排序算法。
  • 算法思路是:将数组中的元素逐个插入到已排序的子数组中,直到整个数组有序。
  • 具体过程是:从第二个元素开始,将当前元素与已排序的子数组进行比较和插入。

C语言实现:

void insertion_sort(int arr[], int n) {// 插入排序实现for (int i = 1; i < n; i++) {int key = arr[i];int j = i - 1;while (j >= 0 && arr[j] > key) {arr[j + 1] = arr[j];j--;}arr[j + 1] = key;}
}

python实现: 

def insertion_sort(arr):n = len(arr)for i in range(1, n):key = arr[i]j = i - 1while j >= 0 and key < arr[j]:arr[j + 1] = arr[j]j -= 1arr[j + 1] = keyreturn arr

4, 堆排序:

堆排序(Heap Sort):

  • 堆排序利用二叉堆的特性进行排序。
  • 算法思路是:首先将待排序数组构建成一个最大堆,然后将堆顶元素(即最大值)与堆末尾元素交换,然后对剩余元素重新调整为最大堆,重复这个过程直到整个数组有序。

C语言实现:

void heapify(int arr[], int n, int i) {//    // 堆排序实现int largest = i;int left = 2 * i + 1;int right = 2 * i + 2;if (left < n && arr[left] > arr[largest])largest = left;if (right < n && arr[right] > arr[largest])largest = right;if (largest != i) {// 交换 arr[i] 和 arr[largest]int temp = arr[i];arr[i] = arr[largest];arr[largest] = temp;heapify(arr, n, largest);}
}void heap_sort(int arr[], int n) {// 堆排序实现// 构建最大堆for (int i = n / 2 - 1; i >= 0; i--)heapify(arr, n, i);// 从堆中提取元素for (int i = n - 1; i > 0; i--) {// 交换 arr[0] 和 arr[i]int temp = arr[0];arr[0] = arr[i];arr[i] = temp;heapify(arr, i, 0);}
}

python实现:

def heapify(arr, n, i):largest = ileft = 2 * i + 1right = 2 * i + 2if left < n and arr[largest] < arr[left]:largest = leftif right < n and arr[largest] < arr[right]:largest = rightif largest != i:arr[i], arr[largest] = arr[largest], arr[i]heapify(arr, n, largest)def heap_sort(arr):n = len(arr)# 构建大顶堆for i in range(n // 2 - 1, -1, -1):heapify(arr, n, i)# 逐步将堆顶元素与末尾元素交换并重新调整堆for i in range(n - 1, 0, -1):arr[i], arr[0] = arr[0], arr[i]heapify(arr, i, 0)return arr

5,快速排序:

它的基本思想是:

  1. 从数列中挑出一个元素,称为 "基准"(pivot)。
  2. 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面。在这个分区结束之后,该基准就处于数列的中间位置。这个称为分区(partition)操作。
  3. 递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。

 C语言实现:

//快速排序
// 交换两个元素
void swap(int *a, int *b) {int temp = *a;*a = *b;*b = temp;
}// 分区操作
int partition(int arr[], int low, int high) {int pivot = arr[high];  // 将最后一个元素选为基准int i = (low - 1);      // 较小元素的索引for (int j = low; j <= high - 1; j++) {// 如果当前元素小于或等于 pivotif (arr[j] <= pivot) {i++;            // 将较小元素的索引递增swap(&arr[i], &arr[j]);}}swap(&arr[i + 1], &arr[high]);return (i + 1);
}// 快速排序函数
void quickSort(int arr[], int low, int high) {if (low < high) {int pi = partition(arr, low, high);// 递归地对分区进行排序quickSort(arr, low, pi - 1);quickSort(arr, pi + 1, high);}
}

python实现:

def partition(arr, low, high):i = (low-1)pivot = arr[high]for j in range(low, high):if arr[j] < pivot:i = i+1arr[i], arr[j] = arr[j], arr[i]arr[i+1], arr[high] = arr[high], arr[i+1]return (i+1)

 6,并归排序:

  • 归并排序是一种采用分治策略的高效排序算法。
  • 算法思路是:将待排序数组递归地分成两半,直到每个子数组只有一个元素,然后将这些子数组合并,得到最终有序的数组。
  • 具体过程是:将数组一分为二,递归地对两个子数组进行排序,然后将两个有序的子数组合并成一个有序数组。

 C语言实现:

// 并归排序
void merge(int arr[], int left[], int left_size, int right[], int right_size) {int i = 0, j = 0, k = 0;// 合并 left 和 right 数组while (i < left_size && j < right_size) {if (left[i] < right[j]) {arr[k++] = left[i++];} else {arr[k++] = right[j++];}}// 将剩余元素添加到 arr 中while (i < left_size) {arr[k++] = left[i++];}while (j < right_size) {arr[k++] = right[j++];}
}void merge_sort(int arr[], int size) {if (size <= 1) {return;}int mid = size / 2;int *left = (int *)malloc(mid * sizeof(int));int *right = (int *)malloc((size - mid) * sizeof(int));// 递归地对左右子数组进行排序for (int i = 0; i < mid; i++) {left[i] = arr[i];}merge_sort(left, mid);for (int i = mid; i < size; i++) {right[i - mid] = arr[i];}merge_sort(right, size - mid);// 合并左右子数组merge(arr, left, mid, right, size - mid);// 释放动态分配的内存free(left);free(right);
}

python实现:

def merge_sort(arr):if len(arr) > 1:mid = len(arr) // 2L = arr[:mid]R = arr[mid:]merge_sort(L)merge_sort(R)i = j = k = 0while i < len(L) and j < len(R):if L[i] < R[j]:arr[k] = L[i]i += 1else:arr[k] = R[j]j += 1k += 1while i < len(L):arr[k] = L[i]i += 1k += 1while j < len(R):arr[k] = R[j]j += 1k += 1return arr

7,举例子 

来随机生成一个长度为100,000的一维数组,并使用上述算法进行排序。

(由于数据量太大,电脑可能由于内存问题,一块运行会导致C语言代码崩溃,建议便注释边运行,python不会出现种情况。非计算机专业学生,说法错误欢迎指正)

C语言版代码:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>#define SIZE 100000void bubble_sort(int arr[], int n) {// 冒泡排序实现for (int i = 0; i < n - 1; i++) {for (int j = 0; j < n - i - 1; j++) {if (arr[j] > arr[j + 1]) {// 交换 arr[j] 和 arr[j+1]int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}
}void selection_sort(int arr[], int n) {// 选择排序实现for (int i = 0; i < n - 1; i++) {int min_idx = i;for (int j = i + 1; j < n; j++) {if (arr[j] < arr[min_idx]) {min_idx = j;}}// 交换 arr[i] 和 arr[min_idx]int temp = arr[i];arr[i] = arr[min_idx];arr[min_idx] = temp;}
}void insertion_sort(int arr[], int n) {// 插入排序实现for (int i = 1; i < n; i++) {int key = arr[i];int j = i - 1;while (j >= 0 && arr[j] > key) {arr[j + 1] = arr[j];j--;}arr[j + 1] = key;}
}void heapify(int arr[], int n, int i) {//    // 堆排序实现int largest = i;int left = 2 * i + 1;int right = 2 * i + 2;if (left < n && arr[left] > arr[largest])largest = left;if (right < n && arr[right] > arr[largest])largest = right;if (largest != i) {// 交换 arr[i] 和 arr[largest]int temp = arr[i];arr[i] = arr[largest];arr[largest] = temp;heapify(arr, n, largest);}
}void heap_sort(int arr[], int n) {// 堆排序实现// 构建最大堆for (int i = n / 2 - 1; i >= 0; i--)heapify(arr, n, i);// 从堆中提取元素for (int i = n - 1; i > 0; i--) {// 交换 arr[0] 和 arr[i]int temp = arr[0];arr[0] = arr[i];arr[i] = temp;heapify(arr, i, 0);}
}// 并归排序
void merge(int arr[], int left[], int left_size, int right[], int right_size) {int i = 0, j = 0, k = 0;// 合并 left 和 right 数组while (i < left_size && j < right_size) {if (left[i] < right[j]) {arr[k++] = left[i++];} else {arr[k++] = right[j++];}}// 将剩余元素添加到 arr 中while (i < left_size) {arr[k++] = left[i++];}while (j < right_size) {arr[k++] = right[j++];}
}void merge_sort(int arr[], int size) {if (size <= 1) {return;}int mid = size / 2;int *left = (int *)malloc(mid * sizeof(int));int *right = (int *)malloc((size - mid) * sizeof(int));// 递归地对左右子数组进行排序for (int i = 0; i < mid; i++) {left[i] = arr[i];}merge_sort(left, mid);for (int i = mid; i < size; i++) {right[i - mid] = arr[i];}merge_sort(right, size - mid);// 合并左右子数组merge(arr, left, mid, right, size - mid);// 释放动态分配的内存free(left);free(right);
}//快速排序
// 交换两个元素
void swap(int *a, int *b) {int temp = *a;*a = *b;*b = temp;
}// 分区操作
int partition(int arr[], int low, int high) {int pivot = arr[high];  // 将最后一个元素选为基准int i = (low - 1);      // 较小元素的索引for (int j = low; j <= high - 1; j++) {// 如果当前元素小于或等于 pivotif (arr[j] <= pivot) {i++;            // 将较小元素的索引递增swap(&arr[i], &arr[j]);}}swap(&arr[i + 1], &arr[high]);return (i + 1);
}// 快速排序函数
void quickSort(int arr[], int low, int high) {if (low < high) {int pi = partition(arr, low, high);// 递归地对分区进行排序quickSort(arr, low, pi - 1);quickSort(arr, pi + 1, high);}
}int main() {int arr[SIZE];// 生成随机数组srand(time(NULL));for (int i = 0; i < SIZE; i++) {arr[i] = rand() % 1000000;}// 冒泡排序 // Bubble sort time: 21.614000 secondsint bubble_arr[SIZE];memcpy(bubble_arr, arr, sizeof(arr));clock_t bubble_start = clock();bubble_sort(bubble_arr, SIZE);clock_t bubble_end = clock();printf("Bubble sort time: %f seconds\n", (double)(bubble_end - bubble_start) / CLOCKS_PER_SEC);//// // 选择排序 //Selection sort time: 4.120000 seconds// int select_arr[SIZE];// memcpy(select_arr, arr, sizeof(arr));// clock_t select_start = clock();// selection_sort(select_arr, SIZE);// clock_t select_end = clock();// printf("Selection sort time: %f seconds\n", (double)(select_end - select_start) / CLOCKS_PER_SEC);//// // 插入排序 //Insertion sort time: 2.663000 seconds// int insert_arr[SIZE];// memcpy(insert_arr, arr, sizeof(arr));// clock_t insert_start = clock();// insertion_sort(insert_arr, SIZE);// clock_t insert_end = clock();// printf("Insertion sort time: %f seconds\n", (double)(insert_end - insert_start) / CLOCKS_PER_SEC);//// // 堆排序 //Heap sort time: 0.015000 seconds// int heap_arr[SIZE];// memcpy(heap_arr, arr, sizeof(arr));// clock_t heap_start = clock();// heap_sort(heap_arr, SIZE);// clock_t heap_end = clock();// printf("Heap sort time: %f seconds\n", (double)(heap_end - heap_start) / CLOCKS_PER_SEC);//// // 归并排序 //Merge sort time: 0.035000 seconds// int merge_arr[SIZE];// memcpy(merge_arr, arr, sizeof(arr));// clock_t merge_start = clock();// merge_sort(merge_arr, SIZE);// clock_t merge_end = clock();// printf("Merge sort time: %f seconds\n", (double)(merge_end - merge_start) / CLOCKS_PER_SEC);// //快速排序 //Quick sort time: 0.010000 seconds// int quickSort_arr[SIZE];// memcpy(quickSort_arr, arr, sizeof(arr));// clock_t quick_start = clock();// int n = sizeof(quickSort_arr) / sizeof(quickSort_arr[0]);// quickSort(quickSort_arr, 0, n-1);// clock_t quick_end = clock();// printf("Quick sort time: %f seconds\n", (double)(quick_end - quick_start) / CLOCKS_PER_SEC);return 0;
}

python版代码:

import random
import time# 冒泡排序: Bubble sort time: 663.5839667320251 seconds
def bubble_sort(arr):n = len(arr)for i in range(n):for j in range(0, n - i - 1):if arr[j] > arr[j + 1]:arr[j], arr[j + 1] = arr[j + 1], arr[j]return arr# 选择排序: Selection sort time: 285.8419885635376 seconds
def selection_sort(arr):n = len(arr)for i in range(n):min_idx = ifor j in range(i+1, n):if arr[j] < arr[min_idx]:min_idx = jarr[i], arr[min_idx] = arr[min_idx], arr[i]return arr# 插入排序:
def insertion_sort(arr):n = len(arr)for i in range(1, n):key = arr[i]j = i - 1while j >= 0 and key < arr[j]:arr[j + 1] = arr[j]j -= 1arr[j + 1] = keyreturn arr# 归并排序: Merge sort time: 0.539679765701294 seconds
def merge_sort(arr):if len(arr) > 1:mid = len(arr) // 2L = arr[:mid]R = arr[mid:]merge_sort(L)merge_sort(R)i = j = k = 0while i < len(L) and j < len(R):if L[i] < R[j]:arr[k] = L[i]i += 1else:arr[k] = R[j]j += 1k += 1while i < len(L):arr[k] = L[i]i += 1k += 1while j < len(R):arr[k] = R[j]j += 1k += 1return arr# 快速排序: Quick sort time: 0.31060314178466797 seconds
def partition(arr, low, high):i = (low-1)pivot = arr[high]for j in range(low, high):if arr[j] < pivot:i = i+1arr[i], arr[j] = arr[j], arr[i]arr[i+1], arr[high] = arr[high], arr[i+1]return (i+1)def quick_sort(arr, low, high):if low < high:pi = partition(arr, low, high)quick_sort(arr, low, pi-1)quick_sort(arr, pi+1, high)return arr# 堆排序
def heapify(arr, n, i):largest = ileft = 2 * i + 1right = 2 * i + 2if left < n and arr[largest] < arr[left]:largest = leftif right < n and arr[largest] < arr[right]:largest = rightif largest != i:arr[i], arr[largest] = arr[largest], arr[i]heapify(arr, n, largest)def heap_sort(arr):n = len(arr)# 构建大顶堆for i in range(n // 2 - 1, -1, -1):heapify(arr, n, i)# 逐步将堆顶元素与末尾元素交换并重新调整堆for i in range(n - 1, 0, -1):arr[i], arr[0] = arr[0], arr[i]heapify(arr, i, 0)return arr# 生成随机数组
data = [random.randint(0, 1000000) for _ in range(100000)]# 冒泡排序 Bubble sort time: 663.5839667320251 seconds
start_time = time.time()
bubble_sorted = bubble_sort(data.copy())
bubble_time = time.time() - start_time
print("Bubble sort time:", bubble_time, "seconds")
#
# 选择排序 Selection sort time: 285.8419885635376 seconds
start_time = time.time()
selection_sorted = selection_sort(data.copy())
selection_time = time.time() - start_time
print("Selection sort time:", selection_time, "seconds")
#
# 插入排序 Insertion sort time: 396.2825345993042 seconds
start_time = time.time()
insertion_sorted = insertion_sort(data.copy())
insertion_time = time.time() - start_time
print("Insertion sort time:", insertion_time, "seconds")
#
# 归并排序 Merge sort time: 0.539679765701294 seconds
start_time = time.time()
merge_sorted = merge_sort(data.copy())
merge_time = time.time() - start_time
print("Merge sort time:", merge_time, "seconds")
#
# 快速排序 Quick sort time: 0.31060314178466797 seconds
start_time = time.time()
quick_sorted = quick_sort(data.copy(), 0, len(data) - 1)
quick_time = time.time() - start_time
print("Quick sort time:", quick_time, "seconds")# 堆排序 heap_sorted time: heap_sorted time: 0.8571550846099854 seconds
start_time = time.time()
heap_sorted = heap_sort(data.copy())
heap_sorted_time = time.time() - start_time
print("heap_sorted time:", heap_sorted_time, "seconds")

结果对比:

不仅是算法上,C与python的执行效率上都有区别 (实验存在偶然性,本文提供代码可以自己验证)

绘图代码: 

import matplotlib.pyplot as pltalgorithms_c = ['Bubble Sort','Selection Sort','Insertion Sort','Merge Sort','Quick Sort','Heap Sort']
times_c = ['21.614000','4.120000','2.663000','0.035000','0.010000','0.015000']algorithms_python = ['Bubble Sort','Selection Sort','Insertion Sort','Merge Sort','Quick Sort','Heap Sort']
times_python = ['663.583','285.841','396.282','0.539','0.310','0.857']plt.figure(figsize=(25, 12))
plt.subplot(1, 2, 1)
plt.bar(algorithms_c, times_c)
plt.xlabel('Sorting Algorithms')
plt.ylabel('Time (seconds)')
plt.title('Comparison of Sorting Algorithms')
plt.xticks(rotation=45)
plt.title('Inference Time of Sorting Algorithms in C')plt.subplot(1,2,2)
plt.bar(algorithms_c, times_c,color='red')
plt.xlabel('Sorting Algorithms')
plt.ylabel('Time (seconds)')
plt.title('Comparison of Sorting Algorithms')
plt.xticks(rotation=45)
plt.title('Inference Time of Sorting Algorithms in Python')
plt.show()

 【排序算法】八种排序算法可视化过程_哔哩哔哩_bilibili

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/410428.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

51单片机最快能生成多高频率的方波?

前言 在嵌入式系统开发中&#xff0c;51 单片机作为一种非常非常非常经典&#xff0c;贯穿上下几十年的微控制器&#xff0c;被广泛应用于各种电子项目中。其中&#xff0c;生成特定频率的方波信号是一项常见的需求。 那么&#xff0c;51 单片机究竟能以多快的速度生成方波呢&…

c++类的继承

1.直接继承父类的方法 #include <iostream> #include <string>using namespace std; class Person{ public:void eat(){cout<<"在吃饭"<<endl;} }; class Student : public Person{ private:int age; public:string name;Student() {cout &…

Spring security 密码加密使用

一、密码加密 2011年12月21日&#xff0c;有人在网络上公开了一个包含600万个CSDN 用户资料的数据库&#xff0c;数据全部为明文储存&#xff0c;包含用户名、密码以及注册邮箱。事件发生后CSDN 在微博、官方网站等渠道发出了声明、解释说此数据库系2009 年备份所用&#xff0c…

外包干了2年,女朋友跑了...

&#x1f345; 点击文末小卡片&#xff0c;免费获取软件测试全套资料&#xff0c;资料在手&#xff0c;涨薪更快 简单的说下&#xff0c;我大学的一个同学&#xff0c;毕业后我自己去了自研的公司&#xff0c;他去了外包&#xff0c;快两年了我薪资、技术各个方面都有了很大的…

Salesforce篇——如何在lightning页面添加ListviewButton使用lwc组件

1.创建lwc组件&#xff0c;用于展示listview已选数据&#xff1a; html&#xff1a; <template><lightning-card title"Selected Records"><p>Selected Record IDs: {selectedIds}</p><lightning-button label"返回" onclick…

Spring中Bean的生命周期管理

Spring框架中的Bean生命周期是指从创建到销毁的整个过程。在这个过程中&#xff0c;Spring容器会负责管理Bean的状态和行为。以下是Spring中Bean生命周期的详细解释&#xff1a; 实例化&#xff1a;Spring容器根据Bean的定义信息&#xff0c;通过反射机制创建Bean对象。 设置属…

“阉割版”ADS还能遥遥领先吗?

文/王俣祺 导语&#xff1a;随着特斯拉FSD一次又一次的“入华无门”&#xff0c; 让国内车企智能驾驶的“内卷”之争迎来了喘息的余地&#xff0c;而“端到端”也成为现如今市场上的首要研发目标。早在今年4月份&#xff0c;华为就宣布其研发的HUAWEI ADS 3.0已经采用了最新的端…

Java-数据结构-包装类和认识泛型 !!!∑(゚Д゚ノ)ノ

目录&#xff1a; 一、包装类&#xff1a; 1、基本数据类型所对应的包装类&#xff1a; 2、装箱和拆箱&#xff1a; 二、 泛型&#xff1a; 1、什么是泛型&#xff1a; 2、语法&#xff1a; 三、泛型类的使用&#xff1a; 四、裸类型&#xff1a; 五、泛型的擦除机制&…

[oeasy]python031_[趣味拓展]unix起源_Ken_Tompson_Ritchie_multics

[趣味拓展]unix起源_Ken_Tompson_Ritchie_multics &#x1f94b; 回忆上次内容 上次 动态设置了 断点 断点 可以把代码 切成一段一段的可以 更快地调试 调试的目的 是 去除 bug 别害怕 bug 一步步 总能找到 bug这 就是 程序员基本功 调试 debug 在bug出现的时候 甚至…

Python 变量类型

Python 变量类型 变量赋值 多个变量赋值 标准数据类型 Python 数字 Python字符串 Python列表 Python 元组 Python 字典 Python数据类型转换 Python 变量类型 变量是存储在内存中的值&#xff0c;这就意味着在创建变量时会在内存中开辟一个空间。 基于变量的数据类型…

【视频讲解】主成分分析原理与水果成熟数据实例:Python中PCA-LDA 与卷积神经网络CNN...

全文链接&#xff1a;https://tecdat.cn/?p37450 分析师&#xff1a;Shixian Ding 主成分分析&#xff08;PCA&#xff09;作为数据科学中用于可视化和降维的重要工具&#xff0c;在处理具有大量特征的数据集时非常有用。就像我们难以找到时间阅读一本 1000 页的书&#xff0…

实现流程化办公,可专注于开源可视化报表设计器!

近日&#xff0c;有很多粉丝和朋友们会问我们关于低代码技术平台、开源可视化报表设计器的相关内容和问题。其实&#xff0c;在流程化办公新时代&#xff0c;愿意启用新软件平台的客户朋友会收获市场红利&#xff0c;也会站在前沿之地上斩获更多市场份额。今天我们就一起来了解…

随机森林与线性回归

集成学习方法之随机森林 集成学习&#xff08;Ensemble Learning&#xff09;是一种通过组合多个分类器来提高预测性能的方法。主要分为三种类型:Bagging、Boosting和Stacking。以下是集成学习的基本步骤和概念&#xff1a; 1数据采样&#xff1a;从训练集中有放回地随机抽取…

【渗透测试】ATTCK靶场一,phpmyadmin,域渗透,内网横向移动攻略

前言 博客主页&#xff1a;h0ack1r丶羽~ 从0到1~ VulnStack&#xff0c;作为红日安全团队匠心打造的知识平台&#xff0c;其独特优势在于全面模拟了国内企业的实际业务场景&#xff0c;涵盖了CMS、漏洞管理及域管理等核心要素。这一设计理念源于红日安全团队对ATT&CK红队评…

斯坦福大学cs231n (图像分类)

1.介绍 当作图像分类时&#xff0c;分类系统接收一些分类图像&#xff0c;比如猫咪。并且系统清楚了一些已经确定了分类或者标签的集合。那么&#xff0c;计算机的工作就是根据图片&#xff0c;给他分配一些固定的分类或者标签。 对于一个计算机来说&#xff0c;这是一个非常…

springsecurity 在web中如何获取用户信息(后端/前端)

一、SecurityContextHolder 是什么 SecurityContextHolder用来获取登录之后用户信息。Spring Security 会将登录用户数据保存在Session中。但是&#xff0c;为了使用方便,Spring Security在此基础上还做了一些改进&#xff0c;其中最主要的一个变化就是线程绑定。当用户登录成功…

FastGPT如何增减用户

背景 开源版本的FastGPT默认只有一个超级用户root&#xff0c;为了更好地管理应用和知识库&#xff0c;可以通过操作MongoDB数据库来增加新的用户和团队。 所需环境 已安装并运行的FastGPT实例MongoDB客户端工具&#xff08;如Mongo Shell或Robo 3T等&#xff09; 操作步骤…

数据库三大范式

三大范式 一种数据库设计理念&#xff0c;意义在于降低耦合 写代码 高内聚 低耦合 一个表只有一个主键 一个主键可以是多列 ‌第一范式&#xff08;1NF&#xff09;‌&#xff1a;要求数据库表的每一列都是不可分割的原子数据项&#xff0c;即列中存储的数据是最小的数据单元&…

并发服务器

一、服务器 1.单循环服务器&#xff1a;同一时刻&#xff0c;只能处理一个客户端的任务&#xff1b; 2.并发服务器&#xff1a;同一时刻&#xff0c;可以处理多个客户端的任务&#xff1b; 3.TCP并发服务器&#xff1a; &#xff08;1&#xff09;多进程: &#xff08;2&a…

搭建面向切面编程项目

此项目在整合Mybatis基础上修改&#xff0c;可参考主页的整合Mybatis文章 注解版本 第一步 引入maven坐标 <!-- 切面编程所需jar包--><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId>…