第二章 链表part01

第二章 链表part01

203.移除链表元素

题目链接： https://leetcode.cn/problems/remove-linked-list-elements/

 

 

Code :

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* p = head;
        ListNode* pre;
​
        ListNode* NewHead;
​
        while(p != nullptr && p->val == val)
        {
            p = p->next;
        }
​
        NewHead = p;
        pre = p;
​
​
        while(p != nullptr)
        {
​
            //内循环
            if(p->val == val)
            {
                pre->next = p->next;
​
            }
            else
            {
                pre = p;
            }
​
            p = p->next;
        }
​
        return NewHead;
    }
};

 

 

707. 设计链表

题目链接： https://leetcode.cn/problems/design-linked-list/

 

Code

class MyLinkedList {
public:
    struct node
    {
        int val;
        node * next;
    };
​
        // 带头 结点
​
    node * head ;
​
​
    MyLinkedList() {
        head = new node() ;
​
        head->val = 0; 
        head->next = NULL;
​
    }
    
    int get(int index) {
        int i = 0;
​
        //cout<<"------------get--------------------"<<endl;
​
        int step = index + 1;
​
        int count = 0;
​
        node * p;
​
        p = head->next;
​
        //cout<<"index : "<<index<<endl;
​
        
        //cout<<"step : "<<step<<endl;
​
        //cout<<"head->val : "<<head->val<<endl;
        
​
        if(step > head->val)
        {
            return -1;
        }
​
        if(step == 1)
        {
            return p->val;
        }
​
        
​
        count++;
​
​
        for( ; i < (step - 1) ; i++ )
        {
            if(p == NULL)
            {
                break;
            }
            p = p->next;
            
            count++;
        }
​
        //cout<<"------count : "<<count<<endl;
        
​
        if(count < (step))
        {
            return -1;
        }else
        if(count == step)
        {
            return p->val;
        }
        else
        {
            cout<<"step 溢出"<<endl;
            return -1;
        }
​
        //cout<<"-----------------------------------"<<endl;
​
    }
    
    void addAtHead(int val) {
        node * temp = new node() ;
        temp->val = val ;
        temp->next = head->next;
​
        head->next = temp;
​
        head->val ++ ;
​
    }
    
    void addAtTail(int val) {
        node * p = head->next ;
​
        node * temp = new node();
        temp->val = val;
        temp->next = NULL;
​
​
        if(p==NULL)
        {
            head->next = temp;
            head->val++;
        }
        else
        {
            while(p->next!=NULL)
            {
​
                p = p->next;
            }
​
            p->next = temp;
            head->val++;
​
​
        }
​
        
​
    }
    
    void addAtIndex(int index, int val) {
        int i = 0;
        int MoveStep = index + 1;
​
        int count = 0;
​
        node * pre;
​
        node * p = head->next;
        count++;
​
        
​
        if(index > head->val)
        {
            return ;
​
        }else
        if(index == head->val)
        {
            addAtTail(val);
​
        }else
        if(index == 0)
        {
            addAtHead(val);
        }else
        {
            for( ; i < MoveStep - 1 ; i++ )
        {
            if(p == NULL)
            {
                break;
            }
            pre = p;
            p = p->next;
            
            count++;
        }
​
//cout<<"***********MoveStep - 1 : "<<MoveStep - 1<<endl;
​
//cout<<"***********count : "<<count<<endl;
​
//cout<<"***********p->val : "<<p->val<<endl;

//cout<<"***********pre->val : "<<pre->val<<endl;
​
        if(count < (MoveStep))
        {
            return ;
        }else
        if(count == MoveStep)
        {
            node * temp = new node();
            temp->val = val;
            temp->next = p;
            pre->next = temp;
​
head->val++;
            
        }
        else
        {
            cout<<"step 溢出"<<endl;
        }


    }
​
​
    }
    
    void deleteAtIndex(int index) {
        node * p = head->next;
​
        node * pre ;
​
        int step = index + 1;
​
        int i = 0;
​
        if(step > head->val )
        {
            return ;
        }
​
        if(index == 0)
        {
            head->next = head->next->next ;
​
            head->val--;
        }
        else
        {
            for( ;i< (step-1) ; i++)
            {
                pre = p;
                p = p->next;
​
            }
​
            pre->next = p->next;
​
head->val--;
​
​
​
        }
​
    }
};
​
/**
* Your MyLinkedList object will be instantiated and called as such:
* MyLinkedList* obj = new MyLinkedList();
* int param_1 = obj->get(index);
* obj->addAtHead(val);
* obj->addAtTail(val);
* obj->addAtIndex(index,val);
* obj->deleteAtIndex(index);
*/

 

 

206. 反转链表

题目链接： https://leetcode.cn/problems/reverse-linked-list/

 

Code

 

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
            // 假设 为 有头 结点 
        
​
        if(head == NULL)
        {
            return NULL;
        }else
        if(head->next == NULL)
        {
            return head;            // 一个 有效 结点 时 调 了 之后  前后  一样  (有效 荷载 区) 
            
        }else                                   // xx  内容  的  积累
        {                                               
            // “头插法”
​
            ListNode * p = head;
​
            ListNode * pre = p ;
​
            ListNode * spear ;
​
            p = p->next;
​
            pre->next = NULL;
​
​
            while(p != NULL)
            {
                // 内部 操作 ———— 链表 处理
​
​
                spear = p->next;
​
                p->next = pre;
​
​
                pre = p;
                p = spear;
​
            }
​
​
            head = pre ;
​
​
            return head ;
​
​
​
        }
​
​
​
​
    }
};