假期打卡的第六天

让两个链表同时进入，分别检测，谁小谁先进入…

    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    
    
        ListNode* tmp = new ListNode(0);
        ListNode* out = tmp;
        ListNode* tmp1 = l1, * tmp2 = l2;
        //避免空指针
        if(l1 == NULL) return l2;
        if(l2 == NULL) return l1;
        //如果都不是空，比较并完成写入
        while (tmp1 != nullptr && tmp2 != nullptr) {
    
    
            if (tmp1->val < tmp2->val) {
    
    
                out->next = new ListNode(tmp1->val);
                out = out->next;
                tmp1 = tmp1->next;
            }
            else {
    
    
                out->next = new ListNode(tmp2->val);
                out = out->next;
                tmp2 = tmp2->next;
            }
        }
        //剩余部分持续写入
        while (tmp1 != nullptr) {
    
    
            out->next = new ListNode(tmp1->val);
            out = out->next;
            tmp1 = tmp1->next;
        }
        while (tmp2 != nullptr) {
    
    
            out->next = new ListNode(tmp2->val);
            out = out->next;
            tmp2 = tmp2->next;
        }
        //第一位可以在循环开始前完成比较进行写入，偷个懒输出从第二位开始
        return tmp->next;
    }

下面是用链表的方式解决最小栈问题的解决方案…拖了几天才弄出来，哈

class MinStack {
    
    
private:
	//建立（私有）结构体 XminStack
    struct XminStack{
    
    
        int key;
        int min;
        XminStack* next;
        XminStack* befor;
		//空构造函数，缺失导致下面将私有项work无法正常生成
        XminStack(){
    
    
            key = 0;
            min = INT_MAX;	//避免错误，让最小值直接为int的极限大小
        }
		//后面生成用构造函数
        XminStack(int Key,int Min,XminStack* Befor){
    
    
            key = Key;
            min = Min;
            next = nullptr;
            befor = Befor;
        }
    };
    
    XminStack work;
    XminStack* os;
public:
    /** initialize your data structure here. */
    MinStack() {
    
    
        work.next = nullptr;
        work.befor = nullptr;
        os = &work;
    }
    
    void push(int _X) {
    
    
        if(os->min > _X){
    
    
        	//这里的内存要分配给我们的私有结构体XminStack而不是MinStack，与指针名同步...这里卡了一会
            os->next = new XminStack(_X,_X,os);
        }else{
    
    
            os->next = new XminStack(_X,os->min,os);
        }
        os = os->next;
    }
    
    void pop() {
    
    
        os = os->befor;
        delete os->next;
    }
    
    int top() {
    
    
        return os->key;
    }
    
    int getMin() {
    
    
        return os->min;
    }
};

链表是按照需求写的，更加节约空间和时间…[doge]