数据结构__链表

#define ERROR_RET 0xEFEFEFEF

struct Node{
    int value;
    Node *next;
};

class LinkedList{
private:
    Node *_head;

public:

    LinkedList(){
        _head = nullptr;
    }

    ~LinkedList(){

    }

    int size() const {
        int count = 0;
        Node *tmp = _head;
        while (tmp!=nullptr) {
            count ++;
            tmp = tmp->next;
        }
        return count;
    }


    bool isEmpty() const{
        return _head == nullptr;
    }

    Node *firstNode() const {
        return _head;
    }

    Node *lastNode() const {
        if(_head == nullptr)
            return nullptr;

        Node *tmp = _head;
        while (tmp->next !=nullptr) {
            tmp = tmp->next;
        }

        return tmp;
    }

    Node *getNode(int pos) const {
        if(pos<0 || _head == nullptr)
            return nullptr;

        int i=0;
        Node *tmp = _head;
        while (tmp->next !=nullptr && i< pos) {
            tmp = tmp->next;
            i++;
        }

        return tmp;
    }

    Node *findNode(int e) const {

        Node *tmp = _head;
        while (tmp !=nullptr) {
            if(tmp->value == e)
            {
                return tmp;
            }
            tmp = tmp->next;
        }

        return nullptr;
    }

    int getValue(int pos) const {
        Node *node = getNode(pos);
        if(node!=nullptr){
            return node->value;
        }else{
            return ERROR_RET;
        }
    }

    void setValue(int pos ,int e){
        Node *node = getNode(pos);
        if(node!=nullptr){
            node->value = e;
        }
    }

    int insert(int pos,int e)
    {
        Node *newNode = new Node;
        newNode->value = e;

        if(pos<=0 || _head == nullptr){
            newNode->next = _head;
            _head = newNode;
            return 0;
        }

        int i=0;
        Node *tmp = _head;
        while (tmp->next != nullptr && i<pos-1) {
            tmp = tmp->next;
            i++;
        }

        newNode->next = tmp->next;
        tmp->next = newNode;
        return i+1;
    }

    int remove(int pos){

        if(pos<0 || _head == nullptr)
            return ERROR_RET;

        if(pos == 0){
            Node *tmp = _head;
            _head = _head->next;

            tmp->next = nullptr;

            int value = tmp->value;
            delete  tmp;
            return value;
        }

        int i=0;
        Node *tmp = _head;
        while (tmp->next != nullptr && i<pos-1) {
            tmp = tmp->next;
            i++;
        }
        if(tmp != nullptr)
        {
            Node *node = tmp->next;
            if(node == nullptr)
                return  ERROR_RET;
            else{
                tmp->next = node->next;
                int value = node->value;
                delete  node;
                return value;
            }
        }else{
            return ERROR_RET;
        }

    }

    void reverse()
    {
        if(_head==nullptr || _head->next == nullptr)
        {
            return;
        }

        Node *p = _head;
        Node *q = _head->next;

        Node *r;
        //取出第一个节点
        _head->next = nullptr;
        while( q!=nullptr)
        {
            r = q->next; //r 为第三个节点
            q->next = p;

            p = q;
            q = r;
        }

        _head = p;
    }

    void sort()
    {
        Node newHead;
        Node *tmpHead = &newHead;
        tmpHead->next = nullptr;

        while (_head != nullptr) {
            int min = _head->value;
            Node *preMinNode = nullptr;
            Node *tmpNode = _head;
            //第一轮循环找到最小的。
            while (tmpNode->next != nullptr) {
                Node *node = tmpNode->next;
                if(min>node->value){
                    preMinNode = tmpNode;
                    min = node->value;
                }
                tmpNode = node;
            }

            if(preMinNode == nullptr){
                tmpHead->next = _head;
                _head = _head->next;
            }else{
                Node *node = preMinNode->next;
                tmpHead->next = node;
                preMinNode->next = node->next;
            }

            tmpHead = tmpHead->next;
            tmpHead->next = nullptr;

        }

        _head = newHead.next;
    }

};


int main()
    {
        std::cout << "Hello World!\n";
        //LinkedList ls;
        //ls.insert(0, 5);
        //ls.insert(1, 1);
        //ls.insert(2, 4);
        //ls.insert(3, 6);
        //ls.insert(4, 2);
        //ls.sort();

        //unordered_set<int> ts;
        //ts.insert(0);
        //ts.insert(1);
        //ts.insert(5);
        //ts.insert(2);
        //ts.insert(1);
        //ts.insert(3);
}