排序算法总结——冒泡排序与鸡尾酒排序

1、 冒泡排序

冒泡排序(bubble sort),是一种基础的交换排序。基本思想是,把相邻的元素两辆进行比较,当一个元素大于右侧相邻元素时,交换它们的位置;当一个元素小于或等于右侧相邻元素时,位置不变。

冒泡排序是一种稳定排序,值相等的元素并不会打乱原本的顺序。由于该排序算法每一轮都要遍历所有元素,总共遍历(元素数量-1)轮,平均时间复杂度为O(n2)。

升级版1:

对于序列的后半部分已经是有序的情况,如果能判断出有序,并作出标记,那么剩下的几轮排序就不必执行了。利用bool变量isSorted作为标记,如果在本轮排序中,元素有交换,则说明数列无序;如果没有元素交换,则说明数列已然有序,直接跳出大循环。

升级版2:

界定序列有序区。在每一次排序后,记录下来最后一次元素交换的位置,该位置即为无序数列的边界,再往后就是有序区了。

class Solution
{
public:
    void bubble_sort(int* data, int length)
    {
        if (data == nullptr || length <= 0)
            return;

        // 有序标志,每一轮的初始值都是true;
        bool isSorted = true;
        // 无序数列的边界,每次比较到这即停止
        int sortBoard = length - 1;

        for (int i = 0; i < length - 1; ++i)
        {
            for (int j = 0; j < length - i - 1; ++j)
            {
                int temp = 0;
                if (data[j] > data[j + 1])
                {
                    temp = data[j + 1];
                    data[j + 1] = data[j];
                    data[j] = temp;

                    // 因为有元素进行交换,所以不是有序的,标记变为false;
                    isSorted = false;
                    // 将无序数列的边界更新为最后一次交换元素的位置
                    sortBoard = j;
                }
            }
            if (isSorted)
                break;
        }
    }
};

测试代码:

void test()
{
    int data[] = { 5, 8, 6, 3, 9,2,1,7 };
    int length = sizeof(data) / sizeof(int);

    Solution M;
    M.bubble_sort(data, length);

    for (int i = 0; i < length; ++i)
        cout << data[i] << "  ";
    cout << endl;
}

2、 鸡尾酒排序(cocktail sort)

鸡尾酒排序法的元素比较和交换过程是双向的。在大部分元素已经有序的情况下,减少排序的次数。缺点就是代码量较大。时间复杂度也是O(n2)。

class Solution
{
public:
    void cocltail_sort(int* data, int length)
    {
        if (data == nullptr || length <= 0)
            return;

        int temp = 0;

        for (int i = 0; i < length / 2; ++i)
        {
            // 有序标志,每一轮的初始值都为true;
            bool isSorted = false;
            // 奇数轮,从左向右比较和变换
            for (int j = i; j < length - i - 1; ++j)
            {
                if (data[j] > data[j + 1])
                {
                    temp = data[j + 1];
                    data[j + 1] = data[j];
                    data[j] = temp;
                    // 因为有元素交换,所以不是有序的,标记变为false
                    isSorted = false;
                }
            }
            if (isSorted) break;
            // 偶数轮,将isSorted重新标记为true;
            isSorted = false;
            for (int j = length - i - 1; j > i; --j)
            {
                if (data[j] < data[j - 1])
                {
                    temp = data[j - 1];
                    data[j - 1] = data[j];
                    data[j] = temp;
                    // 因为有元素交换,所以不是有序的,标记变为false
                    isSorted = false;
                }
            }
            if (isSorted) break;
        }
    }
};

用一个特殊的测试案例:

void test()
{
    int data[] = { 2, 3, 4, 5, 6, 7, 8, 1 };
    int length = sizeof(data) / sizeof(int);

    Solution M;
    M.cocltail_sort(data, length);

    for (int i = 0; i < length; ++i)
        cout << data[i] << "  ";
    cout << endl;
}

原文地址:https://www.cnblogs.com/wyr-123-wky/p/11087389.html

时间: 2024-11-08 19:51:57

排序算法总结——冒泡排序与鸡尾酒排序的相关文章

排序算法之一--冒泡排序,选择排序,插入排序

一.排序算法定义 1.排序算法定义 排序算法是一种能将一串数据依照特定顺序进行排列的一种算法 2.六种排序算法理解方式 想象小时候老师给我们按照身高进行排队时用到的方法,脑子里面要浮现老师排身高的场面   以从矮到高进行排序为例 3.稳定性的定义 一个排序算法是稳定的,当有两个相等键值的纪录R和S,且在原本的列表中R出现在S之前,在排序过的列表中R也将会是在S之前. 二.三种基本排序算法 1.冒泡排序:"移" 把最高的移到最右边 第一次循环,找到最高的那个人放到最右边       方法

基础排序算法(冒泡排序,选择排序,插入排序)

最近经常调用api中的排序算法,很少自己写了,有时候也只写写快速排序这些比较快的排序,然而刚开始学排序时用的一些基本的排序算法却有点忘了 正好今天Java老师让我们每个人写个选择排序热热手,趁这个机会再来复习下一些基本的排序好了. 一.冒泡排序(稳定排序) 学编程接触到的第一个排序算法,基本思路就是,给定一个无序数组a0.a1.a2.a3....an; 通过从左到右相邻的元素两两比较,把最大或者最下的数依次放到数组的右边,最后得到有序的序列 public static void maoPao(i

数组的排序算法(冒泡排序,选择排序,插入排序)

package j2se; /**  * Created by jingqing.zhou on 2015/6/16.  * 数组排序算法  */ public class inserSort {    /**     *冒泡排序     */     public static int[] bubbleSort(){         int[] arr = {10,5,7,45,11,-6,2};         for(int i=0;i<arr.length-1;i++){        

【Java_Base】常用排序算法:冒泡排序、选择排序、插入排序

冒泡排序比较相邻的元素.如果第一个比第二个大,就交换他们两个.对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对.在这一点,最后的元素应该会是最大的数.针对所有的元素重复以上的步骤,除了最后一个.持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较. 选择排序对比数组中前一个元素跟后一个元素的大小,如果后面的元素比前面的元素小则用一个变量k来记住他的位置,接着第二次比较,前面“后一个元素”现变成了“前一个元素”,继续跟他的“后一个元素”进行比较如果后面的元素比他要小则用变

排序算法之冒泡排序Java实现

排序算法之冒泡排序 一.初级的冒泡排序 import java.util.Arrays; /** * * @title BubbleSort * @describe 冒泡排序 * @author 张富昌 * @date 2016年10月1日下午3:56:30 */public class BubbleSortLow { // 起泡排序是快速排序的基础,但是排序速度较慢. // 基本思想:将序列中第 1 个元素与第 2 个元素进行比较,如前者大于后者,则两个元素交换位置,否则不交换: // 再将第

排序算法之冒泡排序(Java)

 冒泡排序即每次遍历.相邻数字间进行比较,前者大于后者进行交换,不断将最大值后移,直至沉至最后位置:算法关键要点在于确定每次循环的边界: 后面两种算法则是对冒泡排序一定程度上的改良,但相对于其他排序算法,冒泡排序性能依然较差. //冒泡排序 public class Bubble_Sort { //最原始的解法 public void bubble_sort1(int[] data) { int n = data.length; for(int i = 0; i < n; i++) { //

C语言排序算法之简单交换法排序,直接选择排序,冒泡排序

C语言排序算法之简单交换法排序,直接选择排序,冒泡排序,最近考试要用到,网上也有很多例子,我觉得还是自己写的看得懂一些. 简单交换法排序 1 /*简单交换法排序 2 根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置 3 交换排序的特点是:将键值较大的记录向序列的尾部移动,键值较小的记录向序列的前部移动 4 不稳定 5 */ 6 #include<windows.h> 7 #include<stdio.h> 8 void main(){ 9 int i,j,arr[10

冒泡排序和鸡尾酒排序(code)

昨天回顾了下冒泡排序和鸡尾酒排序,用面向对象的方式写了一下,并且优化了代码,记录一下~ 一.冒泡排序 # 冒泡排序 class BubbleSort(object): def __init__(self, data_list): self.data_list = data_list self.length = len(data_list) # 简单粗暴的排序方式 def b_sort(self): data_list = list(self.data_list) for i in range(s

【数据结构】——排序算法——3.1、选择排序

      [数据结构]--排序算法--3.1.选择排序 一.先上维基的图: 分类 排序算法 数据结构 数组 最差时间复杂度 О(n2) 最优时间复杂度 О(n2) 平均时间复杂度 О(n2) 最差空间复杂度 О(n) total, O(1)auxiliary 二.描述: 选择算法算是最直观的一个了.每次在队列里抽取一个极大(或极小)值进行排列.每次都需要遍历未被抽取的元素队列. 三.Java程序: static void selection_sort(int[] unsorted) { for