C#链表学习与使用

//主要方法是getLength方法
 
import java.util.Scanner;
 
public class 单链表 {
    public static void main(String[] args) {
        Node a = new Node(1);
        Node a1 = new Node(88);
        Node a2 = new Node(66);
        Node a3 = new Node(68);
        LinkedList l = new LinkedList();
        l.add(a);
        l.add(a1);
        l.add(a2);
        l.add(a3);
        l.show();
        l.find(88);
        //l.update(88);
        l.show();
        System.out.println("============");
        LinkedList l1 = new LinkedList();
        l1.addByOrder(a);
        l1.addByOrder(a1);
        l1.addByOrder(a2);
        l1.addByOrder(a3);
        l1.show();
        l1.find(88);
        l1.getLength();
    }
}
 
class LinkedList {
    private Node head = new Node(0);
 
    public LinkedList() {
 
    }
 
    //增加操作
    public void add(Node node) {
        Node temp = head;
        while (temp.next != null) {
            temp = temp.next;
        }
        temp.next = node;
    }
 
    //删除操作
    public void del(int value) {
        Node temp = head.next;
        Node temp1 = null;
        //当temp.getValue()
        while (temp.getValue() != value) {
            temp1 = temp;
            temp = temp.next;
            if (temp == null) {
                System.out.println("没有找到");
                break;
            }
        }
        temp1.next = temp.next;
    }
 
    //查找操作
    public void find(int value) {
        Node temp = head.next;
        //当temp.getValue()
        while (temp.getValue() != value) {
            temp = temp.next;
            if (temp == null) {
                System.out.println("没有找到");
                return;
            }
        }
        System.out.println("找到了" + temp.getValue());
    }
 
    //修改操作
    public void update(int value) {
        Node temp = head.next;
        //当temp.getValue()
        while (temp.getValue() != value) {
            temp = temp.next;
            if (temp == null) {
                System.out.println("没有找到");
                return;
            }
        }
        System.out.println("找到了" + temp.getValue());
        Scanner sc = new Scanner(System.in);
        System.out.println("输入你要修改的值为：");
        int gai = sc.nextInt();
        temp.setValue(gai);
        System.out.println("修改完成");
    }
 
    //显示队列
    public void show() {
        Node temp = head;//这里可以是头节点赋值， 也可以是头节点的next赋值
        if (temp.next == null) {
            System.out.println("队列空~~~");
            return;
        }
        while (temp.next != null) {//下一个结点不为null
            System.out.println(temp.next);
            temp = temp.next;
        }
    }
 
    //顺序添加
    public void addByOrder(Node node) {
        Node temp = head;
        boolean flag = false; //表示是否找到该节点
        while (true) {
            if (temp.next == null) {//遍历完
                break;
            }
            if (temp.next.getValue() > node.getValue()) {
                break;
            } else if (temp.next.getValue() == node.getValue()) {
                flag = true;//value值已经存在
                break;
            }
            temp = temp.next;//后移
        }
        //根据flag判断是否找到要修改的节点
        if (flag) {//不能添加，说明编号存在
            System.out.printf("准备插入的英雄的编号%d 已经存在，不能加入\n", node.getValue());
        } else {
            //插入到了链表中， temp的后面
            node.next = temp.next;
            temp.next = node;
        }
    }
    //获取链表长度
    public void getLength() {
        Node temp = head.next;
        int length = 0;
        while (temp != null) {
            length++;
            temp = temp.next;
        }
        System.out.println("链表长度为 = " + length);
    }
}
 
class Node {
    private int value;
    public Node next;
 
    public Node() {
    }
 
    public Node(int value) {
        this.value = value;
    }
 
    @Override
    public String toString() {
        return "Node{" +
                "value=" + value +
                '}';
    }
 
    public int getValue() {
        return value;
    }
 
    public void setValue(int value) {
        this.value = value;
    }
}

一:链表简介

顾名思义就是链式结构,把一组内存不连续的数据(当然也可以连续),通过指针串联起来,链表中存储的数据被称为数据域,指针域也可以叫做链,是指储存下一个节点的内存地址

二:图解链表

1.单链表:单链表的Next指向下一个节点的引用地址,尾节点的Next为空

2.双链表:与单链表不同的是,Node节点类中会有Next与Previous两个引用储存

3.环形链表:特点是尾节点的下一个几点会指向头结点(看似循环,实则还是可以有头节点与尾节点的)

4.链表的增删改查(以单链表示意)

    增加

    增加头结点:需要把新的节点的Next指向头结点,然后把这个新节点赋值给头结点

    增加尾节点:把尾节点的Next指向新节点

    增加中间节点:需要确定插入的节点下标(插入到哪里),这个时候需要把新节点的Next指向下标节点下一个的引用,把插入                                        下标上一个节点的引用指向新增节点

删除

    删除头结点:把头结点改为头结点的下一个节点

    删除尾节点:需遍历链表,找到尾节点的上一个节点,把尾节点赋值

    删除中间节点:需把需要删除的节点的Next指针指向删除节点的Next

![**

    修改:这里的修改是指修改数据域的数据,这里就没有图了,只需要找到该节点,然后修改数据域即可

    查找:链表的查找需要从头结点一节一节往下遍历frist.Next.Next.....

1.链表常用方法
2.定义接口预制功能清单ISingleLinkedListFunction

interface ISingleLinkedListFunction<T>
    {
        /// <summary>
        /// 第一个节点
        /// </summary>
        SingleLinkedListNode<T> First { get; }
 
        /// <summary>
        /// 最后一个节点
        /// </summary>
        SingleLinkedListNode<T> Last { get; }
 
        /// <summary>
        /// 链表数量
        /// </summary>
        int Count { get; }
 
        /// <summary>
        /// 链表是否为空
        /// </summary>
        bool IsEmpty { get; }
 
        /// <summary>
        /// 清空链表
        /// </summary>
        void Clear();
 
        /// <summary>
        /// 链表中是否包含该数据
        /// </summary>
        /// <param name="value">验证数据项</param>
        /// <returns></returns>
        bool Contains(T value);
 
        /// <summary>
        /// 添加一个节点到节点起点
        /// </summary>
        /// <param name="value">节点数据</param>
        /// <returns>返回Node节点</returns>
        SingleLinkedListNode<T> AddFirst(T value);
 
        /// <summary>
        /// 添加一个节点到节点起点
        /// </summary>
        /// <param name="node">需要添加的节点</param>
        /// <returns>添加的并不是参数节点,而是参数数据,返回添加的节点</returns>
        SingleLinkedListNode<T> AddFirst(SingleLinkedListNode<T> node);
 
        /// <summary>
        /// 添加一个节点到链表最后
        /// </summary>
        /// <param name="value">节点数据</param>
        /// <returns>节点</returns>
        SingleLinkedListNode<T> AddLast(T value);
 
        ///<summary>
        /// 添加一个节点到链表最后
        /// </summary>
        /// <param name="node">需要添加的节点</param>
        /// <returns>添加的并不是参数节点,而是参数数据,返回添加的节点</returns>
        SingleLinkedListNode<T> AddLast(SingleLinkedListNode<T> node);
 
        /// <summary>
        /// 插入一个节点到指定的下标出
        /// </summary>
        /// <param name="value">节点数据</param>
        /// <param name="index">插入下标</param>
        /// <returns>新增节点</returns>
        SingleLinkedListNode<T> Insert(T value, int index);
 
        /// <summary>
        /// 插入一个节点到指定的下标出
        /// </summary>
        /// <param name="node">节点</param>
        /// <param name="index">插入下标</param>
        /// <returns>添加的并不是参数节点,而是参数数据,返回添加的节点</returns>
        SingleLinkedListNode<T> Insert(SingleLinkedListNode<T> node, int index);
 
        /// <summary>
        /// 删除节点
        /// </summary>
        /// <param name="value">数据</param>
        /// <returns>是否删除成功</returns>
        bool Delete(T value);
 
        /// <summary>
        /// 删除节点
        /// </summary>
        /// <param name="index">删除的节点下标</param>
        /// <returns>是否删除成功</returns>
        bool DeleteAt(int index);
 
        /// <summary>
        /// 删除节点
        /// </summary>
        /// <param name="index">删除的节点</param>
        /// <returns>是否删除成功</returns>
        bool Delete(SingleLinkedListNode<T> node);
 
        /// <summary>
        /// 删除第一个节点
        /// </summary>
        /// <returns>是否删除成功</returns>
        bool DeleteFirst();
 
        /// <summary>
        /// 删除最后一个节点
        /// </summary>
        /// <returns>是否删除成功</returns>
        bool DeleteLast();
 
        /// <summary>
        /// 根据数据查找节点
        /// </summary>
        /// <param name="value">数据</param>
        /// <returns>节点</returns>
        SingleLinkedListNode<T> Find(T value);
 
        /// <summary>
        /// 根据数据查找上一个节点
        /// </summary>
        /// <param name="value">数据</param>
        /// <returns>节点</returns>
        SingleLinkedListNode<T> FindPrevious(T value);
 
        /// <summary>
        /// 索引器取数据
        /// </summary>
        /// <param name="index">下标</param>
        /// <returns></returns>
        T this[int index] { get; }
 
        /// <summary>
        /// 根据下标取数据
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        T GetElement(int index);
 
        /// <summary>
        /// 根据数据获取下标
        /// </summary>
        /// <param name="value">数据</param>
        /// <returns>数据节点下标</returns>
        int IndexOf(T value);

}

3.定义节点类SingleLinkedListNode

class SingleLinkedListNode<T>
    {
        public T Value { get; set; }
        public SingleLinkedListNode<T> Next { get; set; }
        public SingleLinkedListNode()
        {
            Value = default(T);
            Next = null;
        }
    }

4.定义链表类SingleLinkedList,实现功能清单

 class SingleLinkedList<T> : ISingleLinkedListFunction<T>
    {
        private SingleLinkedListNode<T> first = null;
        /// <summary>
        /// 头结点
        /// </summary>
        public SingleLinkedListNode<T> First
        {
            get
            {
                return first;
            }
        }
 
        private SingleLinkedListNode<T> last = null;
        /// <summary>
        /// 尾节点
        /// </summary>
        public SingleLinkedListNode<T> Last
        {
            get
            {
                return last;
            }
        }
 
        private int count;
        /// <summary>
        /// 链表节点数量
        /// </summary>
        public int Count
        {
            get
            {
                count = GetCount();
                return count;
            }
        }
 
        private bool isEmpty;
        /// <summary>
        /// 链表是否为空
        /// </summary>
        public bool IsEmpty
        {
            get
            {
                isEmpty = GetIsEmpty();
                return isEmpty;
            }
        }
 
        /// <summary>
        /// 索引器
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public T this[int index]
        {
            get
            {
                if (index >= Count || index < 0)
                {
                    return default(T);
                }
                SingleLinkedListNode<T> tempNode = first;
                for (int i = 0; i < index; i++)
                {
                    tempNode = tempNode.Next;
                }
                return tempNode.Value;
            }
        }
 
        /// <summary>
        /// 添加数据到链表首节点
        /// </summary>
        /// <param name="value">数据</param>
        /// <returns>Node节点</returns>
        public SingleLinkedListNode<T> AddFirst(T value)
        {
            SingleLinkedListNode<T> tempNode = new SingleLinkedListNode<T>();
            tempNode.Value = value;
            if (first == null)
            {
                first = tempNode;
                last = tempNode;
            }
            else
            {
                tempNode.Next = first;
                first = tempNode;
            }
            return tempNode;
        }
 
        /// <summary>
        /// 添加节点到首节点(此时储存的并不是传递过来的数据地址,而是新建节点,赋值传过来节点的数据)
        /// </summary>
        /// <param name="node">数据节点</param>
        /// <returns>真正添加的节点</returns>
        public SingleLinkedListNode<T> AddFirst(SingleLinkedListNode<T> node)
        {
            SingleLinkedListNode<T> tempNode = CopyToFrom(node);
            tempNode.Next = null;
            if (first == null)
            {
                first = tempNode;
                last = tempNode;
            }
            else
            {
                tempNode.Next = first;
                first = tempNode;
            }
            return tempNode;
        }
 
        /// <summary>
        /// 添加数据到尾节点
        /// </summary>
        /// <param name="value">数据</param>
        /// <returns>Node节点</returns>
        public SingleLinkedListNode<T> AddLast(T value)
        {
            SingleLinkedListNode<T> tempNode = new SingleLinkedListNode<T>();
            tempNode.Value = value;
            if (first == null)
            {
                first = tempNode;
                last = tempNode;
            }
            else
            {
                last.Next = tempNode;
                last = tempNode;
            }
            return tempNode;
        }
 
        /// <summary>
        /// 添加尾节点(此时储存的并不是传递过来的数据地址,而是新建节点,赋值传过来节点的数据)
        /// </summary>
        /// <param name="node">数据节点</param>
        /// <returns>返回真正添加的节点</returns>
        public SingleLinkedListNode<T> AddLast(SingleLinkedListNode<T> node)
        {
            SingleLinkedListNode<T> tempNode = CopyToFrom(node);
            tempNode.Next = null;
            if (first == null)
            {
                first = tempNode;
                last = tempNode;
            }
            else
            {
                last.Next = tempNode;
                last = tempNode;
            }
            return tempNode;
        }
 
        /// <summary>
        /// 清空链表
        /// </summary>
        public void Clear()
        {
            first = null;
            last = null;
        }
 
        /// <summary>
        /// 判断链表中是否有该数据
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool Contains(T value)
        {
            if (first == null)
            {
                return false;
            }
            SingleLinkedListNode<T> tempNode = first;
            if (tempNode.Value.Equals(value))
            {
                return true;
            }
            while (true)
            {
                if (tempNode.Next != null)
                {
                    if (tempNode.Value.Equals(value))
                    {
                        return true;
                    }
                    tempNode = tempNode.Next;
 
                }
                else
                {
                    break;
                }
            }
            return false;
        }
 
        /// <summary>
        /// 删除第一个数据T的节点
        /// </summary>
        /// <param name="value"></param>
        /// <returns>是否删除成功</returns>
        public bool Delete(T value)
        {
            if (Contains(value))
            {
                SingleLinkedListNode<T> tempNode = first;
                if (tempNode.Value.Equals(value))
                {
                    first = first.Next;
                    return true;
                }
                SingleLinkedListNode<T> tempPrevious = null;
                while (true)
                {
                    if (tempNode.Next != null)
                    {
                        tempPrevious = tempNode;
                        tempNode = tempNode.Next;
                        if (tempNode.Value.Equals(value))
                        {
                            tempPrevious.Next = tempNode.Next;
                            return true;
                        }
                    }
                    else
                    {
                        break;
                    }
                }
            }
            return false;
        }
 
        /// <summary>
        /// 删除下标节点
        /// </summary>
        /// <param name="index">下标</param>
        /// <returns>是否删除成功</returns>
        public bool DeleteAt(int index)
        {
            if (index >= Count)
            {
                return false;
            }
            else
            {
                if (index == 0)
                {
                    first = first.Next;
                    return true;
                }
                else
                {
                    SingleLinkedListNode<T> tempNode = first;
                    //拿到需要删除节点的上一个节点
                    for (int i = 0; i < index - 1; i++)
                    {
                        tempNode = tempNode.Next;
                    }
                    tempNode.Next = tempNode.Next.Next;
                    return true;
                }
            }
        }
 
        /// <summary>
        /// 删除节点
        /// </summary>
        /// <param name="node">删除的节点</param>
        /// <returns>是否删除成功</returns>
        public bool Delete(SingleLinkedListNode<T> node)
        {
            if (first == null)
            {
                return false;
            }
            else
            {
                SingleLinkedListNode<T> tempNode = first;
                if (tempNode.Equals(node))
                {
                    first = first.Next;
                    return true;
                }
                SingleLinkedListNode<T> tempPrevious = null;
                while (true)
                {
                    if (tempNode.Next != null)
                    {
                        tempPrevious = tempNode;
                        tempNode = tempNode.Next;
                        if (tempNode.Equals(node))
                        {
                            tempPrevious.Next = tempNode.Next;
                            return true;
                        }
                    }
                    else
                    {
                        break;
                    }
                }
                return false;
            }
        }
 
        /// <summary>
        /// 删除头节点
        /// </summary>
        /// <returns></returns>
        public bool DeleteFirst()
        {
            if (first == null)
            {
                return false;
            }
            else
            {
                first = first.Next;
                return true;
            }
 
        }
 
        /// <summary>
        /// 删除尾节点
        /// </summary>
        /// <returns></returns>
        public bool DeleteLast()
        {
            if (first == null)
            {
                return false;
            }
            else
            {
                if (first == last)
                {
                    last = null;
                    first = null;
                }
                else
                {
                    //获取last的上一个节点
                    SingleLinkedListNode<T> tempNode = first;
                    SingleLinkedListNode<T> tempPrevious = null;
                    while (true)
                    {
                        if (tempNode.Next != null)
                        {
                            tempPrevious = tempNode;
                            tempNode = tempNode.Next;
 
                        }
                        else
                        {
                            tempPrevious.Next = null;
                            last = tempPrevious;
                            break;
                        }
                    }
                }
                return true;
            }
        }
 
        /// <summary>
        /// 查找数据所属节点
        /// </summary>
        /// <param name="value">数据</param>
        /// <returns></returns>
        public SingleLinkedListNode<T> Find(T value)
        {
            if (Contains(value))
            {
                SingleLinkedListNode<T> tempNode = first;
                if (tempNode.Value.Equals(value))
                {
                    return first;
                }
                while (true)
                {
                    if (tempNode.Next != null)
                    {
                        if (tempNode.Value.Equals(value))
                        {
                            return tempNode;
                        }
                        tempNode = tempNode.Next;
                    }
                    else
                    {
                        break;
                    }
                }
            }
            return null;
        }
 
        /// <summary>
        /// 查找数据上一个节点
        /// </summary>
        /// <param name="value">数据</param>
        /// <returns></returns>
        public SingleLinkedListNode<T> FindPrevious(T value)
        {
            if (first == null)
            {
                return null;
            }
 
            SingleLinkedListNode<T> tempNode = first;
            if (tempNode.Value.Equals(value))
            {
                return null;
            }
 
 
            SingleLinkedListNode<T> tempPrevious = null;
            while (true)
            {
                if (tempNode.Next != null)
                {
 
                    tempPrevious = tempNode;
                    tempNode = tempNode.Next;
                    if (tempNode.Value.Equals(value))
                    {
                        return tempPrevious;
                    }
                }
                else
                {
                    break;
                }
            }
            return null;
        }
 
        /// <summary>
        /// 获取下标的数据域
        /// </summary>
        /// <param name="index">下标</param>
        /// <returns>数据</returns>
        public T GetElement(int index)
        {
            if (index >= Count)
            {
                return default(T);
            }
            else
            {
                if (index == 0)
                {
                    return first.Value;
                }
                else
                {
                    SingleLinkedListNode<T> tempNode = first;
                    //拿到需要删除节点的上一个节点
                    for (int i = 0; i < index; i++)
                    {
                        tempNode = tempNode.Next;
                    }
                    return tempNode.Value;
                }
            }
        }
 
        /// <summary>
        /// 查找数据下标
        /// </summary>
        /// <param name="value">数据</param>
        /// <returns>返回该数据第一次出现的下标</returns>
        public int IndexOf(T value)
        {
            if (Contains(value))
            {
                int tempIndex = 0;
                SingleLinkedListNode<T> tempNode = first;
                if (tempNode.Value.Equals(value))
                {
                    return tempIndex;
                }
                while (true)
                {
                    if (tempNode.Next != null)
                    {
                        if (tempNode.Value.Equals(value))
                        {
                            return tempIndex;
                        }
                        tempNode = tempNode.Next;
                        tempIndex++;
                    }
                    else
                    {
                        break;
                    }
                }
            }
            return -1;
        }
 
        /// <summary>
        /// 插入数据到Index下标处
        /// </summary>
        /// <param name="value">数据</param>
        /// <param name="index">下标</param>
        /// <returns>Node节点</returns>
        public SingleLinkedListNode<T> Insert(T value, int index)
        {
            if (index > Count || index < 0)
            {
                return null;
            }
            if (index == 0)
            {
                return AddFirst(value);
            }
            else if (index == Count)
            {
                return AddLast(value);
            }
            else
            {
                if (first == null) return null;
 
                SingleLinkedListNode<T> tempNode = first;
                for (int i = 0; i < index - 1; i++)
                {
                    tempNode = tempNode.Next;
                }
                SingleLinkedListNode<T> newNode = new SingleLinkedListNode<T>();
                newNode.Value = value;
                newNode.Next = tempNode.Next;
                tempNode.Next = newNode;
                return newNode;
            }
 
 
        }
 
        /// <summary>
        /// 插入Node节点到Index下标节点
        /// </summary>
        /// <param name="node">数据节点</param>
        /// <param name="index">下标</param>
        /// <returns>真正添加的Node节点</returns>
        public SingleLinkedListNode<T> Insert(SingleLinkedListNode<T> node, int index)
        {
            if (index > Count || index < 0)
            {
                return null;
            }
            if (index == 0)
            {
                return AddFirst(node);
            }
            else if (index == Count)
            {
                return AddLast(node);
            }
            else
            {
                if (first == null) return null;
 
                SingleLinkedListNode<T> tempNode = first;
                for (int i = 0; i < index - 1; i++)
                {
                    tempNode = tempNode.Next;
                }
                SingleLinkedListNode<T> newNode = CopyToFrom(node);
                newNode.Next = tempNode.Next;
                tempNode.Next = newNode;
                return newNode;
            }
        }
 
        /// <summary>
        /// 打印链表
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            string str = "链表信息";
            if (first == null)
            {
                Console.WriteLine("空链表");
                return str;
            }
            SingleLinkedListNode<T> tempNode = first;
            str += tempNode.Value.ToString();
            while (true)
            {
                if (tempNode.Next != null)
                {
                    tempNode = tempNode.Next;
                    str += tempNode.Value.ToString();
 
                }
                else
                {
 
                    break;
                }
            }
            Console.WriteLine(str);
            return str;
        }
 
        /// <summary>
        /// 获取链表数量
        /// </summary>
        /// <returns></returns>
        private int GetCount()
        {
            if (first == null) return 0;
 
            int tempCount = 1;
            SingleLinkedListNode<T> tempNode = first;
            while (true)
            {
                if (tempNode.Next != null)
                {
                    tempNode = tempNode.Next;
                    tempCount++;
                }
                else
                {
                    break;
                }
            }
            return tempCount;
        }
 
        /// <summary>
        /// 判断链表是否为空
        /// </summary>
        /// <returns></returns>
        private bool GetIsEmpty()
        {
            return first == null;
        }
 
        /// <summary>
        /// 为避免参数重复赋值(比如已经加了头结点,又加入了尾节点)
        /// </summary>
        /// <returns></returns>
        private SingleLinkedListNode<T> CopyToFrom(SingleLinkedListNode<T> node)
        {
            SingleLinkedListNode<T> tempNode = new SingleLinkedListNode<T>();
            tempNode.Value = node.Value;
            tempNode.Next = tempNode.Next;
            return tempNode;
        }
    }

5.使用此链表

class Program
{
    static void Main(string[] args)
    {
        SingleLinkedList<int> singleLinkedList = new SingleLinkedList<int>();
        SingleLinkedListNode<int> singleLinkedListNode = new SingleLinkedListNode<int>();
        singleLinkedListNode.Value = 6;
        //singleLinkedList.AddFirst(1);
        //singleLinkedList.AddFirst(2);
        //singleLinkedList.AddFirst(3);
        //singleLinkedList.AddFirst(4);
        //singleLinkedList.AddFirst(singleLinkedListNode);
        singleLinkedList.AddLast(1);
        singleLinkedList.AddLast(2);
        singleLinkedList.AddLast(3);
        singleLinkedList.AddLast(4);
        singleLinkedList.Insert(singleLinkedListNode, 3);
        //singleLinkedList.AddLast(4);
        //singleLinkedList.AddLast(3);
        //singleLinkedList.AddLast(2);
        //singleLinkedList.AddLast(singleLinkedListNode);
 
        Console.WriteLine("获取:" + singleLinkedList[1]);
 
        Console.WriteLine("链表数量" + singleLinkedList.Count);
        Console.WriteLine("链表是否为空" + singleLinkedList.IsEmpty);
        singleLinkedList.ToString();
        Console.ReadKey();
 
    }
}

以上只贴出了,单链表的实现,双链表只是在节点类中添加上一个节点的引用,然后在实现链表功能中赋值即可,环形链表也是一样的,只需要把尾节点的Next指向头结点即可~

好了,文章到此就结束了,本文有什么错误的观点或者用法,希望各位看官能够及时提出,希望在自己积累知识的同时,能帮助到大家~