数据结构——八大排序算法（面试必备）

拼搏现实的明天。 2022-10-15 00:41 215阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70]  
**1. 交换排序——冒泡排序**

> 从要排序序列的第一个元素开始，一次比较相邻元素的值，发现逆序则交换，将值较大的元素逐渐从前向后移动。  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 1]

public void bubbleSort(int[] arr){ 
        for (int i = 0; i < arr.length - 1; i++) { 
            for (int j = 0; j < arr.length - 1 - i; j++) { 
                if (arr[j] > arr[j + 1]) { 
                    int t = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = t;
                }
            }
        }
    }

**优化**：如果某次排序中，没有发生交换，则可结束排序

public void bubbleSort(int[] arr){ 
        boolean flag = false;//表示没有发生过交换
        for (int i = 0; i < arr.length - 1; i++) { 
            for (int j = 0; j < arr.length - 1 - i; j++) { 
                if (arr[j] > arr[j + 1]) { 
                    int t = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = t;
                    flag = true;//发生交换
                }
            }
            if (!flag)
                break;
            else
                flag = false;//重置flag,进行下次判断
        }
    }

**时间复杂度**：O(n^2)  
稳定

**2. 交换排序——快速排序**

> 快速排序（Quicksort）是对冒泡排序的一种改进。基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列

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

public static void quickSort(int[] arr, int left, int right) { 
        int l = left;
        int r = right;
        int pivot = arr[(left + right) / 2];
        //while循环是为了让比pivot小的值放其左边,比pivot大的值放其右边
        while (l < r) { 
            while (arr[l] < pivot)//直到找到比pivot小的数
                l++;
            while (arr[r] > pivot)//直到找到比pivot大的数
                r--;
            if (l >= r)//说明比pivot小的值都在其左边,比pivot大的值都在其右边
                break;
            //找到pivot左边比其大的元素,右边比其小的元素;进行交换
            int t = arr[l];
            arr[l] = arr[r];
            arr[r] = t;
        }
        //如果l==r,则要l++、r--;否则会出现栈溢出
        if (l == r) { 
            l++;
            r--;
        }
        //向左递归
        if (left < r)
            quickSort(arr, left, r);
        //向右递归
        if (right > l)
            quickSort(arr, l, right);
    }

**时间复杂度**：O(nlog2n)  
不稳定

**3. 选择排序——简单选择排序**

> 基本思想：  
> 第一次从 arr\[0\]~arr\[n-1\]中选取最小值，与 arr\[0\]交换  
> 第二次从 arr\[1\]~arr\[n-1\]中选取最小值，与 arr\[1\]交换  
> 第三次从 arr\[2\]~arr\[n-1\]中选取最小值，与 arr\[2\] 交换…  
> 第 i 次从 arr\[i-1\]~arr\[n-1\]中选取最小值，与 arr\[i-1\]交换…  
> 第 n-1 次从 arr\[n-2\]~arr\[n-1\]中选取最小值，与 arr\[n-2\]交换  
> 总共通过 n-1 次，得到一个按排序码从小到大排列的有序序列

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

public void selectSort(int[] arr){ 
        for (int i = 0; i < arr.length - 1; i++) { 
            int min = arr[i];//假设当前值最小
            int minIndex = i;//记录最小值的索引
            for (int j = i + 1; j < arr.length; j++) { 
                if (arr[j] < min) { 
                    min = arr[j];
                    minIndex = j;
                }
            }
            if (minIndex != i) { 
                arr[minIndex] = arr[i];
                arr[i] = min;
            }
        }
    }

**时间复杂度**：O(n^2)  
不稳定

**4. 选择排序——堆排序**

> 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。

**什么是堆**  
堆是具有以下性质的完全二叉树

每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆（没有要求结点的左孩子的值和右孩子的值的大小关系）

arr[i] >= arr[2*i+1] && arr[i] >= arr[2*i+2]  //i对应第几个节点，i从0开始编号

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 4]  
我们对堆中的结点按层进行编号，映射到数组中就是下面这个样子:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 5]  
每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆

> arr\[i\] <= arr\[2*i+1\] && arr\[i\] <= arr\[2*i+2\] //i对应第几个节点，i从0开始编号

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 6]  
**堆排序基本思想**  
（1）将待排序序列构造成一个大顶堆  
（2）此时，整个序列的最大值就是堆顶的根节点。  
（3）将其与末尾元素进行交换，此时末尾就为最大值。  
（4）然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。  
一般升序采用大顶堆，降序采用小顶堆

**步骤图解**

> 步骤一：构造初始堆，将给定无序序列构造成一个大顶堆（一般升序采用大顶堆，降序采用小顶堆)

原始的数组 \[4, 6, 8, 5, 9\]

1.假设给定无序序列结构如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 7]  
2.此时我们从最后一个非叶子结点开始（叶结点不用调整，第一个非叶子结点 arr.length/2-1=5/2-1=1，也就是下面的6结点），从左至右，从下至上进行调整

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 8]  
3.找到第二个非叶节点 4，由于\[4,9,8\]中 9 元素最大，4 和 9 交换  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 9]  
4.这时，交换导致了子根\[4,5,6\]结构混乱，继续调整，\[4,5,6\]中 6 最大，交换 4 和 6  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 10]  
此时，我们就将一个无序序列构造成了一个大顶堆

> 步骤二：将堆顶元素与末尾元素进行交换，使末尾元素最大。然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行交换、重建、交换

1.将堆顶元素 9 和末尾元素 4 进行交换  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 11]  
2.重新调整结构，使其继续满足堆定义  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 12]  
3.再将堆顶元素 8 与末尾元素 5 进行交换，得到第二大元素 8  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 13]  
4.后续过程，继续进行调整，交换，如此反复进行，最终使得整个序列有序  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 14]  
**代码实现**

import java.util.Arrays;
    
    public class HeapSort { 
        public static void main(String[] args) { 
            int[] arr = { 3, 5, 2, 7, 8, 0, -1, 99};
            heapSort(arr);
            System.out.println(Arrays.toString(arr));
        }
    
        //堆排序
        public static void heapSort(int[] arr) { 
            //将无序序列构建成一个堆
            for (int i = arr.length / 2 - 1; i >= 0; i--) { 
                adjustHeap(arr, i, arr.length);
            }
            //将堆顶元素和末尾元素交换,将最大元素放置数组末端
            //重新调整至堆结构,然后继续将堆顶元素和当前末尾元素交换,以此往复
            for (int i = arr.length - 1; i > 0; i--) { 
                int temp = arr[i];
                arr[i] = arr[0];
                arr[0] = temp;
                adjustHeap(arr, 0, i);
            }
        }
    
        /** * 将二叉树调整为堆 * * @param arr 待调整的数组 * @param i 表示非叶子结点在数组中索引 * @param length 表示对多少个元素继续调整,length逐渐减少 */
        public static void adjustHeap(int[] arr, int i, int length) { 
            int temp = arr[i];
            //k=2i+1是i的左子节点
            for (int k = i * 2 + 1; k < length; k = k * 2 + 1) { 
                if (k + 1 < length && arr[k] < arr[k + 1])//左子节点的值<右子节点的值
                    k++;//指向右节点
                if (arr[k] > temp) { //如果子结点的值>父节点的值
                    arr[i] = arr[k];//将较大的值赋给当前节点
                    i = k;//i指向k,继续循环比较
                } else
                    break;
            }
            //for循环后,已经将以i为父结点的树的最大值,放在了顶部
            arr[i] = temp;//将temp值放到调整后的位置
        }
    }

**5. 插入排序——简单插入排序**

> 基本思想：把 n 个待排序的元素看成为一个有序表和一个无序表，开始时 有序表 中只包含一个元素，无序表中包含有 n-1 个元素，排序过程中每次从无序表中取出第一个元素，与有序表中的元素进行比较，将它插入到有序表中的适当位置，使之成为新的有序表

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

public void InserSort(int[] arr){ 
        for (int i = 1; i < arr.length; i++) { 
            int insertVal = arr[i];//待插入左边有序表的数
            int left_index = i - 1;//左边有序表的索引,初值为有序表最右数的索引
            while (left_index >= 0 && insertVal < arr[left_index]) { //不断遍历左边的有序表进行比较
                arr[left_index + 1] = arr[left_index];//比较过的值右移
                left_index--;//索引-1,继续比较
            }
            if (left_index + 1 != i)
                arr[left_index + 1] = insertVal;
        }
    }

**时间复杂度**：O(n^2)  
稳定

**6. 插入排序——希尔排序**

> 简单的插入排序可能存在的问题：当需要插入的数是较小的数时，后移的次数明显增多，对效率有影响

比如数组 arr = \{2,3,4,5,6,1\} 这时需要插入的数 1(最小)，这样的过程是  
\{2,3,4,5,6,6\}  
\{2,3,4,5,5,6\}  
\{2,3,4,4,5,6\}  
\{2,3,3,4,5,6\}  
\{2,2,3,4,5,6\}  
\{1,2,3,4,5,6\}

为了改进，提出了希尔排序算法：

希尔排序是希尔（Donald Shell）于 1959 年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 16]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 17]

//交换式
    public void shellSort(int[] arr){ 
        for(int gap=arr.length/2;gap>0;gap/=2){ 	//步长gap逐次递减
            for(int i=gap;i<arr.length;i++){ 
                for(int j=i-gap;j>=0;j-=gap){ 
                    if(arr[j]>arr[j+gap]){ 
                        int t=arr[j];
                        arr[j]=arr[j+gap];
                        arr[j+gap]=t;
                    }
                }
            }
        }
    }
    
    //改进成移位法
    public void shellSort(int[] arr){ 
        for (int gap = arr.length / 2; gap > 0; gap /= 2) { //步长gap逐次递减
            for (int i = gap; i < arr.length; i++) { 
                int left_index = i - gap;//左边有序表的索引,初值为有序表最右数的索引
                int insertVal = arr[i];//要插入的值
                while (left_index >= 0 && insertVal < arr[left_index]) { 
                    arr[left_index + gap] = arr[left_index];//比较过的值右移
                    left_index -= gap;
                }
                arr[left_index + gap] = insertVal;
            }
        }
    }

**时间复杂度**：O(nlog2n)  
不稳定

**7. 归并排序**

> 归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治策略(divide-and-conquer)  
> 分治法将问题分(divide)成一些小的问题然后递归求解  
> 而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之

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

> 再来看看治阶段，我们需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将\[4,5,7,8\]和\[1,2,3,6\]两个已经有序的子序列，合并为最终序列\[1,2,3,4,5,6,7,8\]，来看下实现步骤

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

> 左边序列和右边序列分别有一个索引指向第一个元素，然后进行比较，较小的元素存入一个临时数组temp，较小元素边序列索引右移，以此往复不断比较存入，直到一边的索引走到该子序列的最后；然后将有剩余数据的序列的剩余值直接按序存入temp数组中；  
> 最后所有元素都存入临时数组temp中，此时temp数组中的元素有序  
> 最后将temp数组拷贝回原数组，即实现了排序

package test;
    
    import java.util.*;
    
    public class Main { 
        public static void main(String[] args) { 
            int[] arr = { 8, 10, -1, 6, 7, 3, 0, 40, 70};
            int[] temp = new int[arr.length];//归并排序需要额外的空间
            mergeSort(arr, 0, arr.length - 1, temp);
            System.out.println(Arrays.toString(arr));
        }
    
        //分+合方法
        public static void mergeSort(int[] arr, int left, int right, int[] temp) { 
            if (left < right) { 
                int mid = (left + right) / 2;//中间索引
                mergeSort(arr, left, mid, temp);//向左递归分解
                mergeSort(arr, mid + 1, right, temp);//向右递归分解
                merge(arr, left, mid, right, temp);//合并
            }
        }
    
        //合并方法
        public static void merge(int[] arr, int left, int mid, int right, int[] temp) { 
            int i = left;//i为指向左边序列第一个元素的索引
            int j = mid + 1;//j为指向右边序列第一个元素的索引
            int t = 0;//指向临时temp数组的当前索引
    
            //先把左右两边有序数据按规则存入temp数组中,直到有一边的数据全部填充temp中
            while (i <= mid && j <= right) { 
                if (arr[i] <= arr[j]) { 
                    temp[t] = arr[i];
                    t++;
                    i++;
                } else { 
                    temp[t] = arr[j];
                    t++;
                    j++;
                }
            }
    
            //将有剩余数据的一边全部存入temp中
            while (i <= mid) { //左边序列有剩余元素
                temp[t] = arr[i];
                t++;
                i++;
            }
            while (j <= right) { //右边序列有剩余元素
                temp[t] = arr[j];
                t++;
                j++;
            }
    
            /** * 将temp中的元素拷贝到arr中 * 注意:不是每次都拷贝全部元素 * 第一次:tempLeft=0,right=1 * 第二次:tempLeft=2,right=3 * 第三次:tempLeft=0,right=3 */
            t = 0;
            int tempLeft = left;
            while (tempLeft <= right) { 
                arr[tempLeft] = temp[t];
                t++;
                tempLeft++;
            }
        }
    }

**时间复杂度**：O(nlog2n)  
稳定

**8. 基数排序**

> （1）基数排序radix sort属于“分配式排序”(distribution sort)，又称“桶子法”(bucket sort)或bin sort，顾名思义，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用  
> （2）基数排序法是属于稳定性的排序，基数排序法的是效率高的稳定性排序法  
> （3）基数排序(Radix Sort)是桶排序的扩展  
> （4）基数排序是 1887 年赫尔曼·何乐礼发明的。它是这样实现的：将整数按位数切割成不同的数字，然后按每个位数分别比较。  
> 基数排序基本思想：  
> 将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。 这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。

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

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

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

package test;
    
    import java.util.Arrays;
    
    public class Main { 
        public static void main(String[] args) { 
            int[] arr = { 8, 10, 6, 7, 3, 0, 40, 70};
            radixSort(arr);
            System.out.println(Arrays.toString(arr));
        }
    
        public static void radixSort(int[] arr) { 
            //定义一个二维数组,表示10个桶,每一个桶就是一个一维数组
            int[][] bucket = new int[10][arr.length];//可能每个桶不会用满,所以基数排序是使用空间换时间的经典算法
            //定义一个一维数组记录每个桶每次放入数据的个数
            int[] bucketCounts = new int[10];
            //找到数组中最大数
            int max = arr[0];
            for (int i = 0; i < arr.length; i++) { 
                if (arr[i] > max)
                    max = arr[i];
            }
            //获得最大数的位数，即为循环的次数,也就是要判断的总位数(个、十、百、千)
            int maxLength = (max + "").length();
    
            //针对每个元素的位进行比较
            for (int c = 0, n = 1; c < maxLength; c++, n *= 10) { 
                for (int i = 0; i < arr.length; i++) { 
                    //取出每个元素对应位的值(个位-->十位-->百位---)
                    int digit = arr[i] / n % 10;//个位:%10 十位:/10再%10 百位:/100再%10
                    //放入桶中
                    bucket[digit][bucketCounts[digit]] = arr[i];
                    bucketCounts[digit]++;
                }
                int index = 0;
                //遍历每个桶,将桶中的数据放回到原数组
                for (int j = 0; j < 10; j++) { 
                    if (bucketCounts[j] != 0) { //如果桶不为空
                        for (int k = 0; k < bucketCounts[j]; k++) { 
                            arr[index] = bucket[j][k];
                            index++;
                        }
                    }
                    bucketCounts[j] = 0;//清空每个桶的数据
                }
            }
        }
    }

负数问题：在找最大数的同时找最小值 如果最小值小于0就给每个值加上最小值的相反数，再比较

1.基数排序是对传统桶排序的扩展，速度很快  
2.基数排序是经典的空间换时间的方式，占用内存很大，当对海量数据排序时，容易造成OutOfMemoryError  
3.基数排序时稳定的  
4.有负数的数组，我们不用基数排序来进行排序，如果要支持负数，参考: [https://code.i-harness.com/zh-CN/q/e98fa9][https_code.i-harness.com_zh-CN_q_e98fa9]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70]: /images/20221014/af06a1c1f0594fbab55e4aae2bd3b65b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 1]: /images/20221014/881c26dc65ec44f78c57e8b7b6553be6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 2]: /images/20221014/24a8dbb937df4e3996ff386eb588fefc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 3]: /images/20221014/79f8ea7050cc4f00912a9ec131951fa9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 4]: /images/20221014/72c8cbd54ec44778870769b4039bc6ab.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 5]: /images/20221014/7463514ca4ec4af9a9c52864288a6a33.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 6]: /images/20221014/62368883882d4365a70789c14a840d14.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 7]: /images/20221014/8a4da68d97b642be9df6a58142ea81f1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 8]: /images/20221014/88e4fafb218c48c994a56aaaa58e3882.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 9]: /images/20221014/c99f904718304994a5b882fa0e922787.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 10]: /images/20221014/95ab8d3fa7f24686a6c043b2e29860c2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 11]: /images/20221014/055cbcbcfe6c4c5f8ed0a16fdcd1d0f0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 12]: /images/20221014/bf342f043ca3423285155e8e742c6c2e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 13]: /images/20221014/3fdced87e9b34eb09f574045c0e8808e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 14]: /images/20221014/008a1f68ee774175ad1b320734293318.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 15]: /images/20221014/f1065ea4711147b89e624c96e88a482d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 16]: /images/20221014/9205aafc0bad45ef8f665730723547a0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 17]: /images/20221014/1757cd8972b8452992b4bb95aa3e921e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 18]: /images/20221014/a1f7d338125e43c08d197943b08bb609.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 19]: /images/20221014/20fd748800c9446f8bb56d88580fe36d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 20]: /images/20221014/12a22ef3d1de4008923b6cb889aa7e2b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 21]: /images/20221014/434dc595a9664f3285abce3029664245.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 22]: /images/20221014/8da0143736884f6ba1d791510a5c370e.png
[https_code.i-harness.com_zh-CN_q_e98fa9]: https://code.i-harness.com/zh-CN/q/e98fa9