冒泡排序

　　同一问题可用不同算法解决，而一个算法的质量优劣将影响到算法乃至程序的效率。算法分析的目的在于选择合适算法和改进算法。 　　计算机科学中，算法的 时间复杂度 是一个函数，它定量描述了该算法的运行时间。这是一个关于代表算法输入值的字符串的长度的函数。时间复杂度常用大O符号（Order）表述，不包括这个函数的低阶项和首项系数。使用这种方式时，时间复杂度可被称为是渐近的，它考察当输入值大小趋近无穷时的情况。 定义 　　在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。这是一个关于代表算法输入值的字符串的长度的函数。时间复杂度常用大O符号表述，不包括这个函数的低阶项和首项系数。 算法复杂度 　　算法复杂度分为时间复杂度和空间复杂度。其作用: 时间复杂度是指执行算法所需要的计算工作量;而空间复杂度是指执行这个算法所需要的内存空间。(算法的复杂性体现在运行该算法时的计算机所需资源的多少上，计算机资源最重要的是时间和空间(即寄存器)资源，因此复杂度分为时间和空间复杂度)。 时间复杂度 　　1. 一般情况下，算法的基本操作重复执行的次数是模块n的某一个函数f(n)，因此，算法的时间复杂度记做:T(n)=O(f(n)) 分析:随着模块n的增大，算法执行的时间的增长率和 f(n) 的增长率成正比，所以 f(n) 越小，算法的时间复杂度越低，算法的效率越高。 　　2.

回顾冒泡排序、快速排序，直接选择排序以及递归思想。快速排序和二分查找都融入了分而治之的思想，一分再分，递归之。 1、冒泡排序 相邻元素之间逐对两两比较，若不符合预期则先交换位置再继续比较，如此，每次比较都能把最大或最小的元素放在预期位置，直到完成排序。 2、快速排序 1、准备工作：先选定一个参考值，设置两个指针（设为i,j，分别指向数字序列的头和尾）。 2、同时从数字序列的两头进行扫描对比，将大于参考值的数字都放于参考值的一侧，小于参考值的数字置于另一侧。直到i,j指向同一个位置，这个位置即为参考值的预期位置，设为m。 3、对大于参考值一侧，令i=m+1,对小于参考值的一侧，令j=m-1。再分别对参考值的两侧重复步骤1、2。 4、重复步骤1、2、3，直到i>j。 public static int getMiddle(int[] array, int i, int j) { 　　int key = array[i]; 　　while(i<j) 　　{ 　　//从前向后扫描 　　　　while (i<j && array[j]>key) 　　　　　{ 　　　　　　j--; 　　　　　} 　　array[i] = array[j]; 　　//从后向前扫描 　　　　while (i<j && array[i]<key) 　　　　{ 　　　　　　i++; 　　　　} 　　array[j]

比较常用的排序方法（升序）： 冒泡排序： 最常用的排序方法。大体思路就是每次选出一个最大值，第二次选出次大值，基本上就是两个for循环。 鸡尾酒排序 ：冒泡排序方法的变种，鸡尾酒排序，待排序数组首先从0->n-1找出最大值，然后n-2->0找出最小值，然后再从1->n-2找次大值……依次类推……一个while循环，里面套两个for循环即可。 奇偶排序 ：也是冒泡排序的变种。一个while循环，里面两个for循环，但是一个for循环从0开始，一个从1开始，每次加2，比较相邻两个数值大小。 快速排序 ：是分之思想的一种体现。对于一个待排序队列，首先选择一个 基准 ，扫描数据，大于这个基准数据的元素放在右侧，小于的放在左侧，然后左侧和右侧的数据又是待排序队列，再分别选择基准……递归下去，知道全部都是有序的。 插入排序： 是一种比较直观的排序方法，从待排序队列中构建有序队列，把剩余的待排序数据插入到有序队列中。 希尔排序 ：分步长排序法，对相隔步长的数据分别进行排序，然后减小步长，直至步长为1，主要可以减少数据的移动次数。 选择排序： 选择一个最大元素放入队尾，然后从剩余的元素中选择最大的放入队尾的前一位置，直到待排序数组中只有一个元素为止。 堆排序算法 ：选择排序的一种，不停的构建大（小）顶堆，然后取出顶，得到有序序列。 归并排序 ：也是典型的分治法思想的应用

#include <stdio.h> #include <stdlib.h> //冒泡排序法 void BubbleSort(int arr[], int size){ //从后往前排序,因此[0,bound）为已经排好的 //[bound, size) 为待排序的 //每次找最小值放到前面去，意味着已排序区间多一个元素，待排序区间少一个元素 for (int bound = 0; bound < size; bound++){ //下面这重循环负责找到当前排序区间的最小值并放到bound位置 //从后往前排序,因此cur--. 否则越界 for (int cur = size - 1; cur > bound; cur--){ //当前一项数大于当前项时，交换 //改变if语句条件中的'>'，可降序 if (arr[cur - 1] > arr[cur]){ int tmp = arr[cur - 1]; arr[cur - 1] = arr[cur]; arr[cur] = tmp; } } } } int main() { int arr[5] = { 5, 8, 9, 7, 6 }; BubbleSort(arr, 5); for (int i = 0; i < 5; i++){ //打印数组 printf(" %d", arr[i]); } putchar('\n');

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace Choice { class Program { static void Main(string[] args) { var arr = new IComparable[] { 72,6,57,88,60,42,83,73,48,85 }; //var result = Sorted(arr); //Array.ForEach(arr, Console.WriteLine); var resulto = SortedInsert(arr); // Array.ForEach(arr, Console.WriteLine); //var resulquite = SortedQuite(arr,0, arr.Length-1); Console.WriteLine("排序是否成功?{0}", IsSorted(resulto) ? "是" : "否"); Array.ForEach(arr, Console.WriteLine); //Console.WriteLine("排序是否成功?{0}", IsSorted(result) ?

因为之前写过Ｃ＋＋的一些算法，觉得好多东西其实挺简单的，可是有一次面试让我自己写一个排序算法，最后倒腾了半天都感觉不太对的样子，今儿个自己琢磨琢磨调试了一个程序，算是为以后面试当干粮吧，有时间把所有的算法都整理一下写出来。 package homework; public class BubbleSort { public static void main (String[] args){ int arr[] = {1,2,3,4,9,6,3,11}; int temp; for (int i =0;i<arr.length;i++){ for (int j=i+1; j<arr.length;j++){ if(arr[i]>arr[j]){ temp = arr[i]; arr[i]=arr[j]; arr[j]=temp; } } } for (int i=0; i<arr.length;i++){ System.out.println(arr[i]); } } } 来源： https://www.cnblogs.com/luoluode2015/p/4359806.html

什么是冒泡排序？ 冒泡排序是一种最基础的交换排序，它就是把相邻的元素两两进行比较，根据大小来交换元素的位置，把较小的元素放在前面较大的元素放在后面，重复‘比较’‘交换’操作，最终实现数组有序的效果。 原理图如下： 实现步骤： （1） 比较相邻两个元素的大小，然后把较小的数放在前面，较大的数放在后面。 （2） 经过n-1次比较后，最大的那个元素会沉到数组中第n-1个的位置 （3） 如果n-1大于0，就继续重复1，2 否则排序完成。 时间复杂度： 该排序算法在最好情况下（元素是完全有序的）时间复杂度是O(n)，最坏情况下（元素是完全逆序的）时间复杂度是O(n²)。 冒泡排序、选择排序、插入排序时间复杂度都是O（n²） 稳定性： 数组中相同的值，经过排序后位置不变表示该排序算法是稳定的，否则是不稳定的。冒泡排序和插入排序是稳定排序，选择排序是不稳定排序。 冒泡排序第一版： public static int[] bubbleSort(int[] arr) { for (int i = 0; i < arr.length; i++) { for (int j = 0; j < arr.length - i - 1; j++) { if (arr[j] > arr[j + 1]) { int temp = 0; temp = arr[j]; arr[j] = arr[j+1]; arr[j

#define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> struct Node { int id; Node* next; }; //初始化头节点 Node* init_m_head() { Node* temp = (Node*)malloc(sizeof(Node)); temp->id = 0; temp->next = NULL; return temp; } //初始化子节点 Node* init_Node(int num) { Node* temp= (Node*)malloc(sizeof(Node)); temp->id = num; temp->next = NULL; return temp; } //节点链接 void nodelink(Node* n1, Node* n2) { n2->next = n1->next; n1->next = n2; } //节点交换 void swap(Node* n1, Node* n2) { Node* temp = n1; n1 = n2; n2 = temp; } //void maopao(Node* list) // { // Node* temp = list->next; // Node* pre = list; //

冒泡排序，是指计算机的一种排序方法，它的时间复杂度为O（n^2），虽然不及堆排序、快速排序的O（nlogn，底数为2），但是有两个优点：1.“编程复杂度”很低，很容易写出代码；2.具有稳定性，这里的稳定性是指原序列中相同元素的相对顺序仍然保持到排序后的序列，而堆排序、快速排序均不具有稳定性。不过，一路、二路归并排序、不平衡二叉树排序的速度均比冒泡排序快，且具有稳定性，但速度不及堆排序、快速排序。冒泡排序是经过n-1趟子排序完成的，第i趟子排序从第1个数至第n-i个数，若第i个数比后一个数大（则升序，小则降序）则交换两数 　冒泡排序（BubbleSort）的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。 　　由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升

这篇文章仅仅为心中自证，不是算法教学，也不想误人子弟，谢谢各位。 第一章：一些感慨 　　我断断续续学习算法两年多了，这说起来是多么苦涩，是我笨嘛？一直不知道算法是什么东西。 从《算法导论》再到《C算法》不清楚看了多少遍，它们就是我过不去的坎吗？ 　　 　　不敢说什么大话，但是我有一个心得，学习算法，一定要理解，理解比会写更重要，会写，很有可能仅仅是记忆好， 但是过一段时间忘了， 就对这个算法完全没有印象了，我就是这样。 　　所以我以后学习算法，一定抱着理解的心态，理解了，就很好。 第二章：基本排序算法 2.1 冒泡排序 　　人们常说，冒泡排序是最初级的排序算法，人们说这句话的时候是从时间复杂度这个角度来说的，这么说或许没错， 但是，冒泡排序是相当漂亮的排序，这个“漂亮”是说，假如把排序算法可视化起来，x轴从小到大，依次对应0到n，y轴对应的是a[x], 然后排序开始了，你会发现冒泡很飘逸，看起来很赏心悦目，大概人们都喜欢美丽的泡泡吧。 　　 冒泡排序的中心思想： 不写中心思想至少也有十年了吧，记得高中之后语文老师就不搞什么中心思想之类的。 但是我还是要写一写冒泡排序的中心思想，而且，现在我不看资料，我想描述一下，看一看我到底能不能描述。 　　冒泡排序的思想是这样的，从数组a[0]开始，比较相邻的两项的大小顺序，假如顺序不对，则交换两项。 5 4 6 3 2 　　比如上面的数组