八大排序算法汇总原理+图解+源码+复杂度分析

谁借莪１个温暖的怀抱￠ 2022-11-14 10:21 203阅读 0赞

# 排序算法 #

### 文章目录 ###

*  排序算法
 *   *  一、冒泡排序
     *  二、选择排序
     *  三、插入排序
     *  四、归并排序
     *  五、快速排序
     *  六、堆排序
     *  七、桶排序
     *   *  1. 计数排序
         *  2. 基数排序
     *  八、希尔排序
 *  排序算法总结

## 一、冒泡排序 ##

1.  原理
    
    将相邻两个数比较，将较大值移至后方，第一轮可将最大值移至最后方，第二轮可将前n - 1个数的最大值移至倒数第二个位置，持续此过程，比较n - 1轮，每一轮的比较次数都比上一轮少一次，第一轮需比较n - 1次
2.  图解
    
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA_size_16_color_FFFFFF_t_70][]
3.  代码
    
        public class BubbleSort { 
        
           public static void bubbleSort(int[] arr) { 
              if (arr == null || arr.length < 2) { 
                 return;
              }
              for (int e = arr.length - 1; e > 0; e--) { 
                 for (int i = 0; i < e; i++) { 
                    if (arr[i] > arr[i + 1]) { 
                       swap(arr, i, i + 1);
                    }
                 }
              }
           }
        
           public static void swap(int[] arr, int i, int j) { 
              int temp = arr[i];
              arr[i] = arr[j];
              arr[j] = temp;
           }
        }
4.  复杂度分析
    
    时间复杂度O(n2)（n方），空间复杂度O(1)

## 二、选择排序 ##

1.  原理
    
    arr\[0\] → arr\[n - 1\]之间选择一个最小的数放在arr\[0\]
    
    arr\[1\] → arr\[n - 1\]之间选择一个最小的数放在arr\[1\]
    
    arr\[2\] → arr\[n - 1\]之间选择一个最小的数放在arr\[2\]
    
    持续此过程…
    
    注意：每组都假设第一个值为最小，从后面的数中选择一个比第一个值更小的最小值，记录下它的索引，与第一个值交换，若无更小值，不交换
2.  图解
    
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA_size_16_color_FFFFFF_t_70 1][]
3.  代码
    
        public class SelectionSort { 
        
           public static void selectionSort(int[] arr) { 
              if (arr == null || arr.length < 2) { 
                 return;
              }
              for (int i = 0; i < arr.length - 1; i++) { 
                 int minIndex = i;
                 for (int j = i + 1; j < arr.length; j++) { 
                    minIndex = arr[j] < arr[minIndex] ? j : minIndex;
                 }
                 swap(arr, i, minIndex);
              }
           }
        
           public static void swap(int[] arr, int i, int j) { 
              int tmp = arr[i];
              arr[i] = arr[j];
              arr[j] = tmp;
           }
        }
4.  复杂度分析
    
    时间复杂度O(n2)（n方），空间复杂度O(1)

## 三、插入排序 ##

1.  原理
    
    从前向后遍历数组，每个数都将其与其之前的所有数两两进行比较，将其插入到合适位置
2.  图解
    
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA_size_16_color_FFFFFF_t_70 2][]
3.  代码
    
        public class InsertionSort { 
        
           public static void insertionSort(int[] arr) { 
              if (arr == null || arr.length < 2) { 
                 return;
              }
              for (int i = 1; i < arr.length; i++) { 
                 for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) { 
                    swap(arr, j, j + 1);
                 }
              }
           }
        
           public static void swap(int[] arr, int i, int j) { 
              int temp = arr[i];
              arr[i] = arr[j];
              arr[j] = temp;
           }
        }
4.  复杂度分析
    
    时间复杂度O(n2)（n方），空间复杂度O(1)

## 四、归并排序 ##

1.  原理
    
    宏观上将一个大的数组分成左和右两部分，左部分排好序，右部分排好序，使用两个指针分别指向两部分的开头，借用一个数组空间，比较两个指针所指向的值的大小，将较小值放入借用的数组中，并向后遍历，最终将两部分归并成一个有序的数组
2.  图解
    
    宏观：
    
    ![20210328195323532.png][]
    
    微观：
    
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA_size_16_color_FFFFFF_t_70 3][]
3.  代码
    
        public class MergeSort { 
        
           public static void mergeSort(int[] arr) { 
              if (arr == null || arr.length < 2) { 
                 return;
              }
              mergeSort(arr, 0, arr.length - 1);
           }
        
           public static void mergeSort(int[] arr, int l, int r) { 
              if (l == r) { 
                 return;
              }
              int mid = l + ((r - l) >> 1);
              mergeSort(arr, l, mid); //分治
              mergeSort(arr, mid + 1, r); //分治
              merge(arr, l, mid, r); //归并、排序
           }
        
           public static void merge(int[] arr, int l, int m, int r) { 
              int[] help = new int[r - l + 1]; //借用的数组
              int i = 0; //指向借用的数组首元素
              int p1 = l; //指向左半部分首元素
              int p2 = m + 1; //指向右半部分首元素
              while (p1 <= m && p2 <= r) { 
                 help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
              }
              while (p1 <= m) { 
                 help[i++] = arr[p1++];
              }
              while (p2 <= r) { 
                 help[i++] = arr[p2++];
              }
              //将已经排好序的借用的数组复制到原数组
              for (i = 0; i < help.length; i++) { 
                 arr[l + i] = help[i];
              }
           }
        }
4.  复杂度分析
    
    时间复杂度O(nlogn)，空间复杂度O(n)，空间复杂度主要是merge过程中产生
5.  复杂度计算方式
    
    使用master公式：T(n) = 2 \* T(N / 2) + O(n)，其中O(n)是merge过程

## 五、快速排序 ##

1.  原理
    
    将小于数组中最后一个数r的数放在左边，等于的放在中间，大于的放在右边；从数组的左边 -1开始划定只放小于r的数的区域，数组的最右边开始划定只放大于r的数的区域(此时r被包含在这个区域)，使用指针L遍历数组，小于r的数与左边区域的后一个值进行交换，区域++，L++；等于r的数，不交换，L++；大于r的数，与右边区域的前一个值进行交换，区域–，L不动，此时需判断L处交换来的值与r值的关系，重复以上；完成之后，将r与右边区域的第一个值进行交换，保证了左小，中间等于，右大；对左小、右大区域分别递归上述过程，让两边区域都满足左小，中间等于，右大，持续直到不可划分，即可完成排序 (经典快排)
2.  图解
    
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA_size_16_color_FFFFFF_t_70 4][]
3.  代码
    
        public static void quickSort(int[] arr) { 
           if (arr == null || arr.length < 2) { 
              return;
           }
           quickSort(arr, 0, arr.length - 1);
        }
        
        public static void quickSort(int[] arr, int l, int r) { 
           if (l < r) { 
              //加上此语句，即可变成随机快排
              //swap(arr, l + (int) (Math.random() * (r - l + 1)), r);
              int[] p = partition(arr, l, r);
              //对左小，右大区域进行递归，直到不可划分的最小区域
              quickSort(arr, l, p[0] - 1);
              quickSort(arr, p[1] + 1, r);
           }
        }
        
        public static int[] partition(int[] arr, int l, int r) { 
           int less = l - 1;
           int more = r;
           while (l < more) {  //不能写等于
              if (arr[l] < arr[r]) { 
                 swap(arr, ++less, l++);
               } else if (arr[l] > arr[r]) { 
                 //等于的情况，会执行此句，与--more交换值会错误
                 swap(arr, --more, l);
              } else { 
                 l++;
              }
           }
           swap(arr, more, r);
           return new int[] {  less + 1, more };
        }
        
        public static void swap(int[] arr, int i, int j) { 
           int tmp = arr[i];
           arr[i] = arr[j];
           arr[j] = tmp;
        }
4.  复杂度分析
    
    最坏情况下，最后一个数永远是每次需要递归的数组的最大值，则相当于每次只能确 定最后一个数(因为所有的数都比它小，不会划分出来左右区域，只能向前递归)，时间复杂度为O(n2)（n方）
5.  随即快排
    
    每次递归时都将数组中的一个随机数与最后一个值进行交换，防止出现上述最坏情况，但此时复杂度的好与坏是一个概率事件(因为不知道谁与最后一个值交换)，根据数学期望计算，随机快排的时间复杂度为O(nlogn)，空间复杂度为O(logn)

注意：空间复杂度主要是根据确定左、右区域的分割点占用的空间来决定，期望值为O(logn)

## 六、堆排序 ##

1.  需要了解的两个过程
    
    (1) 将数组转换成大顶堆的heapInsert()方法
    
     *  过程：从前向后遍历数组，每遍历到一个元素，就将其与其之前的所有数都转换成大顶堆，每次添加新元素到大顶堆时，都需要将其与其父节点的大小进行比较，若此元素的值大于父节点的值，则二者的值交换，若交换后还有父节点，则需要继续与上层的父节点进行比较，每个元素都重复上述步骤，即可转换成大顶堆
     *  图解
        
        ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA_size_16_color_FFFFFF_t_70 5][]
    
    
    
    (2) 重新调整堆为大顶堆的heapify()方法
    
     *  过程：过程：当大顶堆的某一父结点的值变化(变小)时，需要重新调整其成为大顶堆，将值变化后的父节点与其左右孩子结点中的较大值进行比较，较大值与其交换，若交换后还有孩子节点，继续上述比较，即可将堆重新调整为大顶堆
     *  图解
        
        ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA_size_16_color_FFFFFF_t_70 6][]
2.  堆排序思路
    
    首先将数组中的所有元素执行heapInsert方法，转换成大顶堆，将大顶堆的堆顶结点与最后一个结点进行交换，此时原数组中的最大值已移至最后，堆长度 - 1，执行heapify方法，将剩余元素重新调整为大顶堆，再将堆顶结点与最后一个结点进行交换…重复上述，即可完成对数组的堆排序
3.  代码
    
        public static void heapSort(int[] arr) { 
           if (arr == null || arr.length < 2) { 
              return;
           }
           for (int i = 0; i < arr.length; i++) { 
              heapInsert(arr, i); //对每个元素执行heapInsert方法
           }
           //执行到此处已将数组转换成大顶堆
           int size = arr.length;
           swap(arr, 0, --size); //堆顶结点与最后一个结点进行交换
           //每交换一次其余结点就需要重新调整为大顶堆一次(堆长度减一)，直到堆长度为0
           while (size > 0) { 
              heapify(arr, 0, size);
              swap(arr, 0, --size);
           }
        }
        
        public static void heapInsert(int[] arr, int index) { 
           while (arr[index] > arr[(index - 1) / 2]) { 
              swap(arr, index, (index - 1) / 2);
              index = (index - 1) / 2;
           }
        }
        
        public static void heapify(int[] arr, int index, int size) { 
           int left = index * 2 + 1;
           while (left < size) { 
              //求左右孩子结点中的较大值的索引
              int largest = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left;
              //将孩子节点中的较大值与父节点比较，求较大者的索引
              largest = arr[largest] > arr[index] ? largest : index;
              if (largest == index) { 
                 break; //如果父节点大于孩子节点中的较大者，无需向下比较
              }
              //执行到此说明父节点比孩子节点中的较大者小，需要交换
              swap(arr, largest, index);
              index = largest;
              left = index * 2 + 1; //继续与下面的孩子结点比较(如果有)
           }
        }
        
        public static void swap(int[] arr, int i, int j) { 
           int tmp = arr[i];
           arr[i] = arr[j];
           arr[j] = tmp;
        }
4.  复杂度分析
    
    时间复杂度O(nlogn)，空间复杂度O(1)

注意：如果只是将数组转换成大顶堆(heapInsert)，则时间复杂度是O(n)，复杂度用于循环的与父节点进行比较大小，第n个结点比较logn次(层数)，O(log1 + lon2 + …+ logn)极限值为O(n)

## 七、桶排序 ##

*  概念：非基于比较的排序，之前的均为基于比较的排序
 *  分类：计数排序、基数排序
 *  复杂度：时间复杂度为O(n)，空间复杂度为O(n)

### 1. 计数排序 ###

1.  原理
    
    取出原数组中的最大值，创建一个容量为最大值 + 1的新数组(比如最大值为5，则数据可能为0 ~ 5，共6个数)，遍历原数组，元素的值为几就放入几号桶，对应的桶值++，根据桶的值就可以知道该桶中有几个相同的数，再依次从小到大从桶中取出数据放入原数组，即可完成排序
2.  代码
    
        public static void bucketSort(int[] arr) { 
           if (arr == null || arr.length < 2) { 
              return;
           }
           int max = Integer.MIN_VALUE; //保证max比数组中任何一个数都小
           //将max变为数组中的最大值
           for (int i = 0; i < arr.length; i++) { 
              max = Math.max(max, arr[i]);
           }
           int[] bucket = new int[max + 1];
           //将数组中的元素依次放入对应的桶
           for (int i = 0; i < arr.length; i++) { 
              bucket[arr[i]]++;
           }
           int i = 0; //指向原数组，用于往数组中放入桶中的数据
           for (int j = 0; j < bucket.length; j++) { 
              while (bucket[j]-- > 0) {  //将每一个桶中的数据全部取出
                 arr[i++] = j;
              }
           }
        }

### 2. 基数排序 ###

1.  原理
    
    对数组中所有数先按照个位排序，再按照十位排序，再按照百位排序…持续此过程直到所有数中的最大位数也排好序，则整个数组完成排序
2.  过程
    
    先找到数组中最大数，求其位数，对数组中其他数不满足最大位数的在左边补零直到满足最大位数，准备十个桶(二维数组)，对所有数字按照个位进对应的桶，再从桶中从左向右取出所有数，此时所有数按照个位已经排好序；然后对十位重复此操作，百位也重复此操作…直到最大位数也完成此操作，即可完成排序
3.  注意
    
    基数排序只适合所有数字非负的情况，并且假设此时所有的数都是十进制
4.  图解
    
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA_size_16_color_FFFFFF_t_70 7][]
5.  代码实现
    
        public static void radixSort(int[] arr) { 
           Integer maxValue = Integer.MIN_VALUE; //记录数组中的最大值
           for (int i = 0; i < arr.length; i++) { 
              maxValue = Math.max(arr[i], maxValue);
           }
           int maxLength = (maxValue + "").length(); //记录最大值的位数
           int[][] bucket = new int[10][arr.length]; //创建10个桶
           int[] bucketCounts = new int[10]; //记录每个桶有多少个数据
           //i用来表示有多少位就要循环的入桶、出桶多少次
           //n用来计算每一次循环每个数的对应位的值时多少
           for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {  //有多少位就要循环入桶、出通多少次
              for (int j = 0; j < arr.length; j++) {  //j用来遍历数组中的数据
                 int digitOfElement = arr[j] / n % 10; //表示对应位数上的值
                 bucket[digitOfElement][bucketCounts[digitOfElement]++] = arr[j];
              }
              //内层for循环第一轮执行完之后，所有的数已经按照个位进入对应的桶，此时需取出桶中数据
              int index = 0; //指向原始数组，用来将桶中的数据放入原始数组中
              for (int k = 0; k < bucket.length; k++) {  //遍历每个桶
                 if (bucketCounts[k] != 0) {  //桶中有数据时才往出取
                    for (int l = 0; l < bucketCounts[k]; l++) { 
                       arr[index++] = bucket[k][l];
                    }
                 }
                 //桶中的数据被取出之后，将每个桶中的数据清空
                 bucketCounts[k] = 0;
              }
           }
        }

## 八、希尔排序 ##

1.  使用原因
    
    插入排序有一种情况比较消耗性能，如下图：
    
    ![image-20210416004909191][]
    
    元素1要与其之前的所有元素进行比较才可以移动到第一个位置，但实际上为了提高效率，可以直接对1加大比较的跨度，一次比较就能把1放到更前面的位置，从而减少比较的次数，这就是希尔排序的思想，故希尔排序又叫 “缩小增量排序”
2.  原理
    
     *  选择一个增量，一般增量取值为 `数组长度 / 2` ，按照增量将数据进行分组
     *  对分好组的每一组数据都完成插入排序
     *  缩小增量，默认缩小方式为 `增量 / 2` ，重复上一步操作，直到增量缩小为1（插入排序）
3.  图解
    
    ![image-20210416005741819][]
4.  代码实现
    
        public static void shellSort(int[] arr) { 
            if (arr == null || arr.length < 2) { 
                return;
            }
            //确定初始增量
            int incrment = arr.length / 2;
            while (incrment > 0) { 
                //找到每一组待插入的元素，第一个待插入元素的索引等于增量值
                for (int i = incrment; i < arr.length; i++) { 
                    //将待插入元素按照插入排序的规则添加到分组对应的位置
                    for (int j = i - incrment; j >= 0; j -= incrment) { 
                        if (arr[j] > arr[j + incrment]) { 
                            swap(arr, j, j + incrment);
                        } else { 
                            break;
                        }
                    }
                }
                //将增量缩小
                incrment = incrment / 2;
            }
        }
        
        public static void swap(int[] arr, int i, int j) { 
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
5.  复杂度分析
    
    时间复杂度O(nlogn)，空间复杂度O(1)

# 排序算法总结 #

*  几个概念
    
     *  稳定性：相同值的元素排序后相对次序保持不变(相同值原来在前面的，排序后依然在前面)，并不是说算法时快时慢
     *  in - place：占用常数内存，不占用额外内存
     *  out - place：占用额外内存
 *  各种算法比较
    
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA_size_16_color_FFFFFF_t_70 8][]
 *  追求速度使用快排，节省空间使用堆排序，追求稳定性使用归并排序

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA_size_16_color_FFFFFF_t_70]: /images/20221022/ed44c2117f8f44adb13dad6ee470effe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210328195302662.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210328195313329.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA==,size_16,color_FFFFFF,t_70
[20210328195323532.png]: https://img-blog.csdnimg.cn/20210328195323532.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/2021032819533185.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20210328195406687.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20210328195433208.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20210328195447905.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/2021032819550950.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA==,size_16,color_FFFFFF,t_70
[image-20210416004909191]: https://typora-pic-1304435145.cos.ap-beijing.myqcloud.com/image-20210416004909191.png
[image-20210416005741819]: https://typora-pic-1304435145.cos.ap-beijing.myqcloud.com/image-20210416005741819.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/2021032819552731.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA==,size_16,color_FFFFFF,t_70