安科网

C/C++ 数据结构与算法

Cypress

Cypress

2020-03-04

关注 关注
  • 线性表（Linear List）
    • 顺序存储结构
      • 顺序表（Sequence List）
      • 顺序栈（Sequence Stack）
      • 循环队列（Circular Queue）
    • 链式存储结构
      • 单链表（Singly Linked List）
      • 双链表（Doubly Linked List）
      • 循环链表（Circular Linked List）
      • 链栈（Linked Stack）
      • 链队列（Linked Queue）
#ifndef _H_LINEARLIST
#define _H_LINEARLIST

#include <iostream>
#include <stdexcept>
using namespace std;

// 线性表头文件（Linear List header file）
// 导入各种数据结构头文件

// 线性表的顺序存储
#include "SequenceList.h"        // 顺序表
#include "SequenceStack.h"        // 顺序栈
#include "CircularQueue.h"        // 循环队列
// 线性表的链式存储
#include "SinglyLinkedLIst.h"    // 单链表
#include "LinkedStack.h"        // 链栈
#include "LinkedQueue.h"        // 链队列

#endif

LinearList.h

#ifndef _H_SEQUENCELIST
#define _H_SEQUENCELIST

// 顺序表定义头文件（Sequence List）

namespace SequenceList 
{
    // SqList，顺序表类，成员有存储MAXSIZE个T类型数据的数组
    template <typename T, size_t MAXSIZE>
    class SqList 
    {
    private:
        T *data;
        size_t length;
        size_t size;
    public:
        // 初始化SqList
        SqList() 
        {
            this->size = MAXSIZE;
            this->data = new T[this->size]; 
            this->length = 0; 
        }
        // 析构化SqList
        ~SqList() { free(this->data); }
        // 是否为空
        bool Empty() const { return this->length == 0; }
        // 是否已满
        bool Full() const { return this->length == this->size; }
        // 返回长度
        size_t Length() const { return this->length; }
        // 返回大小
        size_t Size() { return this->size; }
        // 清除顺序表
        void Clear() 
        { 
            free(this->data); 
            this->size = MAXSIZE;
            this->data = new T[this->size]; 
            this->length = 0; 
        }
        // 获得index上的数据
        T GetElem(const size_t &index)
        {
            if (this->Empty())
            {
                throw out_of_range("SqList<T>: List is empty!\n");
            }
            else if (index <= 0 || index > this->length)
            {
                throw out_of_range("SqList<T>: Index out of range!\n");
            }
            else
            {
                return this->data[index-1];
            }
        }
        // 返回elem在SqList中的索引，如果找不到，返回0
        size_t LocateElem(const T &elem)
        {
            size_t index = 1;
            for (int i = 0; i < this->length; ++i, ++index)
            {
                if (this->data[i] == elem)
                {
                    return index;
                }
            }
            return 0;
        }
        // 在index位置上插入元素elem，所有index之后的元素向后移动一位
        void InsertElem(const size_t &index, const T &elem)
        {
            if (this->Full())
            {
                throw out_of_range("SqList<T>: List is full!\n");
            }
            else if (index <= 0 || index > this->length + 1)
            {
                throw out_of_range("SqList<T>: Index out of range!\n");
            }
            else
            {
                int i;
                for (i = this->length; i > index-1; --i)
                {
                    this->data[i] = this->data[i-1];
                }
                this->data[i] = elem;
                ++this->length;
            }
        }
        // 删除index上的元素elem，所有index之后的元素向前一位
        void DeleteElem(const size_t &index)
        {
            if (this->Empty())
            {
                throw out_of_range("SqList<T>: List is empty!\n");
            }
            else if (index <= 0 || index > this->length)
            {
                throw out_of_range("SqList<T>: Index out of range!\n");
            }
            else
            {
                for (int i = index-1; i < this->length - 1; ++i)
                {
                    this->data[i] = this->data[i+1];
                }
                --this->length;
            }
        }
        // 扩大顺序表，size += extra
        void Expand(size_t extra)
        {
            if (extra != 0)
            {
                T *tmp = this->data;
                this->data = new T[this->size + extra];
                // memcpy(destination, source, size)
                memcpy(this->data, tmp, this->length * sizeof(T));
                free(tmp);
                this->size += extra;
            }
        }
        // 打印SqList
        friend ostream &operator<<(ostream &os, const SqList &sql)
        {
            if (sql.Empty()) 
            {
                os << "SqList<T>[0]: {}" << endl;
            }
            else
            {
                os << "SqList<T>[" << sql.length << ", " << sql.size << "]: {";
                for (int i = 0; i < sql.length; ++i)
                {
                    os << sql.data[i] << ", ";
                }
                os << "\b\b}" << endl;
            }
            return os;
        }
    };
}


#endif

SequenceList.h

// SequenceStack.h
#ifndef _H_SEQUENCESTACK
#define _H_SEQUENCESTACK

// 顺序栈定义头文件（Sequence Stack）

namespace SequenceStack
{
    template <typename T, size_t MAXSIZE>
    class SqStack
    {
    private:
        T *data;            // 数组
        size_t topPtr;         // 栈顶指针
        size_t length;        // 长度
        size_t size;        // 大小
    public:
        // 初始化
        SqStack()
        {
            this->size = MAXSIZE;
            this->data = new T[this->size];
            this->length = 0;
            this->topPtr = -1;
        }
        // 析构化
        ~SqStack() { free(this->data); }
        // 是否为空
        bool Empty() const { return this->length == 0; };
        // 是否已满
        bool Full() const { return this->length == this->size; }
        // 返回长度
        size_t Length() const { return this->length; }
        // 返回大小
        size_t Size() const { return this->size; }
        // 清除顺序栈
        void Clear()
        {
            free(this->data);
            this->size = MAXSIZE;
            this->data = new T[this->size];
            this->length = 0;
            this->topPtr = -1;
        }
        // 获取栈顶指针数据
        T Top() 
        { 
            if (this->Empty())
            {
                throw out_of_range("SqStack<T>: stack is empty!\n");
            }
            else
            {
                return this->data[this->topPtr]; 
            }
        }
        // 压入栈
        void Push(const T &elem) 
        {
            if (this->Full())
            {
                throw out_of_range("SqStack<T>: stack is full!\n");
            }
            else
            {
                ++this->topPtr;
                this->data[this->topPtr] = elem;
                ++this->length;
            }
        }
        // 弹出栈
        void Pop()
        {
            if (this->Empty())
            {
                throw out_of_range("SqStack<T>: stack is empty!\n");
            }
            else
            {
                --this->topPtr;
                --this->length;
            }
        }
        // 扩大顺序栈，size += extra
        void Expand(const size_t &extra)
        {
            if (extra != 0)
            {
                T *tmp = this->data;
                this->data = new T[this->size + extra];
                // memcpy(destination, source, size)
                memcpy(this->data, tmp, this->length * sizeof(T));
                free(tmp);
                this->size += extra;
            }
        }
        // 打印栈
        friend ostream &operator<<(ostream &os, const SqStack &sq)
        {
            os << "SqStack<T>[" << sq.length << ", " << sq.size << "] {";
            if (sq.Empty())
            {
                os << "}" << endl;
            }
            else
            {
                for (int i = sq.topPtr; i >= 0; --i)
                {
                    os << sq.data[i] << ", ";
                }
                os << "\b\b}" << endl;
            }
            return os;
        }
    };    
}

#endif

SequenceStack.h

// CircularQueue.h
#ifndef _H_CIRCULARQUEUE
#define _H_CIRCULARQUEUE

// 循环队列定义头文件（Circular Queue）
namespace CircularQueue
{
    template <typename T, size_t MAXSIZE>
    class CuQueue
    {
    private:
        T *data;        // 数组
        size_t head;    // 头指针
        size_t rear;    // 尾指针
        size_t length;    // 长度
        size_t size;    // 大小
    public:
        // 构造器
        CuQueue()
        {
            this->head = 0;
            this->rear = 0;
            this->length = 0;
            this->size = MAXSIZE;
            this->data = new T[this->size];
        }
        // 析构器
        ~CuQueue() { free(this->data); }
        // 是否为空
        bool Empty() const { return this->length == 0; }
        // 是否已满
        bool Full() const { return this->size == this->length; }
        // 返回长度
        size_t Length() const { return this->length; }
        // 返回大小
        size_t Size() const { return this->size; }
        // 清除队列
        void Clear()
        {
            free(this->data);
            this->size = MAXSIZE;
            this->data = new T[this->size];
            this->length = 0;
            this->head = 0;
            this->rear = 0;
        }
        // 返回队列头元素
        T Head()
        {
            if (this->Empty())
            {
                throw out_of_range("CuQueue<T>: queue is empty!\n");
            }
            else
            {
                return this->data[this->head];
            }
        }
        // 进列
        void EnQueue(const T &elem)
        {
            if (this->Full())
            {
                throw out_of_range("CuQueue<T>: queue is full!\n");
            }
            else
            {
                // 当head和rear指向同一个位置时，队列为空
                this->data[this->rear] = elem;
                ++this->rear;
                ++this->length;
                if (this->rear == this->size)
                {
                    this->rear = 0;
                }
            }
        }
        // 出列
        void DeQueue()
        {
            if (this->Empty())
            {
                throw out_of_range("CuQueue<T>: queue is empty!\n");
            }
            else
            {
                ++this->head;
                --this->length;
                if (this->head == this->size)
                {
                    this->head = 0;
                }
            }
        }
        // 扩大循环队列，size += extra
        void Expand(const size_t &extra)
        {
            if (extra != 0)
            {
                T *tmp = this->data;
                this->data = new T[this->size + extra];
                // memcpy(destination, source, size)
                memcpy(this->data, tmp, this->length * sizeof(T));
                free(tmp);
                this->size += extra;
            }
        }
        // 打印循环队列
        friend ostream &operator<<(ostream &os, const CuQueue &cq)
        {
            os << "CuQueue<T>:[" << cq.length << ", " << cq.size << "][" << cq.head << ", " << cq.rear << "]: {";
            if (cq.Empty()) 
            {
                os << "}" << endl;
            }
            else
            {
                int index = cq.head;
                for (int i = 0; i < cq.length; ++i, ++index)
                {
                    if (index == cq.size) { index = 0; }
                    os << cq.data[index] << ", "; 
                }
                os << "\b\b}" << endl;
            }
            return os;
        }
    };
}

#endif

CircularQueue.h

#ifndef _H_SINGLYLINKEDLIST
#define _H_SINGLYLINKEDLIST

// 单链表定义头文件（Singly Linked List）

namespace SinglyLinkedList
{
    template <typename T>
    class SgNode
    {
    private:
        T elem;
        SgNode<T> *next;
    public:
        template <typename I> friend class SgList;
        T Elem() { return this->elem; }
        SgNode<T> *Next() { return this->next; }
        SgNode() {}
    };

    template <typename T>
    class SgList 
    {
    private:
        SgNode<T> *head;
        size_t length;
    public:
        // 初始化
        SgList() 
        {
            this->head = NULL;
            this->length = 0;
        }
        // 析构，删除每个节点
        ~SgList()
        {
            SgNode<T> *tmp;
            for (SgNode<T> *node = this->head; node;)
            {
                tmp = node;
                node = node->next;
                delete tmp;
            }
        }
        // 是否为空
        bool Empty() const { return this->length == 0; }
        // 长度
        size_t Length() const { return this->length; }
        // 清除单链表 
        void Clear()
        {
            SgNode<T> *tmp;
            for (SgNode<T> *node = this->head; node;)
            {
                tmp = node;
                node = node->next;
                delete tmp;
            }
            this->head = NULL;
            this->length = 0;
        }
        // 获取index上的elem
        T GetElem(const size_t &index)
        {
            if (this->Empty())
            {
                throw out_of_range("SgList<T>: List is empty!\n");
            }
            else if (index <= 0 || index > this->length)
            {
                throw out_of_range("SgList<T>: Index out of range!\n");
            }
            else
            {
                SgNode<T> *node = this->head;
                for (int i = 1; i < index; ++i)
                {
                    node = node->next;
                }
                return node->elem;
            }
        }
        // 返回elem在单链表中的索引
        size_t LocateElem(const T &elem)
        {
            size_t index = 1;
            for (SgNode<T> *node = this->head; node; node = node->next, ++index) 
            {
                if (node->elem == elem)
                {
                    return index;
                }
            }
            return 0;
        }
        // 在index位置插入elem
        void InsertElem(const size_t &index, const T &elem)
        {
            if (index <= 0 || index > this->length + 1)
            {
                throw out_of_range("SgList<T>: Index out of range!\n");
            }
            else
            {
                SgNode<T> *node = new SgNode<T>;
                node->elem = elem;
                if (index == 1)
                {
                    if (this->head == NULL)
                    {
                        node->next = NULL;
                        this->head = node;
                    }
                    else
                    {
                        node->next = this->head;
                        this->head = node;
                    }
                }
                else
                {
                    // 找到index-1上的节点
                    SgNode<T> *prior = this->head;
                    for (int i = 1; i < index - 1; ++i)
                    {
                        prior = prior->next;
                    }
                    node->next = prior->next;
                    prior->next = node;
                }
                ++this->length;
            }
        }
        // 删除index位置上的elem
        void DeleteElem(const size_t &index)
        {
            if (this->Empty())
            {
                throw out_of_range("SgList<T>: List is empty!\n");
            }
            else if (index <= 0 || index > this->length)
            {
                throw out_of_range("SgList<T>: Index out of range!\n");
            }
            else
            {
                if (index == 1)
                {
                    SgNode<T> *node = this->head;
                    this->head = this->head->next;
                    delete node;
                }
                else
                {
                    // 找到index-1上的节点
                    SgNode<T> *prior = this->head;
                    for (int i = 1; i < index-1; ++i)
                    {
                        prior = prior->next;
                    }
                    SgNode<T> *node = prior->next;
                    prior->next = prior->next->next;
                    delete node;
                }
                --this->length;
            }
        }
        // 打印SgList
        friend ostream &operator<<(ostream &os, const SgList &sg)
        {
            os << "SgList<T>[" << sg.length << "]: {";
            if (sg.Empty())
            {
                os << "NULL}" << endl;
            }
            else
            {
                for (SgNode<T> *node = sg.head; node; node = node->Next())
                {
                    os << node->Elem() << " -> ";
                }
                os << "NUll}" << endl;
            }

            return os;
        }
    };
}

#endif

SinglyLinkedList.h

#ifndef _H_LINKEDQUEUE
#define _H_LINKEDQUEUE

// 链队列的数据结构定义

namespace LinkedQueue
{
    template <typename T>
    class LiNode
    {
    private:
        T elem;
        LiNode<T> *next;
    public:
        template <typename I> friend class LiQueue;
        LiNode() {}
        T Elem() { return this->elem; }
        LiNode<T> *Next() { return this->next; }
    };

    template <typename T>
    class LiQueue
    {
    private:
        LiNode<T> *head;
        LiNode<T> *rear;
        size_t length;
    public:
        // 构造器
        LiQueue() 
        {
            this->head = NULL;
            this->rear = NULL;
            this->length = 0;
        }
        // 析构器
        ~LiQueue()
        {
            LiNode<T> *tmp;
            for (LiNode<T> *node = this->head; node;)
            {
                tmp = node;
                node = node->next;
                delete tmp;
            }
        }
        // 是否为空
        bool Empty() const { return this->length == 0; }
        // 长度
        size_t Length() const { return this->length; }
        // 清除链队列
        void Clear()
        {
            LiNode<T> *tmp;
            for (LiNode<T> *node = this->head; node;)
            {
                tmp = node;
                node = node->next;
                delete tmp;
            }
            this->head = NULL;
            this->rear = NULL;
            this->length = 0;
        }
        // 返回头部元素
        T Head()
        {
            if (this->Empty())
            {
                throw out_of_range("LiQueue<T>: queue is empty!\n");
            }
            else
            {
                return this->head->elem;
            }
        }
        // 入队
        void EnQueue(T elem)
        {
            LiNode<T> *node = new LiNode<T>;
            node->elem = elem;
            node->next = NULL;
            if (this->Empty())
            {
                
                this->head = node;
                this->rear = node;
            }
            else
            {    
                this->rear->next = node;
                this->rear = node;
            }
            ++this->length;
        }    
        // 出队 
        void DeQueue()
        {
            if (this->Empty())
            {
                throw out_of_range("LiQueue<T>: queue is empty!\n");
            }
            else
            {
                if (this->length == 1)
                {
                    delete this->head;
                    this->head = NULL;
                    this->rear = NULL;
                }
                else
                {
                    LiNode<T> *node = this->head;
                    this->head = this->head->next;
                    delete node;
                }
                --this->length;
            }
        }
        // 打印链队列
        friend ostream &operator<<(ostream &os, LiQueue &li)
        {
            os << "LiQueue<T>[" << li.length << "]: {";
            if (li.Empty()) 
            {
                os << "}" << endl;
            }
            else
            {
                for (LiNode<T> *node = li.head; node; node = node->Next())
                {
                    os << node->Elem() << ", ";
                }
                os << "\b\b}" << endl;
            }
            return os;
        }
    };
}

#endif

LinkedQueue.h

  • 算法（Algorithms）
    • 斐波那契数列（Fibonacci）
#ifndef _H_ALGORITHMS
#define _H_ALGORITHMS

// 斐波那契数列
size_t Fibonacci(size_t i)
{
    if (i < 2)
        return i == 0 ? 0 : 1;
    else
        return Fibonacci(i-1) + Fibonacci(i-2);
}

#endif

Algorithms.h

算法与数据结构 数据结构 顺序表 list include

Cypress

Cypress

0 关注 0 粉丝 0 动态

关注 关注

相关推荐

学c++需要先学c语言吗？

看需求，如果是底层开发，就必须学习C语言。如果只是应用开发，可以直接从C++开始学习。实际上这两个语言是平等的，只是在语法上C++尽量与C兼容，但仍然有很多不同的地方。1) C++不是C的超集。2) 如果你选择了一本好书，学C++之前完全没有必要学C，即使

shenwenjie 2020-09-24

盘点 Python 10 大常用数据结构（上篇）

如果你还处于Python入门阶段，通常只需掌握list、tuple、set、dict这类数据结构，做到灵活使用即可。因为相比于list, tuple实例更加节省内存，这点尤其重要。并且set内允许增删元素，且效率很高。但是值得注意，dict占用字节数是li

xiesheng 2020-08-02

java数据结构与算法一：稀疏数组

因为二维数组的很多值是默认值0，因此记录了很多没有意义的数据，可采用稀疏数组解决此问题。当一个数组中大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。稀疏数组中第一行依次存放着总行数、总列数、 不同值的个数，其他行则依次存放着值所在的行

mingyunxiaohai 2020-07-28

算法学习路线

算法学习是一条漫长而又苦涩的道路。之所以漫长，是因为有关算法的学习是无穷无尽的，如果你不想经历程序员的35岁之劫难，那就要不断地学习算法，提高自己的不可替代性。之所以是苦涩，是因为算法更像是数学题，对智力是有一定要求的，学习算法的过程中总是会质疑自己，相较

Cypress 2020-07-08

数据结构与算法参考答案（第二周）

试写一算法，将x插入到顺序表的适当位置上，以保持该表的有序性。这里我们需要满足x的值大于等于va.elem[i]且小于va.elem[i+1]。之后我们需要将顺序表的va.length - i - 1个元素后移一位。最后将表长va.length加1。算法执

xhao 2020-05-05

数据结构与算法(二) 线性表一

另外，线性表强调是有限的。例如很多编程语言的整型，浮点型，字符型这些指的就是数据类型。抽象数据类型是指一个数学模型及定义在该模型上的一组操作。抽象数据类型的定义仅仅取决于它的一组逻辑特性，而与其在计算机内部如何表示和实现无关。

Cypress 2020-06-28

数据结构与算法(一)

算法采用的策略，方案。在编写程序的时候，我们不关心语言、所用的计算机只关心它所实现的算法。在修改后的运行函数中，只保留最高项。如果最高项存在且不是1，则除这个项相乘的常数。

Dyancsdn 2020-06-27

C#数据结构与算法系列（十五）：排序算法（SortAlgorithm）

排序是将一组数据，以指定的顺序进行排序的过程

dushine00 2020-06-25

《数据结构与算法之美》09——排序（二）归并排序与快速排序

要排序一个数组，先把数组从中间分成前后两部分，然后对前后两部分分别排序，再将排好序的两部分合并在一起。归并排序使用的是分治思想。分治，就是分而治之，将一个大问题分解成小的子问题来解决。回忆一下之前学习递归的编程技巧：分析得出递推公式，然后找到终止条件。归并

Masimaro 2020-06-21

数据结构与算法知识导图

数据结构 的主要任务是通过分析数据对象的结构特征，包括逻辑结构及数据对象之间的关系，然后把逻辑结构表示成计算机课实现的物理结构，从而便于计算机处理。算法是解决特定问题求解步骤的描述，在计算机中表现为有限的操作序列。在数据类型建立起来之后，就要对这些数据类

waitwolf 2020-06-21

[Java数据结构与算法]简单排序之插入排序

大多数情况下，在三种简单排序中，插入排序都是最优的选择。虽然插入排序算法仍需要 O(N^2) 的时间，但在一般情况下，它要比冒泡排序快一倍，比选择排序还要快一点。插入排序可以简单表述为：使“标定项”的一侧局部有序，每次将标定项插入有序一侧，同时将另一侧的下

Jasmineyaoyao 2020-06-16

C#数据结构与算法（六）：链表——双链表（Double-LinkedList）

对于单向链表的删除，我们首先要找到单向链表待删除节点的前一个节点，然后前一个节点的下一个节点指向删除节点的后一个节点。//如果temp.Next为null就表示temp为最后一个节点；

OldBowl 2020-06-16

C#数据结构与算法系列（五）：常见单链表笔试

int length = 0;var cur = headNode.Next;if (cur == null) break;length++;cur = cur.Next;return length;public static HeroNode GetLa

alicelmx 2020-06-16

数据结构：第六章学习小结

第六章图的学习感觉比较侧重阅读和理解代码，而写代码部分占比比较小。所以这一章的总结全都是知识点的整理，是用自己的话来表达自己对代码以及做题过程步骤的理解。邻接表存储顶点名称，同时将顶点下标存储在一个结点内，因此当邻接矩阵调用Locate方法来得到顶点下标值

Masimaro 2020-06-14

数据结构之稀疏数组的使用场景及实现

顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的。　　链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息。　　线性结构常见的有：数组、队列、链表和栈，后面我们会详细讲解.　　编写的五子棋程序中，有存

waitwolf 2020-06-08

数据结构之递归与调用栈

递归算法是一种直接或间接调用自身算法的过程。每个递归函数都有两部分：基线 条件和递归条件。基线条件则指的是函数不再调用自己，函数的终止条件，避免形成无限循环 。所有函数调用都进入调用栈，使用递归必须理解这个概念。调用栈是的原则是先进后出，栈有两种操作：压入

nurvnurv 2020-06-05

数据结构与算法-线性表和散列表的总结

将元素映射为下标，然后将数据存储在数组中对应下标的位置，当需要对元素进行操作时，使用同样的方法将元素映射为下标，找到下标的位置，从对应数组下标的位置取数据

ustbfym 2020-06-04

前端就不需要掌握算法与数据结构？

因为开发的过程就是把实际问题转换成计算机可识别的指令，也就是《数据结构》里说的，「设计出数据结构，在施加以算法就行了」。编写指令的好坏，会直接影响到程序的性能优劣，而指令又由数据结构和算法组成，所以数据结构和算法的设计基本上决定了最终程序的好坏。另外，在阅

ziruoxiangyi 2020-06-03

前端就不需要掌握算法与数据结构？

因为开发的过程就是把实际问题转换成计算机可识别的指令，也就是《数据结构》里说的，「设计出数据结构，在施加以算法就行了」。编写指令的好坏，会直接影响到程序的性能优劣，而指令又由数据结构和算法组成，所以数据结构和算法的设计基本上决定了最终程序的好坏。另外，在阅

范范 2020-06-03

数据结构：第五章学习小结

②利用check数组，将其初始化为false，后续创建树的过程中，将孩子结点的编号作为check数组下标，若出现则变为true，以此找出根结点。

Jasmineyaoyao 2020-05-31
Cypress

Cypress

W3CSchool教程
HTML 教程
CSS 教程
Bootstrap 教程
Javascript 教程
jQuery 教程
后端教程
C 教程
Java 教程
PHP 教程
Python 教程
Go 教程
移动开发
Android 教程
Swift 教程
Kotlin 教程
jQuery Mobile 教程
ionic 教程
关于我们
新闻动态
联系方式
招聘英才
安科实验室
帮助与反馈

安科网(Ancii)，中国第一极客网

Copyright © 2013 - 2019 Ancii.com

京ICP备18063983号 京公网安备11010802014868号