归并+插入+选择+归并+归并+桶+归并+基数排序Python实现

常见排序算法Python实现

class Sort(object):
    """常见的排序算法"""

    def __init__(self):
        pass

    @staticmethod
    def bubble_sort(a_list):
        """冒泡排序"""
        list_length = len(a_list)
        if list_length <= 1:
            return a_list

        list_length = len(a_list)
        for x in range(0, list_length):
            flag = False
            for y in range(0, list_length - x - 1):
                if a_list[y] > a_list[y + 1]:
                    temp = a_list[y]
                    a_list[y] = a_list[y + 1]
                    a_list[y + 1] = temp
                    flag = True
            if not flag:
                return a_list

    @staticmethod
    def insert_sort(a_list):
        """插入排序"""
        list_length = len(a_list)
        if list_length <= 1:
            return a_list

        for x in range(1, list_length):
            to_insert_value = a_list[x]
            y = x - 1

            while y >= 0:
                if to_insert_value < a_list[y]:
                    a_list[y + 1] = a_list[y]
                else:
                    break
                y -= 1
            a_list[y + 1] = to_insert_value
        return a_list

    @staticmethod
    def select_sort(a_list):
        """选择排序"""
        list_length = len(a_list)
        if list_length <= 1:
            return a_list

        for x in range(0, list_length):
            min_index = x
            for y in range(x + 1, list_length):
                if a_list[y] < a_list[min_index]:
                    min_index = y

            if min_index != x:
                a_list[x], a_list[min_index] = a_list[min_index], a_list[x]
        return a_list

    def merge_sort(self, a_list):
        """归并排序"""
        if len(a_list) <= 1:
            return a_list

        mid = len(a_list) / 2
        left = self.merge_sort(a_list[:mid])
        right = self.merge_sort(a_list[mid:])

        return self._merge(left, right)

    @staticmethod
    def _merge(left, right):
        """归并排序之合并"""
        result = []
        i = 0
        j = 0
        while i < len(left) and j < len(right):
            if left[i] <= right[j]:
                result.append(left[i])
                i += 1
            else:
                result.append(right[j])
                j += 1
        result += left[i:]
        result += right[j:]
        return result

    def easy_quick_sort(self, a_list):
        """快速排序简单实现"""
        if len(a_list) < 2:
            return a_list

        pivot = a_list[0]

        less_than_pivot = [x for x in a_list if x < pivot]
        more_than_pivot = [x for x in a_list if x > pivot]
        return self.easy_quick_sort(less_than_pivot) + [pivot] + self.easy_quick_sort(more_than_pivot)

    def quick_sort(self, a_list):
        """快速排序"""
        return self._quick_sort(a_list, 0, len(a_list) - 1)

    def _quick_sort(self, a_list, left, right):
        if left < right:
            pivot = self._partition(a_list, left, right)
            self._quick_sort(a_list, left, pivot - 1)
            self._quick_sort(a_list, pivot + 1, right)
        return a_list

    @staticmethod
    def _partition(a_list, left, right):
        pivot_key = a_list[left]
        while left < right:
            while left < right and a_list[right] >= pivot_key:
                right -= 1
            a_list[left] = a_list[right]

            while left < right and a_list[left] <= pivot_key:
                left += 1
            a_list[right] = a_list[left]
        a_list[left] = pivot_key
        return left

    @staticmethod
    def bucket_sort(a_list):
        """桶排序，支持负数和2位小数"""
        if not a_list or len(a_list) < 2:
            return a_list

        accuracy = 1
        _max = int(max(a_list) * accuracy)
        _min = int(min(a_list) * accuracy)
        buckets = [0 for _ in range(_min, _max + 1)]

        for x in a_list:
            buckets[int(x) * accuracy - _min] += 1

        current = _min
        n = 0
        for bucket in buckets:
            while bucket > 0:
                a_list[n] = current / accuracy
                bucket -= 1
                n += 1
            current += 1
        return a_list

    @staticmethod
    def count_sort(a_list):
        """计数排序, 不支持负数"""
        if not a_list or len(a_list) < 2:
            return a_list

        _max = max(a_list)
        buckets = [0 for _ in range(0, _max + 1)]
        for x in a_list:
            buckets[x] += 1

        for x in range(1, _max + 1):
            buckets[x] += buckets[x - 1]
        result = [0 for _ in range(0, len(a_list))]

        for x in range(0, len(a_list)):
            index = buckets[a_list[x]] - 1
            result[index] = a_list[x]
            buckets[a_list[x]] -= 1
        return result

    @staticmethod
    def radix_sort(a_list):
        """基数排序"""
        i = 0
        _max = max(a_list)
        j = len(str(_max))  # 记录最大值的位数
        while i < j:
            bucket_list = [[] for _ in range(10)]
            for x in a_list:
                bucket_list[int(x / (10 ** i)) % 10].append(x)
            a_list = [y for x in bucket_list for y in x]
            i += 1
        return a_list