-
2020-11-28 05:58:12
原标题:Python数据结构之冒泡排序和选择排序
Python数据结构之冒泡排序
冒泡排序是一种基础排序算法,在python中,我们利用列表的的方式来完成,它对列表中的元素进行重复的遍历,在遍历的同时进行比较,如果两个数没有按照我们规定的顺序进行排列,就按照我们预先设定好的是顺序或者逆序输出,类似于烧开水时的气泡,主要操作如下:
比较相邻的元素。如果第一个比第二个大(升序),就交换他们两个。
对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。
针对所有的元素重复以上的步骤,除了最后一个。
持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
时间复杂度
最优时间复杂度:O(n) (表示遍历一次发现没有任何可以交换的元素,排序结束。)
最坏时间复杂度:O(n2)
稳定性:稳定
附上完整代码:
def bubble_sort(list):
for j in range(len(list)-1,0,-1):
for i in range (j):
if list[i]>list[i+1]:
list[i],list[i+1]=list[i+1],list[i]
List=[1,3,2,8,4,6,9,7]
bubble_sort(List)
print(List)
Python数据结构之选择排序
选择排序(select_sort)是一个基础排序,它主要通过查找已给序列中的元素的最大或者最小元素,然后将其放在序列的起始位置或者结束位置,并通过多次这样的循环完成对已知序列的排序,在我们对n个元素进行操作时,我们至少需要n-1次。
def select_sort(list):
n=len(list)
#进行n-1次操作
for i in range(n-1):
min_dex=i
#记录最小的位置
for j in range(i+1,n):
#从i+1选取最小位置
if list[j]
min_dex=j
#最小位置不对应进行交换
if min_dex !=i:
list[i],list[min_dex]=list[min_dex],list[i]
List=[0,3,1,2,9,4,6,5,8,7]
select_sort(List)
print(List)返回搜狐,查看更多
责任编辑:
更多相关内容 -
使用C++随机函数Rand()生成n个数,采用冒泡排序法.选择排序法这两种方法对n个数进行排序
2021-05-25 04:53:44#include #include #include using ...void Maopao_sort(int array[] ,int n){//冒泡排序int tmp;for(int i = 0; i < n-1; i++){for(int j = 0; j < n - i-1; j++){if(array[j] < array[j+1]){tmp =...#include
#include
#include
using namespace std;void Maopao_sort(int array[] ,int n)
{//冒泡排序
int tmp;
for(int i = 0; i < n-1; i++)
{
for(int j = 0; j < n - i-1; j++)
{
if(array[j] < array[j+1])
{
tmp = array[j+1];
array[j+1] =array[j];
array[j] = tmp;
}
}
}
}void Select_sort(int array[],int n)
{//选择排序
int small;//临时变量寄存器
for(int i=0;i
{
small = i;
for(int j=i+1;j
{
if(array[small] > array[j])
{
small = j;
}
}
if(small!=i)
{
int t = array[small];
array[small]=array[i];
array[i]=t;
}
}
}void main()
{
int num_ary[10];
cout << "原数组顺序:" << endl;
srand((unsigned int) time(0));
for(int i = 0 ; i < sizeof(num_ary)/4 ;i++)
{ num_ary[i] = rand()%50;//随机50之间的数字来 初始化数组num_ary
cout << num_ary[i] << endl;
}
Select_sort(num_ary ,sizeof(num_ary)/4);//选择排序从小到大 cout << "选择排序从小到大:" << endl;
for(int i = 0 ; i < sizeof(num_ary)/4 ;i++)
{
cout << num_ary[i] << " ,";
} cout << endl; Maopao_sort(num_ary ,sizeof(num_ary)/4);//冒泡排序从大到小
cout << "冒泡排序从大到小:" << endl;
for(int i = 0 ; i < sizeof(num_ary)/4 ;i++)
{
cout << num_ary[i] << " ,";
}
}
温馨提示:答案为网友推荐,仅供参考
-
产生N个随机数,使用冒泡排序,对随机数进行排序
2020-08-11 17:32:54冒泡排序 #include <time.h> #include <stdio.h> #include <stdlib.h> #define N 100 //数据个数 #define U 1000 //数据范围 int data[N];//存放数据的数组 int comp_count = 0; // 数据比较次数...#include <time.h> #include <stdio.h> #include <stdlib.h> #define N 100 //数据个数 #define U 1000 //数据范围 int data[N];//存放数据的数组 int comp_count = 0; // 数据比较次数 int swap_count = 0; // 数据交换次数 //添加随机数到数组 void add_data(int *data) { srand(time(NULL)); for(int i=0; i<N; ++i) data[i] = rand() % U; } //展示排序前数组 void show(int *data) { printf("随机序列: "); for(int i=0; i<N; ++i) printf("%d\t",data[i]); printf("\n"); } //展示排序后的数组、比较次数和交换次数 void show_ok(int *data) { printf("冒泡排序: "); for(int i=0; i<N; ++i) printf("%d\t",data[i]); printf("\n总共比较次数: %d\n总共交换次数: %d\n", comp_count, swap_count); } //交换元素 void exchange(int *a, int *b) { int n = *a; *a = *b; *b = n; swap_count++; } //冒泡排序 void bubble(int *data) { for (int i=0; i<N-1; i++) { for (int j=0; j<N-1-i; j++) { comp_count++; if (data[j] <= data[j+1]) continue; exchange(&data[j], &data[j+1]); } } } int main(void) { add_data(data); show(data); bubble(data); show_ok(data); return 0; }
-
算法:冒泡排序
2019-07-14 16:36:57文章目录选择排序版本1版本2冒泡排序 选择排序 版本1 从小到大: 1、定义一个10个int元素的数组。 2、选择第一个元素,将这个元素和剩下的九个元素相比,找出最小的那个,然后和第一个元素交换位置。如果第一个元素...理论
冒泡排序只会操作相邻的两个元素。每次冒泡操作都会对相邻的两个元素进行比较,看是否满足大小关系要求。如果不满足就让它俩互换。一次冒泡会让至少一个元素移动到它应该在的位置,重复n次,就完成了n个数据的排序工作。
举个例子:
- 我们要对一组数据 4,5,6,3,2,1,从小到到大进行排序。第一次冒泡操作的详细过程就是这样:
- 可以看出,经过一次冒泡操作之后,6 这个元素已经存储在正确的位置上。要想完成所有数据的排序,我们只要进行 6 次这样的冒泡操作就行了。
- 实际上,刚才讲的冒泡排序还可以优化。当某次冒泡操作已经没有数据交换时,说明已经达到完全有序,不用再继续执行后继的冒泡操作。再举个例子,,这里面给 6 个元素排序,只需要 4 次冒泡操作就可以了。
效率分析:
(1)冒泡排序是原地排序算法吗?
冒泡的过程只涉及相邻数据的交换操作,只需要常量级的临时空间。所以它的空间复杂度为O(1),是一个原地排序算法。
(2)冒泡排序是稳定的排序算法吗?
在冒泡排序中,只有交换才可以改变两个元素的前后顺序。为了保证冒泡排序算法的稳定性,当有相邻的两个元素大小相等的时候,我们不做交换,相同大小的数据在排序前后不会改变顺序,所以冒泡排序是稳定的排序算法。
(3)冒泡排序的时间复杂度是多少?
- 最好情况下,要排序的数据已经有序了,我们只需要进行一次冒泡操作,就可以结束了,所以最好情况时间复杂度是O(n)。而最坏情况是,要排序的数据刚好是倒序排列的,我们需要进行n次冒泡操作,所以最坏情况时间复杂度是O( n 2 n^2 n2)
- 从冒泡排序的算法可以看出,如果待排序的元素为正序,则只需要进行一趟排序,比较次数为(n-1)次,移动元素次数为0; 如果待排序的元素为逆序,则需要进行n-1趟排序,比较次数为 ( n 2 − n ) / 2 (n^2-n)/2 (n2−n)/2,移动次数为 3 ( n 2 − n ) / 2 3(n^2-n)/2 3(n2−n)/2,因此,冒泡排序算法的时间复杂度为O(n ^2)。由于其中的元素移动比较多,所以属于内排序中速度较慢的一种。
那平均情况下的时间复杂是多少呢?- 对于包含n个数据的数组,这n个数据就有n!中排序方式。不同的排序方式,冒泡排序执行的时间肯定是不同的。。如果用概率论方法定量分析平均时间复杂度,涉及的数学推理和计算就会很复杂。一种新的思路是通过“有序度”和“逆序度”这两个概念来进行分析。
- 有序度是数组中具有有序关系的元素对的个数。有序元素对用数学表达式表示就是这样:
有 序 元 素 对 : a [ i ] < = a [ j ] , 如 果 i < j 有序元素对:a[i]<=a[j],如果i<j 有序元素对:a[i]<=a[j],如果i<j
-
同理,对于一个倒序排列的数组,比如 6,5,4,3,2,1,有序度是 0;对于一个完全有序的数组,比如 1,2,3,4,5,6,有序度就是n*(n-1)/2,也就是 15。我们把这种完全有序的数组的有序度叫作满有序度。
-
逆序度的定义正好跟有序度相反(默认从小到大为有序)
逆 序 元 素 对 : a [ i ] > a [ j ] , 如 果 i < j 逆序元素对:a[i] > a[j], 如果 i < j 逆序元素对:a[i]>a[j],如果i<j -
关于这三个概念,我们还可以得到一个公式:逆序度 = 满有序度 - 有序度。我们排序的过程就是一种增加有序度,减少逆序度的过程,最后达到满有序度,就说明排序完成了。
-
举个例子,要排序的数组的初始状态是 4,5,6,3,2,1 ,其中,有序元素对有 (4,5) (4,6)(5,6),所以有序度是 3。n=6,所以排序完成之后终态的满有序度为 n*(n-1)/2=15。
- 冒泡排序包含两个操作原子,比较和交换。每交换一次,有序度就加1。不管算作怎么该,交换次数总是确定的,即为逆序度,也就是n*(n-1)/2–初始有序度。此例中就是 15–3=12,要进行 12 次交换操作。
- 对于包含n个数据的数组进行冒泡排序,平均交换次数是多少呢?最坏情况下,初始状态的有序度是0,所以要进行 n ∗ ( n − 1 ) / 2 n*(n-1)/2 n∗(n−1)/2次交换。最好情况下,初始状态的有序度是 n ∗ ( n − 1 ) / 2 n*(n-1)/2 n∗(n−1)/2,就不需要交换。我们可以取个中间值 n ∗ ( n − 1 ) / 4 n*(n-1)/4 n∗(n−1)/4,来表说初始有序度不是很高也不是很低的平均情况。
- 换句话说,平均情况下,需要 n ∗ ( n − 1 ) / 4 n*(n-1)/4 n∗(n−1)/4次交换操作,比较操作肯定要比交换操作多,而复杂度的上限是 O ( n 2 ) O(n^2) O(n2),所以平均情况下的时间复杂度就是 O ( n 2 ) O(n^2) O(n2)
- 这个平均时间复杂度推导过程其实并不严格,但是很多时候很实用,毕竟概率论的定量分析太复杂,不太好用。
这三种时间复杂度为 O(n^2 ) 的排序算法中,冒泡排序、选择排序,可能就纯粹停留在理论的层面了,学习的目的也只是为了开拓思维,实际开发中应用并不多,但是插入排序还是挺有用的。
实现
C++
#include <iostream> #include <list> #include <vector> #include <map> template<typename T> std::ostream& print(std::ostream &out,T const &val) { return (out << val << " "); } template<typename T1,typename T2> std::ostream& print(std::ostream &out,std::pair<T1,T2> const &val) { return (out << "{" << val.first << " " << val.second << "} "); } template<template<typename,typename...> class TT,typename... Args> std::ostream& operator<<(std::ostream &out,TT<Args...> const &cont) { for(auto&& elem : cont) print(out,elem); return out; } void bubbleSort(std::vector<int> &vec){ if(vec.size() <= 1){ return; } bool is_swap = false; for (int i = 0; i < vec.size(); ++i) { is_swap = false; for (int j = 1; j < vec.size() - i; ++j) { if(vec[j - 1] < vec[j]){ std::swap(vec[j - 1], vec[j]); is_swap = true; } } if(!is_swap){ break; } } } int main() { std::vector<int> vec = {1,9,2,8,3,7,4,6,5,10, -1}; bubbleSort(vec); std::cout << vec; return 0; }
实现过程如下:
#include <iostream> #include <list> #include <vector> #include <map> template<typename T> std::ostream& print(std::ostream &out,T const &val) { return (out << val << " "); } template<typename T1,typename T2> std::ostream& print(std::ostream &out,std::pair<T1,T2> const &val) { return (out << "{" << val.first << " " << val.second << "} "); } template<template<typename,typename...> class TT,typename... Args> std::ostream& operator<<(std::ostream &out,TT<Args...> const &cont) { for(auto&& elem : cont) print(out,elem); out << "\n"; return out; } void swap(int & i, int &j){ int t = i; i = j; j = t; } void bubbleSort1(std::vector<int> &vec){ if(vec.empty() || vec.size() == 1){ return; } if(vec[0] < vec[1]){ swap(vec[0], vec[1]); } if(vec[1] < vec[2]){ swap(vec[1], vec[2]); } if(vec[3] < vec[4]){ swap(vec[3], vec[4]); } // .... if(vec[8] < vec[9]){ swap(vec[8], vec[9]); } } void bubbleSort2(std::vector<int> &vec){ if(vec.empty() || vec.size() == 1){ return; } for(int i = 0; i < vec.size(); i++){ if(vec[i] < vec[i+1]){ swap(vec[i], vec[i+1]); } } if(vec[0] < vec[1]){ swap(vec[0], vec[1]); } if(vec[1] < vec[2]){ swap(vec[1], vec[2]); } if(vec[3] < vec[4]){ swap(vec[3], vec[4]); } // .... if(vec[7] < vec[8]){ swap(vec[7], vec[8]); } } void bubbleSort3(std::vector<int> &vec){ if(vec.empty() || vec.size() == 1){ return; } for(int i = 0; i < 10; i++){ if(vec[i] < vec[i+1]){ swap(vec[i], vec[i+1]); } } for(int i = 0; i < 10 - 1; i++){ if(vec[i] < vec[i+1]){ swap(vec[i], vec[i+1]); } } for(int i = 0; i < 10 - 2; i++){ if(vec[i] < vec[i+1]){ swap(vec[i], vec[i+1]); } } for(int i = 0; i < 10 - 3; i++){ if(vec[i] < vec[i+1]){ swap(vec[i], vec[i+1]); } } // ... for(int i = 0; i < 10-9; i++){ if(vec[i] < vec[i+1]){ swap(vec[i], vec[i+1]); } } } void bubbleSort66(std::vector<int> &vec){ if(vec.empty() || vec.size() == 1){ return; } for(int i = 0; i < vec.size(); i++){ for(int j = 0; j < vec.size() - i; j++){ if(vec[j] < vec[j+1]){ swap(vec[j], vec[j+1]); } } } } void bubbleSort(std::vector<int> &vec){ if(vec.empty() || vec.size() == 1){ return; } bool flag = false; for(int i = 0; i < vec.size(); i++){ for(int j = 0; j < vec.size() - i; j++){ if(vec[j] < vec[j+1]){ swap(vec[j], vec[j+1]); flag = true; } } if(!flag){ break; } } } int main() { std::vector<int> vec = {1,9,2,8,3,7,4,6,5,10, -1}; bubbleSort(vec); std::cout << vec; return 0; }
golang
package main import ( "fmt" ) // 假如我们只插入一个 func BubbleFindMax(arr [] int)int{ length := len(arr) if length == 0 { return -404; }else if length == 1 { return arr[0] }else{ for i := 0; i < length - 1; i++ { if arr[i] > arr[i + 1] { arr[i], arr[i + 1] = arr[i + 1], arr[i]; } } return arr[length - 1]; } } func BubbleSort(arr [] int)[]int{ length := len(arr) if length <= 1 { return arr }else{ for i := 0; i < length; i++ { // 有序元素个数, 从length到0 exchange := false; for j := 0; j < length - 1 - i; j++ { // 每次都从头开始, 尾部是有序区 if arr[j] > arr[j + 1] { arr[j], arr[j + 1] = arr[j + 1], arr[j]; exchange = true } } if !exchange { break } } return arr; } } func main() { arr:=[]int {1,9,2,8,3,7,4,6,5,10, -1} fmt.Println(BubbleSort(arr)) fmt.Println(arr) }
java
从小到大:
1、定义一个10个int元素的数组。
2、从第一个元素开始,两个元素之间两两比较,哪个元素大就放到后面,一直比较到最后一个元素。
3、从第一个元素开始,两个元素之间两两比较,哪个元素大就放到后面,一直比较到倒数第二个元素。
4、。。。。。public static void bubbleSort(int[] arr) { for (int i = 0; i < arr.length; i++) { for (int j = 0; j < arr.length - 1 - i; j++) { if (arr[j] > arr[j + 1]) { int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } } public static void bubbleSort2(int[] arr) { for (int i = 0; i < arr.length - 1; i++) { boolean flag = true; for (int j = 0; j < arr.length - 1 - i; j++) { if (arr[j] > arr[j + 1]) { int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; flag = false; } } if (flag) { break; } } }
package array; public class sort { public static void main(String []args){ int []arr = {199, 11, 23, 56, 55, 49, 88}; BubbleSort(arr); printArray(arr); } public static void bubbleSort(int [] array){ // 注意:如果array指向一个空指针,空指针是没有length属性的,因而会发生空指针异常 if (array == null || array.length < 2){ return; } for (int i = 0; i < array.length; i++){ //i 表示要排序n趟 boolean flag = true; for (int j = 1; j < array.length - i; j++){ // 有序元素 0个, 1个[length-1], 2个[length-1, length-2] ..... if (array[j-1] > array[j]){ //比较相邻两个元素, 如果元素发生逆序 swap(array, j - 1, j); flag = false; // 标记发生了交换 } } // 查看这一趟比数是否发生了交换, 如果没有发生交换,证明元素已经有序了 if (flag) { break; } } } public static void swap(int []arr, int x, int y){ int temp = arr[x]; arr[x] = arr[y]; arr[y] = temp; } public static void printArray(int []arr){ for(int i=0;i<arr.length; i++){ if(i < arr.length - 1){ System.out.print(arr[i] + ","); }else{ System.out.print(arr[i]); } } System.out.println(); } }
总结
1、有序区逐步扩大,无序区逐步缩小。
2、内循环用于比较,外循环用于控制有序区:刚开始有序区为0,因此内循环需要比较到最后一个元素,第二次比较有序区为1,因此内循环需要比较到倒数第二个元素。。。。
3、外循环控制要比较几趟[i表示第n趟];内循环针对无序元素[0, length - 1 - i]比较:从第一个元素开始,比较两个相邻的元素,如果相邻元素的相对位置不正确,则进行交换,[如果正序,则什么也不干],然后继续比较下面相邻两个元素。结束条件:在任意一趟进行过程中,未出现交换。
4、冒泡排序法需要比较:10+9+8+7+6+5+4+3+2+1次
- 我们要对一组数据 4,5,6,3,2,1,从小到到大进行排序。第一次冒泡操作的详细过程就是这样:
-
【冒泡排序回顾】深入理解冒泡排序
2021-06-02 19:23:33文章目录冒泡排序个人理解1.原理:2.思路:3.算法分析:4.代码:5.几个思考问题: ...一次冒泡会让至少一个元素移动到它应该在的位置,重复 n 次,就完成了 n 个数据的排序工作。 用一个例子,带你看. -
基于比较冒泡排序-时间复杂度O(n^2)
2020-04-16 18:04:36只操作相邻的两个数据,每次冒泡操作都会对相邻的两个元素进行比较,看是否满足大小关系要求,如果不满足让它两互换。一次冒泡会让至少一个元素移动到它应该在的位置,重复 n 次,就完成了 n 个数据的排序工作。 eg... -
冒泡排序
2019-07-19 18:05:44每次冒泡排序操作都会将相邻的两个元素进行比较,看是否满足大小关系要求,如果不满足,就交换这两个相邻元素的次序,一次冒泡至少让一个元素移动到它应该排列的位置,重复N次,就完成了冒泡排序。 代码实现(java)... -
冒泡和快速排序的时间复杂度_常用排序算法之冒泡排序
2020-11-22 10:05:35常见的基于选择的排序算法有冒泡排序、插入排序、选择排序、归并排序和快速排序。选择排序算法通常会根据以下几个纬度来考虑:时间复杂度空间复杂度算法的稳定性(待排序序列中有值相等的元素,经过排序之后相等元素... -
算法分析(一) - 冒泡排序 & 插入排序 & 选择排序
2019-12-02 19:29:15冒泡排序 、插入排序和选择排序都是基于比较的排序算法。本文将详细分析这三种排序。 先说结论: 算法 基于比较 原地排序 稳定性 时间复杂度 最好 时间复杂度 最坏 ... -
排序算法——冒泡排序系列及性能测试
2020-10-10 17:05:14初识冒泡排序 排序算法常常作为学习算法的入门实践,而冒泡排序又是其中最简单的一种,我们今天的主题就是冒泡排序。它的基本思想就像鱼吐泡泡一样简单。 想象有一条鱼在数组的最底端,每一轮,它就吐个泡泡,泡泡会... -
冒泡排序、插入排序、选择排序
2019-10-24 19:05:55其中最经典、最常用的算法有:冒泡排序、插入排序、选择排序、快速排序、归并排序、基数排序等。 1. 评判排序算法的标准 排序算法有很多种,那么我们该如何评判一个排序算法呢?一般情况下,我们可以从排序算法的... -
数据结构与算法:冒泡排序、插入排序、选择排序
2020-10-07 22:14:56我只讲众多排序算法中的一小撮,也是最经典的、最常用的:冒泡排序、插入排序、选择排序、归并排序、快速排序、计数排序、基数排序、桶排序。按照时间复杂度把它们分成了三类,本文先分析冒泡、插入、选择三种排序... -
冒泡和快速排序的时间复杂度_java 八大排序算法 冒泡排序 快速排序 堆排序 归并排序 等...
2020-11-22 10:05:36=2] 个数已经是排好顺序的,现在要把第n个数插到前面的有序数中,使得这n个数也是排好顺序的。如此反复循环,直到全部排好顺序。2.代码实现1.遍历数组,每次循环从第二个数字往前插入2.设定插入数和得到已经排好序列... -
在冒泡排序中,需要比较相邻的两个元素的大小,并决定是否需要交换。改写冒泡排序的程序,其中至少包含两个...
2020-12-28 18:03:31改写冒泡排序的程序,其中至少包含两个函数:bubble_sort(int a[], int n)和swap,bubble_sort用于将数组a中的n个元素排序,其中调用函数swap来交换两个数 引用 #include <stdio.h> void swap(int *a,int *b)... -
排序(一)交换排序 c/c++与python实现
2021-01-20 02:59:38每次冒泡排序都会让至少一个元素移动到它应该在的位置,重复n-1,就完成了对n个数据的排序。 如果对一组数据7,8,9,6,5,4,从小到大排序,第一次冒泡排序的详细过程如下所示: 可以看出一次冒泡操作后,有一个... -
排序算法(冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、基数排序)
2021-03-17 15:34:23排序也叫排序算法,排序是将一组数据,依指定的顺序进行...(3)交换排序:冒泡排序、快速排序 (4)归并排序、基数排序 我们先回顾知识点:时间复杂度 时间频度:一个算法花费的时间与算法中语句的执行次数成正比例 -
Go语言实现冒泡排序
2022-05-04 11:18:33一次冒泡会让至少一个元素移动到它应该在的位置,重复 n 次,就完成了 n 个数据的排序工作。 一次冒泡排序的过程 六次冒泡排序的全过程 改进冒泡排序过程 当某次冒泡操作已经没有数据交换时,说明已经达到... -
【八大排序详解~C语言版】直接插入排序-希尔排序- 直接选择排序-堆排序-冒泡排序-快速排序-归并排序-计数...
2022-02-20 16:39:53排序算法想必大家不陌生,今天就来详细的做个总结,包括排序算法的复杂度,稳定性,实现方式。 -
十大经典排序算法详解(一)冒泡排序,选择排序,插入排序
2021-01-20 15:55:40十大经典排序算法2.1-冒泡排序2.2-选择排序2.3-插入排序2.4-希尔排序2.5-归并排序2.6-快速排序2.7-堆排序2.8-计数排序2.9-桶排序2.10-基数排序 1.算法的评判标准 在讲解排序算法之前,我们首先来了解一下评判一个算法... -
排序算法系列:冒泡排序与双向冒泡排序
2016-01-29 15:25:32**排序算法**应该算是一个比较热门的话题,在各个技术博客平台上也都有一些博文进行了一定程度的讲解。...本文就先从最简单的冒泡排序开始说起,别说你已经彻底了解了冒泡排序算法(虽然一开始我也是这样以为的)。 -
排序算法:冒泡排序、插入排序、选择排序、希尔排序
2019-01-28 23:27:36相关博客: 排序算法:冒泡排序、插入排序、选择排序、希尔排序 排序算法:归并排序、快速排序 排序算法:桶排序、计数排序、基数排序 ...一次冒泡会让至少一个元素移动到它应该在的位置,重复n... -
八大排序算法(java实现) 冒泡排序 快速排序 堆排序 归并排序 等
2020-06-17 19:48:33八大排序算法 一、直接插入 - 1.基本思路 - 2....五、冒泡排序 - 1.基本思路 - 2.代码实现 - 3.时间复杂度和空间复杂度 六、快速排序 - 1.基本思路 - 2.代码实现 - 3.时间复杂度和空间复杂度 七.. -
直接插入排序,冒泡排序,快速排序,选择排序的实现
2021-12-14 15:56:23提交正确不是目的,甚至后端没有校验, 直接提交字符串也算对,但那样起不到学习的目的。 根据主函数内容实现功能。 int main() { //直接插入排序 int iArray[MAX_SIZE]= {49,38,65,97,76,13,27,49}; insertSort... -
冒泡排序算法(基于Java实现)
2020-12-23 11:21:54这样一来,一次冒泡会让至少一个元素移动到它应该在的位置,重复n次,就完成了n个数据的排序工作。 例如,我们要对一组数据4,5,6,3,2,1从小到大进行排序。第一次的冒泡操作的详细过程就是这样: 可以看出,... -
【数据结构与算法】简单排序(冒泡排序、选择排序、插入排序)完整思路,并用代码封装排序函数
2020-09-24 14:51:31之前的文章,我已经把前端需要了解的数据结构都给说了一边,并且我们也都对其进行了封装。现在我们要开始对排序算法部分进行讲解,排序算法顾名思义,就是对一堆杂乱无章的数据按照一定的规则将它们有序地排列在一起... -
数据结构-交换排序(冒泡算法,快速排序)
2020-10-28 12:20:38可以看到,冒泡算法的每一趟排序都有一个元素被放到最终的位置,下面我们通过一个例子看看冒泡排序的过程。 2,冒泡排序过程分析 首先看我们的原始数据,每次都把前面的一个元素和后面的一个元素比较,如果前面... -
数据结构之冒泡排序,冒泡排序与直接插入排序比较
2019-05-15 23:26:40冒泡排序 思想: 只会操作相邻的两个元素,每次对相邻的两个元素做大小比较,看是否满足大小关系。 一次冒泡至少会让一个元素移动到最终位置(冒泡) 特点: 时间复杂度O(n^2) 空间复杂度O(1) 稳定性排序 ... -
raptor输入n个数据排序_程序员必备:七种经典排序算法总结(介绍+步骤+动画+python3实现)...
2020-11-20 10:28:45它遍历所有的数据,每次对相邻元素进行两两比较,如果顺序和预先规定的顺序不一致,则进行位置交换;这样一次遍历会将最大或最小的数据上浮到顶端,之后再重复同样的操作,直到所有的数据有序。如... -
排序算法之冒泡排序分析
2020-02-18 20:43:48冒泡排序 冒泡排序是重复地走访过要排序的元素列,依次比较两个相邻的元素,如果顺序(你...最好情况为当要排序的数据已经是有序的,只需要进行一次冒泡排序,时间复杂度为O(n)。 最坏情况下时间复杂度 最坏...