冒泡排序

1.选择排序 选择排序就是对数组中的元素进行比较选择，然后直接放置在排序后的位置 代码： 在主方法 main 中定义一个数组并设置值，然后调用 selectSort 方法并给它参数值然后执行。 在 selectSort 方法中写一个 for 循环， n 为 8 表示的是数组中的总数，判断如果 i<n-1, 满足条件时执行下一个 for 循环，找出最小值的元素下标，第一遍 j=i+1(1=0+1) ，满足 j<n 条件，然后比较赋值，最后输出每一次执行的结果。 public static void main(String[] args) { int [] arr = {19,38,5,17,12,8,27,29}; selectSort (arr,arr. length ); } public static void selectSort( int [] arr, int n){ for ( int i = 0; i < n - 1; i++) { int index = i; int j; // 找出最小值的元素下标 for (j = i + 1; j < n; j++) { if (arr[j] < arr[index]) { index = j; } } int tmp = arr[index]; arr[index] = arr[i]; arr[i] = tmp;

一、冒泡排序 #include <iostream> using namespace std; template<typename T> void bubble_sort(T arr[], int len) { int i, j; T temp; for (i = 0; i < len - 1; i++) { for (j = 0; j < len - 1 - i; j++) if (arr[j] > arr[j + 1]) { temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } int main() { int arr[] = { 61, 17, 29, 22, 34, 60, 72, 21, 50, 1, 62 }; int len = (int) sizeof(arr) / sizeof(*arr); bubble_sort(arr, len); for (int i = 0; i < len; i++) cout << arr[i] << ' '; cout << endl; float arrf[] = { 17.5, 19.1, 0.6, 1.9, 10.5, 12.4, 3.8, 19.7, 1.5, 25.4, 28.6, 4.4, 23.8, 5.4 }; len = (int) sizeof

1. 基本思想 来源： https://blog.csdn.net/zzw0221/article/details/99547595

目录 1.冒泡排序： 2.快速排序： 3.插入排序： 4.选择排序： 1.冒泡排序： 冒泡排序重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。 这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。 /** * 冒泡排序： * 1.比较相邻的元素。如果第一个比第二个大，就交换它们两个； * 2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数； * 3.针对所有的元素重复以上的步骤，除了最后一个； * 4.重复步骤1~3，直到排序完成。 */ public class BubbleSort { public static void outA(int [] a){ for (int i : a) { System.out.print(" "+i); } System.out.println(); } public static void main(String[] args) { int [] a = new int[]{2, 5, 6, 8, 9, 1, 3, 4, 7,0}; int

————— 第二天 ————— ———————————— 我们假定要获得 升序 数列，冒泡排序的原理是什么呢？ 顾名思义，就是把每一元素和下一个元素进行比较和交换，使得较大的元素像气泡一样向右侧移动： 这样一来，每一轮操作都可以把一个最大元素移动到最右侧，经过多轮操作，无序的数列成为了升序数列： 这就是冒泡排序的基本原理。 如果是按照冒泡排序的思路来指挥，结果会是什么样子呢？ 如此一来，同学们一共交换了4次，还只是完成了冒泡排序的第一轮操作。如果继续下去，同学们心里恐怕会想：“这体育老师是不是有毛病啊？” 在程序运行的世界里，虽然计算机并不会产生什么“负面情绪”，但是频繁的数组元素交换意味着更多的内存读写操作，严重影响了代码运行效率。 让我们来看一下具体的指挥过程： 如此一来，只需要很少的交换次数就可以完成队伍的排序，老师和同学们皆大欢喜。 public static void selectionSort(int[] array){ for(int i=0; i<array.length-1; i++){ int minIndex = i; for(int j = i+1;j<array.length;j++){ minIndex = array[minIndex]<array[j] ? minIndex : j; } int temp = array[i]; array[i] =

def bubbleSort(myList): # 首先获取list的总长度,为之后的循环比较作准备 length = len(myList) # 一共进行几轮列表比较,一共是(length-1)轮 for i in range(0, length): print("i",i) # 每一轮的比较,注意range的变化,这里需要进行length-1-长的比较,注意-i的意义(可以减少比较已经排好序的元素) for j in range(0, length - 1 - i): # 交换 if myList[j] > myList[j + 1]: tmp = myList[j] myList[j] = myList[j + 1] myList[j + 1] = tmp# 打印每一轮交换后的列表 print(myList) print("=============================") return myList 改进： def bubbleSort(myList): # 首先获取list的总长度,为之后的循环比较作准备 length = len(myList) # 一共进行几轮列表比较,一共是(length-1)轮 for i in range(0, length): print("i",i) flag = False # 改进版本

冒泡排序大家都很熟悉了，我就简单的写写回顾一下。 一、算法描述 基本思想：每次比较两个相邻的元素，如果它们的顺序错误就把它们交换过来。 原理：每一趟只能确定将一个数归位。 步骤：如果有n 个数进行排序，只需将n-1 个数归位，也就是说要进行n-1 趟操作。而“每一趟”都需要从第1 位开始进行相邻两个数的比较，将较小的一个数放在后面，比较完毕后向后挪一位继续比较下面两个相邻数的大小，重复此步骤，直到最后一个尚未归位的数。 二、代码实现 问题描述：将n个数从小到大进行排序。 实现代码： 1 import java.util.Scanner; 2 3 public class Main { 4 public static void main(String[] args) { 5 // TODO Auto-generated method stub 6 Scanner reader = new Scanner(System.in); 7 int n = reader.nextInt(); 8 int a[] = new int[n]; 9 for(int i=0;i<n;i++) 10 a[i]=reader.nextInt(); 11 12 int tmp; 13 for(int i=0;i<n-1;i++){ 14 for(int j=0;j<n-1-i;j++){ 15 if(a[j

/*--> */ /*--> */ 算法思路 升序排列: 从左到右(或右到左)比较相邻的元素,如果当前元素比下一个元素大(或者小),就交换他们两个。 对下一对相邻元素做同样的工作,从开始第一对到结尾的最后一对,本轮排序完成后得到无序部分中的最大元 素,此时这个最大元素和之前的已经排序的部分,组成新的有序部分 针对所有的无序元素重复以上的步骤,直到某一轮没有发生元素交换则说明排序完成 降序排列: 从左到右(或右到左)比较相邻的元素,如果当前元素比下一个元素小(或者大),就交换他们两个。 对下一对相邻元素做同样的工作,从开始第一对到结尾的最后一对,本轮排序完成后得到无序部分中的最大元 素,此时这个最大元素和之前的已经排序的部分,组成新的有序部分 针对所有的无序元素重复以上的步骤,直到某一轮没有发生元素交换则说明排序完成 例:使冒泡法升序排列8,1,6,3,2,4 从左到右进行排序: 第一轮: 第二轮: 第三轮: 第四轮: 本轮中没有发生元素交换,就表示剩下的元素都是有序的,所以所有元素已经都是有序的了。 代码实现 bool BubbleSort(int * pUnSortAry, int nArySize) { if (pUnSortAry == nullptr || nArySize <= 0) { return false; } bool bFlag = false; for

1、思路：内层循环，比较当前元素与相邻的下一个元素，顺序不对，进行交换，这样就把最大的数沉到底部。外层循环，对于每次剩余的数，把最大的沉到底部。 2、源码： 1 template <typename T> 2 void BubbleSort(vector<T>& vec) 3 { 4 for ( int i= 0 ; i< vec.size();i++ ) 5 { 6 for ( int j= 0 ;j < vec.size()-i- 1 ;j++ ) 7 { 8 if (vec[j]>vec[j+ 1 ]) 9 { 10 swap(vec,j,j+ 1 ); 11 } 12 } 13 } 14 } 转载于:https://www.cnblogs.com/nzbbody/p/3423860.html 来源： https://blog.csdn.net/weixin_30221425/article/details/99234512

两种对冒泡排序的改进算法，对于n个元素的冒泡排序，普通的冒泡排序要经过n-1趟排序。 第一种改进：加一个标志位，当某一趟冒泡排序没有元素交换时，则冒泡结束，元素已经有序，可以有效的减少冒泡次数。 template <class T> void Sort<T>::bubbleSwap(DataList<T> &datalist, const int n, int &flag) { 　　flag = 0; 　　for (int i = datalist.m_nCurrentSize - 1; i >= n; i--) 　　{ 　　　　if (datalist.m_pvector[i-1] > datalist.m_pvector[i]) 　　　　{ 　　　　　　datalist.swap(datalist.m_pvector[i-1], datalist.m_pvector[i]); 　　　　　　flag = 1; 　　　　} 　　} } template <class T> void Sort<T>::bubbleSort(DataList<T> &datalist) { 　　int flag = 1, n = 0; 　　while(++n < datalist.m_nCurrentSize && flag) 　　{ 　　　　bubbleSwap(datalist, n, flag)