冒泡排序和鸡尾酒排序(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(self.length):
            print(‘**************第%s轮循环**************‘ % (i + 1))
            index_len = self.length
            for index in range(index_len - 1):
                print(index)
                if data_list[index] > data_list[index + 1]:
                    data_list[index], data_list[index + 1] = data_list[index + 1], data_list[index]
        return data_list

    # 优化后美丽动人又可爱的冒泡排序
    def new_b_sort(self):
        data_list = list(self.data_list)
        for i in range(self.length):
            print(‘**************第%s轮循环**************‘ % (i + 1))
            index_len = self.length
            mark = False
            for index in range(index_len - 1 - i):
                print(index)
                mark = True
                if data_list[index] > data_list[index + 1]:
                    data_list[index], data_list[index + 1] = data_list[index + 1], data_list[index]
                    mark = False
            if mark:
                break
        return data_list

data_list = [2, 3, 1, 7, 4, 3]
bubblesort = BubbleSort(data_list)
res1 = bubblesort.b_sort()
print(res1)
res2 = bubblesort.new_b_sort()
print(res2)

二、鸡尾酒排序

# 鸡尾酒排序
class CocktailSort(object):
    def __init__(self, data_list):
        self.data_list = data_list
        self.length = len(data_list)
    # 简单粗暴的排序方式
    def c_sort(self):
        data_list = list(self.data_list)
        for i in range(self.length):
            print(‘**************第%s轮循环**************‘ % (i + 1))
            index_len = self.length
            print(‘左--->右‘)
            for index in range(index_len - 1):
                print(index)
                if data_list[index] < data_list[index + 1]:
                    data_list[index], data_list[index + 1] = data_list[index + 1], data_list[index]
            print(‘右--->左‘)
            index_len = self.length
            for index in range(index_len - 1):
                print(index)
                if data_list[index] > data_list[index + 1]:
                    data_list[index], data_list[index + 1] = data_list[index + 1], data_list[index]
        return data_list
    # 优化后俏皮美丽又懂事的鸡尾酒排序
    def new_c_sort(self):
        data_list = list(self.data_list)
        for i in range(self.length):
            print(‘**************第%s轮循环**************‘ % (i + 1))
            index_len = self.length
            mark = False
            print(‘左--->右‘)
            for index in range(index_len - 1- i):
                mark = True
                print(index)
                if data_list[index] < data_list[index + 1]:
                    data_list[index], data_list[index + 1] = data_list[index + 1], data_list[index]
                    mark = False
            print(‘右--->左‘)
            index_len = self.length
            for index in range(i, index_len - 1):
                mark = True
                print(index)
                if data_list[index] > data_list[index + 1]:
                    data_list[index], data_list[index + 1] = data_list[index + 1], data_list[index]
                    mark = False
            if mark:
                break
        return data_list

data_list = [2, 3, 1, 7, 4, 3]
cocktailsort = CocktailSort(data_list)
res1 = cocktailsort.c_sort()
res2 = cocktailsort.new_c_sort()
print(res1)
print(res2)

原文地址:https://www.cnblogs.com/95lyj/p/9399267.html

时间: 2024-11-08 19:54:55

冒泡排序和鸡尾酒排序(code)的相关文章

简单排序,冒泡排序,鸡尾酒排序,快速排序

简单排序:每次找出最大(小)的数,从头开始依次排序. 1 public static int[] simplySort(int a[]) { 2 for (int i = 0; i < a.length - 1; i++) { 3 // int min = a[i]; 4 int minIndex = i; 5 for (int j =i + 1; j < a.length; j++) { 6 //我的代码 7 // if (a[j] < min) { 8 // min = a[j];

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

1. 冒泡排序 冒泡排序(bubble sort),是一种基础的交换排序.基本思想是,把相邻的元素两辆进行比较,当一个元素大于右侧相邻元素时,交换它们的位置:当一个元素小于或等于右侧相邻元素时,位置不变. 冒泡排序是一种稳定排序,值相等的元素并不会打乱原本的顺序.由于该排序算法每一轮都要遍历所有元素,总共遍历(元素数量-1)轮,平均时间复杂度为O(n2). 升级版1: 对于序列的后半部分已经是有序的情况,如果能判断出有序,并作出标记,那么剩下的几轮排序就不必执行了.利用bool变量isSorte

鸡尾酒排序(双冒泡排序、搅拌排序或涟漪排序)

using System; using System.Collections.Generic; using System.Linq; using System.Text;namespace Sort { class CockTailSorter { private static int[] myArray; private static int arraySize; public static int[] Sort(int[] myArray) { arraySize = myArray.Len

冒泡排序的改进:鸡尾酒排序

鸡尾酒排序,也叫定向冒泡排序,是冒泡排序的一种改进.此算法与冒泡排序的不同处在于从低到高然后从高到低,而冒泡排序则仅从低到高去比较列里的每个元素. 它可以得到比冒泡排序稍微好一点的排序. void CocktailSort(int *a , int n){ int left = 0; int right = n - 1; while(left < right) { for(int i = left; i < right; i++) { if(a[i] > a[i+1]) swap(a,i

鸡尾酒排序Cocktail Sort (双向冒泡排序)

鸡尾酒排序 鸡尾酒排序思路,先从左边开始进行冒泡排序,第一趟冒泡排序完,最大值在的数组的最右端,然后进行第二趟排序,第二趟排序从右边开始排序,第二趟结束时,最小值在数组最左端,以此类推,每一趟排序完都能将一个在当前数组(不包括之前排序得到的最大或者最小的数)中最小或者最大的数放在对应的位置. 算法过程 代码实现 #include <iostream> using namespace std; void Swap(int array[], int i, int j) { int temp = a

视频动画 | 什么是鸡尾酒排序?

鸡尾酒排序其实就是冒泡排序的变形,它的时间复杂度和冒泡排序一样,都是O(n^2),比快速排序要慢不少. 鸡尾酒排序算法 鸡尾酒排序的思想有点像摆钟一样,从左到右,又从右到左.而冒泡排序只是单向执行. 鸡尾酒排序也是交换排序,假设做一个升序排序,先从左到右,交换一趟把最大的数放置右边,然后从右到左,把最小的数放置左边. 视频动画 Code Result 初始状态 [5, 1, 9, 3, 7, 4, 8, 6, 2] 从左到右发生交换 [1, 5, 9, 3, 7, 4, 8, 6, 2] 从左到

鸡尾酒排序Cocktail sort

鸡尾酒排序基于冒泡排序,双向循环 还是看例子吧,给定待排数组[2 3 4 5 1] 第一趟过去时的每一步 第一步迭代,2 < 3不换 [2 3 4 5 1] 第二步迭代,3 < 4不换 [2 3 4 5 1] 第三步迭代,4 < 5不换 [2 3 4 5 1] 第四步迭代,5 > 1交换 [2 3 4 1 5] 第一趟回来时的第一步,鸡尾酒一次到头后就回返回来,再到头后再过去,来回比,一个来回能排两个数字 第五步迭代,1 < 5不交换 [2 3 4 1 5] 第六步迭代,1

数据结构——排序——鸡尾酒排序算法

鸡尾酒排序,也就是定向冒泡排序, 鸡尾酒搅拌排序, 是冒泡排序的一种变形.此算法与冒泡排序的不同处在于排序时是以双向在序列中进行排序. 使用鸡尾酒排序为一列数字进行排序的过程 鸡尾酒算法原理 i. 先对数组从左到右进行升序的冒泡排序:  ii. 再对数组进行从右到左的降序的冒泡排序:  iii. 以此类推,持续的.依次的改变冒泡的方向,并不断缩小没有排序的数组范围: 例:         88     7     79     64     55     98     48     52    

冒泡排序和选择排序

冒泡排序和选择排序是排序算法中比较简单和容易实现的算法.冒泡排序的思想为:每一次排序过程,通过相邻元素的交换,将当前没有排好序中的最大(小)移到数组的最右(左)端.而选择排序的思想也很直观:每一次排序过程,我们获取当前没有排好序中的最大(小)的元素和数组最右(左)端的元素交换,循环这个过程即可实现对整个数组排序. 选择排序的平均时间复杂度比冒泡排序的稍低:同样数据的情况下,2种算法的循环次数是一样的,但选择排序只有0到1次交换,而冒泡排序只有0到n次交换.   1.冒泡法:这是最原始,也是众所周