python | 算法-排序-选择，冒泡，插入+异或运算+求最大值

针对的是b站视频-算法大神左神（左程云）算法课程第一节相关算法

视频笔记在这里

1. 选择排序

import random

class Test():
    def main(self):
        """
        对数器，用于检查两个算法的输出是否完全相同
        :return: None
        """
        test_times = 10000 # 测试次数
        max_size = 100 # 数组的最大size
        max_value = 100 # 数组中值的上限

        for _ in range(test_times):
            arr1 = self.generate_random_array(max_size, max_value)
            arr2 = arr1.copy()
            #对比自己编写的选择排序和系统自带的排序算法
            my_sort = mySolution()
            my_sort.selectSort(arr1)
            self.compareSolution(arr2)

            succeed = arr1==arr2

        print("成功！" if succeed else "错了错了。。。")

    def generate_random_array(self, max_size, max_val):
        """
        生成一个数组：数组的大小随机，每个值随机
        :param max_size:
        :param max_val:
        :return: List[int]
        """
        array = []
        #生成size
        size = random.randint(0, max_size)
        #生成每个值
        for _ in range(size):
            array.append(random.randint(0, max_val))
        return array

    def compareSolution(self, array):
        """
        用于对比的 系统自带排序算法
        :param array:
        :return: None
        """
        array.sort()

class mySolution():
    def selectSort(self, array):
        """
        自己编写的排序算法
        :param array:
        :return: None
        """
        if len(array) < 2: # 先提出特殊情况
            return
        for i in range(len(array)):
            j = i + 1
            min_idx = i
            while j < len(array): # 找出 i ~ n-1 之间的最小值的索引
                min_idx = j if array[j] < array[min_idx] else min_idx
                j += 1
            # 将最小值放在i位置--交换操作
            self.swap(array, i, min_idx)

    def swap(self, array, idx1, idx2):
        array[idx1], array[idx2] = array[idx2], array[idx1]

if __name__ == '__main__':
     test = Test()
     test.main()

2. 冒泡排序

# 冒泡排序python代码编写
# 并用对数器检查
import random

class mySort():
    def bubbleSort(self, array):
        """
        自己的冒泡排序
        :param array: List[int]
        :return: None
        """
        #先招呼特殊情况
        if len(array) < 2: return
        #再考虑一般情况
        i = len(array) - 1
        while i > 0:
            for j in range(i):
                if array[j] > array[j+1]:
                    # 将较大的数向后换
                    self.swap(array, j, j+1)
            i -= 1

    def swap(self, array, idx1, idx2):
        """
        交换数组array中索引为idx1和idx2的数的位置,原地操作
        :param array: List[int]
        :param idx1: int
        :param idx2: int
        :return: None
        """
        array[idx1], array[idx2] = array[idx2], array[idx1]

class test():
    def main(self):
        #先设置一些备用参数
        test_times = 10000
        max_size = 100
        max_value = 100

        for _ in range(test_times):
            # 利用随机数相关函数生成随机size，且每个值都随机的数组
            arr1 = self.generate_random_array(max_size, max_value)
            arr2 = arr1.copy()
            tmp = arr1.copy()
            # 分别经过需要对比的两种排序方法
            function1 = mySort()
            function1.bubbleSort(arr1)
            self.compareFunction(arr2)
            # 比较输出是否完全一致
            succeed = arr1 == arr2
            if not succeed:
                print("出错记录\n待排序数组={}\nmyFunction结果={}\ncompareFunction结果={}".format(
                    tmp, arr1, arr2
                ))

        print("成功！" if succeed else "Maybe something's wrong...")


    def generate_random_array(self, max_size, max_value):
        """
        生成size在[0, max_size]范围，每个值在[0, max_value]范围的数组
        :param max_size: int
        :param max_value: int
        :return: List[int]
        """
        array = []
        #生成size
        size = random.randint(0, max_size)
        #生成每个值
        for _ in range(size):
            array.append(random.randint(0, max_value)) # random.randint : Return random integer in range [a, b], including both end points.
        
        return array

    def compareFunction(self, array):
        """
        python自带的排序算法，属于稳定排序
        :param array: List[int]
        :return: None
        """
        array.sort()

if __name__ == '__main__':
    bubbleSorttest = test()
    bubbleSorttest.main()

3. 异或运算

    # 感受一下异或运算
    # python中异或运算符号是：^
    a = 12
    b = 23
    print("a={}\tb={}".format(a, b))
    # 利用异或运算交换两个数
    a = a^b
    b = a^b
    a = a^b
    print("a={}\tb={}".format(a, b))
    # 如果想要交换的两个数存在了同一个位置，这个投机的方法就会出问题

4. 插入排序

# 自己编写插入排序的python代码
# 并用对数器检查正确性

import random

class mySort():
    def insertSort(self, array):
        """
        插入排序--自己的版本
        :param array: List[int]
        :return: None
        """
        # 先处理特殊情况
        if len(array) < 2: return
        i = 1
        while i < len(array):
            j = i
            while j > 0 and array[j] < array[j-1]:
                self.swap(array, j, j-1)
                j -= 1
            i += 1

    def swap(self, array, idx1, idx2):
        """
        交换数组array的位置在idx1和idx2的两个数
        :param array: List[int]
        :param idx1: int
        :param idx2: int
        :return: None
        """
        array[idx1], array[idx2] = array[idx2], array[idx1]

class test():
    def main(self):
        """
        对数器，用于对比两个方法的输出是否完全一样
        用于生成随机数组array，其size和每个值都是随机生成的
        :return: None
        """
        #参数区域
        test_times = 10000
        max_size = 100
        max_value = 100

        for _ in range(test_times):
            # 生成随机数组array，其size和每个值都是随机生成的
            arr1 = self.generate_random_array(max_size, max_value)
            arr2 = arr1.copy()
            tmp = arr1.copy()

            # 将生成的数组经过不同的方法
            my_sort = mySort()
            my_sort.insertSort(arr1)
            self.compareSolution(arr2)
            # 判断开始
            succeed = arr1 == arr2
            if not succeed:
                print("待排序数组={}\nmySort后={}\ncompareSort后={}".format(
                    tmp, arr1, arr2
                ))

        print("Congratulations！" if succeed else "Maybe something's wrong...")

    def generate_random_array(self, max_size, max_value):
        """
        用于生成随机数组array，其size和每个值都是随机生成的
        :param max_size: int
        :param max_value: int
        :return: List[int]
        """
        arr = []
        #生成size
        size = random.randint(0, max_size)
        #生成每个值
        for _ in range(size):
            # random.randint(a, b)可以生成[a, b]之间的一个随机整数
            # 注意：包含两个端点
            arr.append(random.randint(0, max_value))
        
        return arr

    def compareSolution(self, array):
        """
        这里采用python自带的排序工具，属于稳定排序
        :param array: List[int]
        :return: None
        """
        array.sort()

if __name__ == '__main__':
    test_insrtSort = test()
    test_insrtSort.main()

5. 求最大值

# 求最大值
# 用递归行为
# 并用对数器检测

import random

class mySolution():
    def getMax(self, array):
        """
        求最大值-自己的版本
        :param array: List[int]
        :return: int
        """
        #先排除特殊情况
        if len(array) == 0: return None
        #再开始一般情况
        #打包递归行为
        return self.process(array, 0, len(array)-1)

    def process(self, array, left, right):
        """
        求最大值-利用递归行为
        :param array: List[int]
        :param left: int
        :param right: int
        :return: int
        """
        # 只有一个数时
        if left == right: return array[left]
        # 多个数时
        mid = left + ((right-left)>>1) # 这种方式求中间值是为了防止right+left产生溢出情况
        left_max = self.process(array, left, mid)
        right_max = self.process(array, mid+1, right)

        return max(left_max, right_max)

class test():
    def main(self):
        """
        对数器，用于测试两个方法输出是否一致
        :return:None
        """
        #预设参数
        test_times = 10000
        max_size = 100
        max_value = 100

        for _ in range(test_times):
            #生成随机数组，size随机，其中每个值也随机
            array = self.generate_random_array(max_size, max_value)
            #测试方法
            mine = mySolution()
            my_max = mine.getMax(array)
            test_max = self.compareSolution(array)
            succeed = my_max==test_max
            if not succeed:
                print("array={}\nmy_max={}\ntest_max={}".format(
                    array, my_max, test_max
                ))
        print("Congratulations!" if succeed else "Sorry...")

    def generate_random_array(self, max_size, max_value):
        """
        生成随机数组，size随机，其中每个值也随机
        :param max_size: int
        :param max_value: int
        :return: List[int]
        """
        array = []
        #生成size
        size = random.randint(0, max_size)
        #生成每个值
        for _ in range(size):
            array.append(random.randint(0, max_value))

        return array

    def compareSolution(self, array):
        """
        python自带的求最大值的工具
        :param array: List[int]
        :return: int
        """
        if len(array) == 0:return None
        
        return max(array)

if __name__ == '__main__':
    get_max = test()
    get_max.main()