数据结构-非线性结构-树形结构：有序树 -＞二叉树 -＞平衡二叉树（任何节点的左右子树的高度差不大于1）-＞ AVL树【O(logn)】【二分搜索树&平衡二叉树】【旋转类型：LL/RR/LR/RL】

迷南。 2023-10-04 12:27 5阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70_pic_center]  
**平衡二叉树**（AVL树）：当且仅当任何节点的两棵子树的高度差不大于1的二叉树；

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

## 一、AVL 树（二分搜索树&平衡二叉树） ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70_pic_center 2]  
AVL树是二分搜索树的改进版，防止二分搜索树在一些情况下退化为链表。

AVL树最大高度：  l o g n logn logn

### 1、自平衡机制 ###

![在这里插入图片描述][20210512121513379.gif_pic_center]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70_pic_center 3]  
![在这里插入图片描述][20210512121706129.gif_pic_center]

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

### 2、平衡二叉树代码实现 ###

import java.util.ArrayList;
    
    /**
     * AVL平衡二叉树
     *
     * @author whx
     * @version 2018/9/1
     */
    public class AVLTree<K extends Comparable<K>,V> {
        
    
    	private Node root;
    	private int size;
    
    	public AVLTree() {
        
    		root = null;
    		size = 0;
    	}
    
    	/**
    	 * 获取某个节点的高度
    	 *
    	 * @param node
    	 * @return int
    	 * @author whx
    	 * @version 2018/9/1
    	 */
    	private int getHeight(Node node){
        
    		if(node == null){
        
    			return 0;
    		}
    		return node.height;
    	}
    
    	/**
    	 * 获取某个节点的平衡因子
    	 *
    	 * @param node
    	 * @return int
    	 * @author whx
    	 * @version 2018/9/1
    	 */
    	private int getBalanceFactor(Node node){
        
    		if (node == null) {
        
    			return 0;
    		}
    		return getHeight(node.left) - getHeight(node.right);
    	}
    
    	/**
    	 * 查看AVL平衡二叉树是否是二分搜索树
    	 *
    	 * @param
    	 * @return boolean
    	 * @author whx
    	 * @version 2018/9/1
    	 */
    	private boolean isBinarySearchTree(){
        
    		ArrayList<K> keys = new ArrayList<>();
    		inOrder(root,keys);
    		for (int i = 1; i < keys.size(); i++) {
        
    			if(keys.get(i - 1).compareTo(keys.get(i)) > 0){
        
    				return false;
    			}
    		}
    		return true;
    	}
    
    	/**
    	 * 查看AVL平衡二叉树是否是平衡二叉树
    	 *
    	 * @return boolean
    	 * @author whx
    	 * @version 2018/9/1
    	 */
    	private boolean isBalanced(){
        
    		return isBalanced(root);
    	}
    
    	/**
    	 * 递归查看以node为根节点的AVL平衡二叉树是否是平衡二叉树
    	 *
    	 * @param node
    	 * @return boolean
    	 * @author whx
    	 * @version 2018/9/1
    	 */
    	private boolean isBalanced(Node node){
        
    		if (node == null) {
        
    			return true;
    		}
    		int balanceFactor = getBalanceFactor(node);
    		if(Math.abs(balanceFactor) > 1){
        
    			return false;
    		}
    		return isBalanced(node.left) && isBalanced(node.right);
    	}
    
    	// 对节点y进行向右旋转操作，返回旋转后新的根节点x
    	//        y                              x
    	//       / \                           /   \
    	//      x   T4     向右旋转 (y)        z     y
    	//     / \       - - - - - - - ->    / \   / \
    	//    z   T3                       T1  T2 T3 T4
    	//   / \
    	// T1   T2
    	/**
    	 * 右旋转操作
    	 * @param y
    	 * @return AVLTree<K,V>.Node
    	 * @author whx
    	 * @version 2018/9/1
    	 */
    	private Node rightRotate(Node y){
        
    		Node x = y.left;
    		Node T3 = x.right;
    
    		//右旋转操作
    		x.right = y;
    		y.left = T3;
    
    		//更新height
    		y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
    		x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;
    		return x;
    	}
    
    	// 对节点y进行向左旋转操作，返回旋转后新的根节点x
    	//    y                             x
    	//  /  \                          /   \
    	// T1   x      向左旋转 (y)       y     z
    	//     / \   - - - - - - - ->   / \   / \
    	//   T2  z                     T1 T2 T3 T4
    	//      / \
    	//     T3 T4
    	/**
    	 * 左旋转操作
    	 *
    	 * @param y
    	 * @return AVLTree<K,V>.Node
    	 * @author whx
    	 * @version 2018/9/1
    	 */
    	private Node leftRotate(Node y){
        
    		Node x = y.right;
    		Node T2 = x.left;
    
    		//左旋转操作
    		x.left = y;
    		y.right = T2;
    
    		//更新height
    		y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
    		x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;
    		return x;
    	}
    
    	/**
    	 * 中序遍历以node为根节点的AVL平衡二叉树
    	 * 深度优先遍历，递归实现
    	 *
    	 * @param node
    	 * @return void
    	 * @author whx
    	 * @version 2018/8/18
    	 */
    	private void inOrder(Node node, ArrayList<K> keys){
        
    		if(node == null){
        
    			return;
    		}
    		inOrder(node.left,keys);
    		keys.add(node.key);
    		inOrder(node.right,keys);
    	}
    
    	/**
    	 * 向AVL平衡二叉树中插入元素
    	 *
    	 * @param key
    	 * @param value
    	 * @return void
    	 * @author whx
    	 * @version 2018/9/1
    	 */
    	public void add(K key, V value) {
        
    		root = add(root,key,value);
    	}
    
    	/**
    	 * 向node为根元素的AVL平衡二叉树中插入元素
    	 * 递归算法
    	 *
    	 * @param node
    	 * @param key
    	 * @param value
    	 * @return void
    	 * @author whx
    	 * @version 2018/8/19
    	 */
    	private Node add(Node node, K key, V value){
        
    		//递归终止条件，返回结果为null
    		if(node == null){
        
    			size ++;
    			return new Node(key,value);
    		}
    
    		if(key.compareTo(node.key) < 0){
        
    			node.left = add(node.left,key,value);
    		}else if(key.compareTo(node.key) > 0){
        
    			node.right = add(node.right,key,value);
    		}else {
        
    			node.value = value;
    		}
    
    		/**========== 维护平衡 Start ==========*/
    		//更新Height
    		node.height = 1 + Math.max(getHeight(node.left), getHeight(node.right));
    		//计算平衡因子
    		int balanceFactor = getBalanceFactor(node);
    		//LL左孩子节点的左侧产生不平衡
    		if(balanceFactor > 1 && getBalanceFactor(node.left) >= 0){
        
    			//右旋转操作
    			return rightRotate(node);
    		}
    		//RR右孩子节点的右侧产生不平衡
    		if (balanceFactor < -1 && getBalanceFactor(node.right) <= 0){
        
    			//左旋转操作
    			return leftRotate(node);
    		}
    		//LR左孩子节点的右侧产生不平衡
    		if(balanceFactor > 1 && getBalanceFactor(node.left) < 0){
        
    			node.left = leftRotate(node.left);
    			//右旋转操作
    			return rightRotate(node);
    		}
    		//RL右孩子节点的左侧产生不平衡
    		if(balanceFactor <-1 && getBalanceFactor(node.right) > 0){
        
    			node.right = rightRotate(node.right);
    			//右旋转操作
    			return leftRotate(node);
    		}
    		/**========== 维护平衡 End ==========*/
    		return node;
    	}
    
    	/**
    	 * 查找AVL平衡二叉树的最小值
    	 *
    	 * @param
    	 * @return V
    	 * @author whx
    	 * @version 2018/8/18
    	 */
    	public V minimum(){
        
    		if(isEmpty()){
        
    			throw new IllegalArgumentException("BinarySearchTree is empty !");
    		}
    		return minimum(root).value;
    	}
    
    	/**
    	 * 查找以node为根节点AVL平衡二叉树的最小节点
    	 * 深度优先遍历，递归实现
    	 *
    	 * @param node
    	 * @return BinarySearchTree<E>.Node
    	 * @author whx
    	 * @version 2018/8/18
    	 */
    	private Node minimum(Node node) {
        
    		if(isEmpty()){
        
    			throw new IllegalArgumentException("BinarySearchTree is empty !");
    		}
    		if(node.left == null){
        
    			return node;
    		}
    		return minimum(node.left);
    	}
    
    	/**
    	 * 查找AVL平衡二叉树的最大值
    	 *
    	 * @param
    	 * @return V
    	 * @author whx
    	 * @version 2018/8/18
    	 */
    	public V maximize(){
        
    		if(isEmpty()){
        
    			throw new IllegalArgumentException("BinarySearchTree is empty !");
    		}
    		return maximize(root).value;
    	}
    
    	/**
    	 * 查找以node为根节点AVL平衡二叉树的最大节点
    	 * 深度优先遍历，递归实现
    	 *
    	 * @param node
    	 * @return BinarySearchTree<E>.Node
    	 * @author whx
    	 * @version 2018/8/18
    	 */
    	private Node maximize(Node node) {
        
    		if(isEmpty()){
        
    			throw new IllegalArgumentException("BinarySearchTree is empty !");
    		}
    		if(node.right == null){
        
    			return node;
    		}
    		return minimum(node.right);
    	}
    
    	/**
    	 * 删除AVL平衡二叉树的最大值
    	 *
    	 * @param
    	 * @return V
    	 * @author whx
    	 * @version 2018/8/18
    	 */
    	public V removeMax(){
        
    		V maximize = maximize();
    		removeMax(root);
    		return maximize;
    	}
    
    	/**
    	 * 删除以node为根的AVL平衡二叉树的最大节点
    	 * 深度优先遍历，递归实现
    	 *
    	 * @param node
    	 * @return BinarySearchTree<E>.Node
    	 * @author whx
    	 * @version 2018/8/18
    	 */
    	private Node removeMax(Node node){
        
    		if(node.right == null){
        
    			Node leftNode = node.left;
    			node.left = null;
    			size --;
    			return leftNode;
    		}
    		node.right = removeMin(node.right);
    		return node;
    	}
    
    	/**
    	 * 删除AVL平衡二叉树的最小值
    	 *
    	 * @param
    	 * @return BinarySearchTree<E>.Node
    	 * @author whx
    	 * @version 2018/8/18
    	 */
    	public V removeMin(){
        
    		V minimum = minimum();
    		removeMin(root);
    		return minimum;
    	}
    
    	/**
    	 * 删除以node为根的AVL平衡二叉树的最小节点
    	 * 深度优先遍历，递归实现
    	 *
    	 * @param node
    	 * @return BinarySearchTree<E>.Node
    	 * @author whx
    	 * @version 2018/8/18
    	 */
    	private Node removeMin(Node node){
        
    		if(node.left == null){
        
    			Node rightNode = node.right;
    			node.right = null;
    			size --;
    			return rightNode;
    		}
    		node.left = removeMin(node.left);
    		return node;
    	}
    
    	public V remove(K key) {
        
    		Node node = getNode(root,key);
    		if(node != null){
        
    			root = remove(root, key);
    			return node.value;
    		}
    		return null;
    	}
    
    	/**
    	 * 删除以node为根的AVL平衡二叉树中的指定元素
    	 * 深度优先遍历，递归实现
    	 *
    	 * @param node
    	 * @param key
    	 * @return BinarySearchTree<E>.Node
    	 * @author whx
    	 * @version 2018/8/18
    	 */
    	private Node remove(Node node, K key) {
        
    		if(node == null){
        
    			return null;
    		}
    
    		Node resultNode;
    
    		if(key.compareTo(node.key) < 0){
        
    			node.left = remove(node.left, key);
    			resultNode = node;
    		}else if(key.compareTo(node.key) > 0){
        
    			node.right = remove(node.right, key);
    			resultNode = node;
    		}else /*if(key.compareTo(node.key) == 0)*/{
        
    			// 删除右子树为空的情况
    			if(node.right == null){
        
    				Node leftNode = node.left;
    				node.left = null;
    				size --;
    				resultNode = leftNode;
    			}
    			// 删除左子树为空的情况
    			else if(node.left == null){
        
    				Node rightNode = node.right;
    				node.right = null;
    				size --;
    				resultNode = rightNode;
    			}
    			// 删除左子树、右子树均不为空的情况
    			else {
        
    				// 1、删除后用后继节点替代该位置(后继节点即待删除节点右子树中的最小节点)
    				// 获得后继节点
    				Node successor = minimum(node.right);
    				// 删除后继节点，并让待删除节点的右子树成为后继节点的右子树
    				successor.right = remove(node.right,successor.key);
    				// 让待删除节点的左子树成为后继节点的左子树
    				successor.left = node.left;
    				// 将待删除节点的左、右子节点置为空
    				node.left = node.right = null;
    				resultNode = successor;
    				/**
    				 // 2、删除后用前驱节点替代该位置(前驱节点即待删除节点左子树中的最大节点)
    				 // 获得前驱节点
    				 Node predecessor = maximize(node.left);
    				 // 删除前驱节点，并让待删除节点的左子树成为前驱节点的左子树
    				 predecessor.left = removeMax(node);
    				 // 让待删除节点的右子树成为前驱节点的右子树
    				 predecessor.right = node.right;
    				 // 将待删除节点的左、右子节点置为空
    				 node.left = node.right = null;
    				 return predecessor;
    				 */
    			}
    		}
    
    		/**========== 维护平衡 Start ==========*/
    		if(resultNode == null){
        
    			return null;
    		}
    
    		//更新Height
    		resultNode.height = 1 + Math.max(getHeight(resultNode.left), getHeight(resultNode.right));
    		//计算平衡因子
    		int balanceFactor = getBalanceFactor(resultNode);
    		//LL左孩子节点的左侧产生不平衡
    		if(balanceFactor > 1 && getBalanceFactor(resultNode.left) >= 0){
        
    			//右旋转操作
    			return rightRotate(resultNode);
    		}
    		//RR右孩子节点的右侧产生不平衡
    		if (balanceFactor < -1 && getBalanceFactor(resultNode.right) <= 0){
        
    			//左旋转操作
    			return leftRotate(resultNode);
    		}
    		//LR左孩子节点的右侧产生不平衡
    		if(balanceFactor > 1 && getBalanceFactor(resultNode.left) < 0){
        
    			resultNode.left = leftRotate(resultNode.left);
    			//右旋转操作
    			return rightRotate(resultNode);
    		}
    		//RL右孩子节点的左侧产生不平衡
    		if(balanceFactor <-1 && getBalanceFactor(resultNode.right) > 0){
        
    			resultNode.right = rightRotate(resultNode.right);
    			//右旋转操作
    			return leftRotate(resultNode);
    		}
    		/**========== 维护平衡 End ==========*/
    		return resultNode;
    	}
    
    	public boolean contains(K key) {
        
    		return getNode(root,key) != null;
    	}
    
    	public V get(K key) {
        
    		Node node = getNode(root, key);
    		return node != null ? node.value : null;
    	}
    
    	public void set(K key, V value) {
        
    		Node node = getNode(root, key);
    		if(node == null){
        
    			throw new IllegalArgumentException("Set failed. key is not exists!");
    		}
    		node.value = value;
    	}
    
    	public int getSize() {
        
    		return size;
    	}
    
    	public boolean isEmpty() {
        
    		return size == 0;
    	}
    
    	/**
    	 * 根据key获取Node
    	 *
    	 * @param node
    	 * @param key
    	 * @return map.LinkedListMap<K,V>.Node
    	 * @author whx
    	 * @version 2018/8/19
    	 */
    	public Node getNode(Node node,K key){
        
    		if(node == null){
        
    			return null;
    		}
    
    		if(key.compareTo(node.key) == 0){
        
    			return node;
    		}else if(key.compareTo(node.key) < 0){
        
    			return getNode(node.left,key);
    		}else{
        
    			return getNode(node.right,key);
    		}
    	}
    
    	/**
    	 * 节点类
    	 *
    	 * @author whx
    	 * @version 2018/8/18
    	 */
    	private class Node{
        
    		public K key;
    		public V value;
    		public Node left,right;
    		public int height;
    
    		public Node(K key, V value){
        
    			this.key = key;
    			this.value = value;
    			left = null;
    			right = null;
    			height = 1;
    		}
    	}
    
    	public static void main(String[] args) {
        
    		ArrayList<String> words = new ArrayList<>();
    		FileOperation.readFile("pride-and-prejudice.txt",words);
    		System.out.println("Total words: " + words.size());
    		AVLTree<String,Integer> wordsMap = new AVLTree();
    		for (String word : words) {
        
    			if(wordsMap.contains(word)){
        
    				wordsMap.set(word,wordsMap.get(word)+1);
    			}else {
        
    				wordsMap.add(word,1);
    			}
    		}
    		System.out.println("Total different words: " + wordsMap.getSize());
    		System.out.println("Frequency of PRIDE "+wordsMap.get("pride"));
    		System.out.println("Frequency of is "+wordsMap.get("is"));
    		System.out.println("Frequency of of "+wordsMap.get("of"));
    		System.out.println("isBinarySearchTree:"+wordsMap.isBinarySearchTree());
    		System.out.println("isBalanced:"+wordsMap.isBalanced());
    		for (String word : words) {
        
    			wordsMap.remove(word);
    			if(!wordsMap.isBinarySearchTree() || !wordsMap.isBalanced()){
        
    				throw new RuntimeException("Error");
    			}
    		}
    	}
    }

FileOperation.java

import java.io.BufferedInputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.Locale;
    import java.util.Scanner;
    
    // 文件相关操作
    public class FileOperation {
        
    
        // 读取文件名称为filename中的内容，并将其中包含的所有词语放进words中
        public static boolean readFile(String filename, ArrayList<String> words){
        
    
            if (filename == null || words == null){
        
                System.out.println("filename is null or words is null");
                return false;
            }
    
            // 文件读取
            Scanner scanner;
    
            try {
        
                File file = new File(filename);
                if(file.exists()){
        
                    FileInputStream fis = new FileInputStream(file);
                    scanner = new Scanner(new BufferedInputStream(fis), "UTF-8");
                    scanner.useLocale(Locale.ENGLISH);
                }
                else
                    return false;
            }
            catch(IOException ioe){
        
                System.out.println("Cannot open " + filename);
                return false;
            }
    
            // 简单分词
            // 这个分词方式相对简陋, 没有考虑很多文本处理中的特殊问题
            // 在这里只做demo展示用
            if (scanner.hasNextLine()) {
        
    
                String contents = scanner.useDelimiter("\\A").next();
    
                int start = firstCharacterIndex(contents, 0);
                for (int i = start + 1; i <= contents.length(); ){
        
                    if (i == contents.length() || !Character.isLetter(contents.charAt(i))) {
        
                        String word = contents.substring(start, i).toLowerCase();
                        words.add(word);
                        start = firstCharacterIndex(contents, i);
                        i = start + 1;
                    } else{
        
                        i++;
                    }
                }
            }
    
            return true;
        }
    
        // 寻找字符串s中，从start的位置开始的第一个字母字符的位置
        private static int firstCharacterIndex(String s, int start){
        
    
            for( int i = start ; i < s.length() ; i ++ ){
        
                if( Character.isLetter(s.charAt(i)) ){
        
                    return i;
                }
            }
            return s.length();
        }
    }

Main.java

import java.util.ArrayList;
    
    /**
     * @author whx
     * @version 2018/9/1
     */
    public class Main {
        
    	public static void main(String[] args) {
        
    		ArrayList<String> words = new ArrayList<>();
    		FileOperation.readFile("pride-and-prejudice.txt",words);
    		System.out.println("Total words: " + words.size());
    		AVLTree<String,Integer> wordsMap = new AVLTree();
    		for (String word : words) {
        
    			if(wordsMap.contains(word)){
        
    				wordsMap.set(word,wordsMap.get(word)+1);
    			}else {
        
    				wordsMap.add(word,1);
    			}
    		}
    		System.out.println("Total different words: " + wordsMap.getSize());
    		System.out.println("Frequency of PRIDE "+wordsMap.get("pride"));
    		System.out.println("Frequency of is "+wordsMap.get("is"));
    	}
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/2021051211030649.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20210512111941728.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20210512110456333.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE=,size_16,color_FFFFFF,t_70#pic_center
[20210512121513379.gif_pic_center]: https://img-blog.csdnimg.cn/20210512121513379.gif#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20210512114921865.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE=,size_16,color_FFFFFF,t_70#pic_center
[20210512121706129.gif_pic_center]: https://img-blog.csdnimg.cn/20210512121706129.gif#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE_size_16_color_FFFFFF_t_70_pic_center 4]: https://img-blog.csdnimg.cn/20210512121111177.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMyNTA4NjE=,size_16,color_FFFFFF,t_70#pic_center