十大排序算法——python实现

冷不防 2024-04-18 16:31 37阅读 0赞

### 文章目录 ###

*  排序算法的分类
 *  排序算法复杂度
 *  相关概念
 *  1.冒泡排序
 *   *  算法步骤
 *  2. 选择排序
 *   *  算法步骤
 *  3. 插入排序(Insertion-Sort)
 *   *  算法步骤
 *  4. 希尔排序（shell sort）
 *   *  算法步骤
 *  5.归并排序（Merge sort）
 *   *  算法步骤
 *  6.快速排序(Quick Sort)
 *   *  算法描述
 *  7.堆排序
 *   *  算法描述
 *  8.计数排序
 *   *  算法描述
 *  9.桶排序
 *   *  算法描述
 *  10.基数排序(radixSort)
 *   *  算法描述

之前有一篇c++实现的排序算法，现在为了复习，利用python重新实现一次，也可以对比着来看  
[排序算法实现与比较][Link 1]

# 排序算法的分类 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9fbHhs_size_16_color_FFFFFF_t_70]

# 排序算法复杂度 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9fbHhs_size_16_color_FFFFFF_t_70 1]

# 相关概念 #

**稳定**：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。

**不稳定**：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。

**时间复杂度**：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。

**空间复杂度**：是指算法在计算机

内执行时所需存储空间的度量，它也是数据规模n的函数。

# 1.冒泡排序 #

冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

作为最简单的排序算法之一，冒泡排序给我的感觉就像 Abandon 在单词书里出现的感觉一样，每次都在第一页第一位，所以最熟悉。冒泡排序还有一种优化算法，就是立一个 flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序。但这种改进对于提升性能来说并没有什么太大作用。

## 算法步骤 ##

1.  比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2.  对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3.  针对所有的元素重复以上的步骤，除了最后一个。
4.  持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。  
    ![在这里插入图片描述][20190909161800834.gif]

def bubbleSort(ss):
    
        n = len(ss)
    
        for i in range(n):
            for j in range(0, len(arr)-i):
                if arr[j] > arr[j+1]:
                    arr[j], arr[j + 1] = arr[j + 1], arr[j]
    
        return ss
    
    ss = [2,6,3,4,1,9,4,3]
    print bubbleSort(ss)

# 2. 选择排序 #

选择排序是一种简单直观的排序算法，无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。

## 算法步骤 ##

1.  首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
2.  再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
3.  重复第二步，直到所有元素均排序完毕。  
    ![在这里插入图片描述][20190909162130858.gif]

def SelectSort(ss):
    
        n = len(ss)
        for i in range(n):
            min_index = i
            for j in range(i+1, n):
                if ss[j] < ss[min_index]:
                    min_index = j
    
            min_tmp = ss[min_index]
            ss[min_index] = ss[i]
            ss[i] = min_tmp
    		# if i != min_index:
    		#    ss[i], ss[min_index] = ss[min_index], ss[i]
            print(ss)
    
        return ss
        
    ss = [3, 44 , 38, 5, 47,15,36,26,27,2,46,4,50,48]
    print SelectSort(ss)

输出结果为：

[2, 44, 38, 5, 47, 15, 36, 26, 27, 3, 46, 4, 50, 48]
    [2, 3, 38, 5, 47, 15, 36, 26, 27, 44, 46, 4, 50, 48]
    [2, 3, 4, 5, 47, 15, 36, 26, 27, 44, 46, 38, 50, 48]
    [2, 3, 4, 5, 47, 15, 36, 26, 27, 44, 46, 38, 50, 48]
    [2, 3, 4, 5, 15, 47, 36, 26, 27, 44, 46, 38, 50, 48]
    [2, 3, 4, 5, 15, 26, 36, 47, 27, 44, 46, 38, 50, 48]
    [2, 3, 4, 5, 15, 26, 27, 47, 36, 44, 46, 38, 50, 48]
    [2, 3, 4, 5, 15, 26, 27, 36, 47, 44, 46, 38, 50, 48]
    [2, 3, 4, 5, 15, 26, 27, 36, 38, 44, 46, 47, 50, 48]
    [2, 3, 4, 5, 15, 26, 27, 36, 38, 44, 46, 47, 50, 48]
    [2, 3, 4, 5, 15, 26, 27, 36, 38, 44, 46, 47, 50, 48]
    [2, 3, 4, 5, 15, 26, 27, 36, 38, 44, 46, 47, 50, 48]
    [2, 3, 4, 5, 15, 26, 27, 36, 38, 44, 46, 47, 48, 50]
    [2, 3, 4, 5, 15, 26, 27, 36, 38, 44, 46, 47, 48, 50]
    [2, 3, 4, 5, 15, 26, 27, 36, 38, 44, 46, 47, 48, 50]

# 3. 插入排序(Insertion-Sort) #

## 算法步骤 ##

将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。

从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）  
![在这里插入图片描述][20190909162140332.gif]

def insertionSort(arr):
    
        n = len(arr)
    
        for i in range(n):
            preIndex = i-1
            current = arr[i]
    
            while(preIndex >= 0 and arr[preIndex] > current):
                arr[preIndex + 1]=arr[preIndex]
                preIndex = preIndex-1
            arr[preIndex+1] = current
            print arr
    
        return arr
    
    ss =  [38,3,5,44,47,15,36,26,27,2,46,4,19,50,48]
    print insertionSort(ss)

依次排序结果如下：  
\[38, 3, 5, 44, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48\]  
\[3, 38, 5, 44, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48\]  
\[3, 5, 38, 44, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48\]  
\[3, 5, 38, 44, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48\]  
\[3, 5, 38, 44, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48\]  
\[3, 5, 15, 38, 44, 47, 36, 26, 27, 2, 46, 4, 19, 50, 48\]  
\[3, 5, 15, 36, 38, 44, 47, 26, 27, 2, 46, 4, 19, 50, 48\]  
\[3, 5, 15, 26, 36, 38, 44, 47, 27, 2, 46, 4, 19, 50, 48\]  
\[3, 5, 15, 26, 27, 36, 38, 44, 47, 2, 46, 4, 19, 50, 48\]  
\[2, 3, 5, 15, 26, 27, 36, 38, 44, 47, 46, 4, 19, 50, 48\]  
\[2, 3, 5, 15, 26, 27, 36, 38, 44, 46, 47, 4, 19, 50, 48\]  
\[2, 3, 4, 5, 15, 26, 27, 36, 38, 44, 46, 47, 19, 50, 48\]  
\[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 50, 48\]  
\[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 50, 48\]  
\[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50\]  
\[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50\]

# 4. 希尔排序（shell sort） #

希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。

希尔排序是基于插入排序的以下两点性质而提出改进方法的：

插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；

但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位；

希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

## 算法步骤 ##

1.  选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
2.  按增量序列个数 k，对序列进行 k 趟排序；

每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。  
![在这里插入图片描述][20190909162221907.gif]

import math
    
    def shellsort(arr):
        
        n = len(arr)
        if n<= 1:
            return arr
    
        gap = n//2
    
        while gap >=1:
            shellInsert(arr,gap)
            gap = gap//2
            
        return arr
    
    def shellInsert(arr,d):
        n = len(arr)
        for i in range(d,n):
            j = i-d
            tmp = arr[i]
            while(j>=0 and arr[j] > tmp):
                arr[j+d] = arr[j]
                j = j-d
    
            if j != i-d:
                arr[j+d] = tmp
            
    
    ss =  [84,83,88,87,61,50,70,60,80,99]
    print shellsort(ss)

# 5.归并排序（Merge sort） #

归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

作为一种典型的分而治之思想的算法应用，归并排序的实现由两种方法：

自上而下的递归（所有递归的方法都可以用迭代重写，所以就有了第 2 种方法）；
    
    自下而上的迭代；

和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是 O(nlogn) 的时间复杂度。代价是需要额外的内存空间。

## 算法步骤 ##

1.把长度为n的输入序列分成两个长度为n/2的子序列；
    2.对这两个子序列分别采用归并排序；
    3.将两个排序好的子序列合并成一个最终的排序序列。

![在这里插入图片描述][20190909162326638.gif]

def mergesort(arr):
        
        n = len(arr)
        if n < 2:
            return arr
    
        middle = int(math.floor(n/2))
        print middle
        left = arr[0:middle]
    
        right = arr[middle:n]
        print left, right
        return merge(mergesort(left),mergesort(right))
        
    
    
    
    def merge(left,right):
        result = []
        while left and right:
            if left[0] <= right[0]:
                result.append(left.pop(0))
            else:
                result.append(right.pop(0))
    
        while left:
            result.append(left.pop(0))
    
        while right:
            result.append(right.pop(0))
    
        print "result: ",result
        return result
    
    ss =  [3,44,38,5,47,15,36,26,27,2,46,4,19,50,48]
    print mergesort(ss)

middle:  7
    left, right:  [3, 44, 38, 5, 47, 15, 36] [26, 27, 2, 46, 4, 19, 50, 48]
    middle:  3
    left, right:  [3, 44, 38] [5, 47, 15, 36]
    middle:  1
    left, right:  [3] [44, 38]
    middle:  1
    left, right:  [44] [38]
    result:  [38, 44]
    result:  [3, 38, 44]
    middle:  2
    left, right:  [5, 47] [15, 36]
    middle:  1
    left, right:  [5] [47]
    result:  [5, 47]
    middle:  1
    left, right:  [15] [36]
    result:  [15, 36]
    result:  [5, 15, 36, 47]
    result:  [3, 5, 15, 36, 38, 44, 47]
    middle:  4
    left, right:  [26, 27, 2, 46] [4, 19, 50, 48]
    middle:  2
    left, right:  [26, 27] [2, 46]
    middle:  1
    left, right:  [26] [27]
    result:  [26, 27]
    middle:  1
    left, right:  [2] [46]
    result:  [2, 46]
    result:  [2, 26, 27, 46]
    middle:  2
    left, right:  [4, 19] [50, 48]
    middle:  1
    left, right:  [4] [19]
    result:  [4, 19]
    middle:  1
    left, right:  [50] [48]
    result:  [48, 50]
    result:  [4, 19, 48, 50]
    result:  [2, 4, 19, 26, 27, 46, 48, 50]
    result:  [2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
    [2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

# 6.快速排序(Quick Sort) #

快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

## 算法描述 ##

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

1.  从数列中挑出一个元素，称为 “基准”（pivot）；
2.  重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
3.  递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。  
    ![在这里插入图片描述][20190909162351655.gif]

def quicksort(arr,left = None, right = None):
        n = len(arr)
        if not isinstance(left,(int,float)):
            left = 0
        else:
            left
    
        if not isinstance(right,(int,float)):
            right = n - 1
        else:
            right
    
    
        if left < right:
            partitionIndex = partition(arr, left, right)
            quicksort(arr,left, partitionIndex)
            quicksort(arr, partitionIndex+1, right)
    
        return arr
    
    def partition(arr, left, right):
        pivot = left
        high= pivot+1
       low = index
    
        while(low <=right):
            if arr[low ] < arr[pivot] :
                swap(arr, low , high)
                
                high += 1
    
           low  += 1
    
        swap(arr, pivot, high -1)
        
        return high -1
    
    def swap(arr, i, j):
        arr[i], arr[j] = arr[j] , arr[i]
    
    ss =  [44,3,38,5,47,15,36,26,27,2,46,4,19,50,48]
    print quicksort(ss)

\[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50\]

# 7.堆排序 #

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

## 算法描述 ##

1.将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；  
2.将堆顶元素R\[1\]与最后一个元素R\[n\]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R\[1,2…n-1\]<=R\[n\]；  
3.由于交换后新的堆顶R\[1\]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R\[1\]与无序区最后一个元素交换，得到新的无序(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。  
![在这里插入图片描述][20190909162406162.gif]

def buildMaxHeap(arr):
        import math
        for i in range(int(math.floor(len(arr)/2)),-1,-1):
            heapify(arr,i)
    
    def heapify(arr, i):
        left = 2*i+1
        right = 2*i+2
        largest = i
        if left < arrLen and arr[left] > arr[largest]:
            largest = left
        if right < arrLen and arr[right] > arr[largest]:
            largest = right
    
        if largest != i:
            swap(arr, i, largest)
            heapify(arr, largest)
    
    def swap(arr, i, j):
        arr[i], arr[j] = arr[j], arr[i]
    
    def heapSort(arr):
        global arrLen
        arrLen = len(arr)
        buildMaxHeap(arr)
        for i in range(len(arr)-1,0,-1):
            swap(arr,0,i)
            arrLen -=1
            heapify(arr, 0)
        return arr        
    
    ss =  [44,3,38,5,47,15,36,26,27,2,46,4,19,50,48]
    print heapSort(ss)

# 8.计数排序 #

计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。

## 算法描述 ##

1.  找出待排序的数组中最大和最小的元素；
2.  统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
3.  对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
4.  反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。  
    ![在这里插入图片描述][2019091916033682.gif]

def countingSort(arr):
        num_min = arr[0]
        num_max = 0
    
        for i in arr:
            if num_min > i:
                num_min = i
            if num_max < i:
                num_max = i
    
        tmp = {}
    
        for i in arr:
            if i in tmp.keys():
                tmp[i] += 1
            else:
                tmp[i] = 1
    
    
        result = []
    
        for i in range(num_min, num_max):
            if i in tmp.keys():
                for j in range(tmp[i]):
                    result.append(i)
    
    
        return result
                
                
    ss =  [44,3,38,5,47,15,36,26,27,2,46,4,19,50,48]
    print countingSort(ss)

# 9.桶排序 #

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排）。

## 算法描述 ##

1.设置一个定量的数组当作空桶；  
2.遍历输入数据，并且把数据一个一个放到对应的桶里去；  
3.对每个不是空的桶进行排序；  
4.从不是空的桶里把排好序的数据拼接起来。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9fbHhs_size_16_color_FFFFFF_t_70 2]

def bucketSort(arr):
        
        num_min = arr[0]
        num_max = 0
    
        
        for i in arr:
            if num_min > i:
                num_min = i
            if num_max < i:
                num_max = i
        print num_min, num_max
        d1 = [[] for x in range(10)]
        for i in arr:
            d1[int(i/10)].append(i)
    
    
        for i in range(len(d1)):
            insertionSort(d1[i]) #  // 对每个桶进行排序，这里使用了插入排序
            i+=1
    
        result = []
    
        for j in range(len(d1)):
                    if d1[j]:
                        for k in range(len(d1[j])):
                            result.append(d1[j][k])
    
    
    
        return result
    
        
    ss = [2, 15, 5, 9, 7, 6, 4, 12, 5, 4, 2, 64, 5, 6, 4, 2, 3, 54, 45, 4, 44]
        
    print bucketSort(ss)

\[2, 2, 2, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 7, 9, 12, 15, 44, 45, 54, 64\]

# 10.基数排序(radixSort) #

基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。

## 算法描述 ##

1.  取得数组中的最大数，并取得位数；
2.  arr为原始数组，从最低位开始取每个位组成radix数组；
3.  对radix进行计数排序（利用计数排序适用于小范围数的特点）；  
    ![在这里插入图片描述][20190909162526291.gif]

def radixSort(arr):
    
        # 基于最低位次排序
        d1 = [[] for x in range(10)]
        for i in arr:
            d1[int(i%10)].append(i)
    
    
        result_1 = []
        for i in d1:
            if i:
                for j in i:
                   result_1.append(j) # 基于最低位次排序后的数组
    
        #基于次低位次排序
                   
        d2 = [[] for x in range(10)]
        for i in result_1:
            d2[int(i/10)].append(i)
    
        result_2 = []
        for i in d2:
            if i:
                for j in i:
                   result_2.append(j) #  # 基于次低位次排序后的数组
    
        return result_2
    
    ss = [2, 15, 5, 9, 7, 6, 4, 12, 5, 4, 2, 64, 5, 6, 4, 2, 3, 54, 45, 4, 44]
        
    print radixSort(ss)

[Link 1]: https://blog.csdn.net/xiao_lxl/article/details/45482593
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9fbHhs_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/de00547593174ec1a84e237516bf6147.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9fbHhs_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/321a50f4d662463198b95fe4c350e45a.png
[20190909161800834.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/0e169bc045644cdeb2b39fcb0d3c3311.gif
[20190909162130858.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/4f827cc36fae47349258037e5e9318d5.gif
[20190909162140332.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/697a96927ea549648f533079b1a816d4.gif
[20190909162221907.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/ed99279a175d4378a54ff8c8c0fbdf8d.gif
[20190909162326638.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/2fc952ce7728480c81334c4e4be9cd2b.gif
[20190909162351655.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/5c0b5d5324bf4a80904e87319ab95ebd.gif
[20190909162406162.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/9114b3a91eb94533bb335a361ec44bb2.gif
[2019091916033682.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/bbc566612ddf4179a8cd90c79497955c.gif
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9fbHhs_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/8ab16fcb7a5840adbf707f2b4c88014d.png
[20190909162526291.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/01f02b9390574a0abe4fb8d675a960da.gif