0808面试

这次猿辅导的面试很糟糕，代码写的很差。

这题就是奇偶链表了。

#include
#include
using namespace std;
typedef struct ListNode
{
     
	int val;
	ListNode*next;
	ListNode(int val) :val(val), next(NULL) {
     }
}ListNode;

ListNode*fun(ListNode*head)
{
     
	if (head->next == NULL)
		return NULL;
	ListNode*new_head = head->next;
	ListNode*t = head->next;
	while (t && t->next)
	{
     

		t->next = t->next->next;
		t = t->next;

	}
	return new_head;
}
int main()
{
     

	ListNode*node1 = new ListNode(1);
	ListNode*node2 = new ListNode(2);
	ListNode*node3 = new ListNode(3);
	ListNode*node4 = new ListNode(4);
	ListNode*node5 = new ListNode(5);
	node1->next = node2;
	node2->next = node3;
	node3->next = node4;
	node4->next = node5;
	ListNode*new_head = fun(node1);
	ListNode*t = new_head;
	while (t)
	{
     
		cout << t->val << endl;
		t = t->next;
	}
	system("pause");
	return 0;
}

奇偶交替作业

class Solution {
     
public:
	ListNode* oddEvenList(ListNode* head) {
     
		if (head == NULL || head->next == NULL)return head;
		//双指针
		ListNode*odd_head = head;//奇链表头结点
		ListNode*odd_t = head;
		ListNode*even_head = head->next;//偶链表头结点
		ListNode*even_t = head->next;
		while (even_t!=NULL&&even_t->next != NULL)//奇偶交替作业
		{
     
			odd_t->next = even_t->next;
			odd_t = odd_t->next;

			even_t->next = odd_t->next;
			even_t = even_t->next;

		}

		odd_t->next = even_head;
		return head;

	}
};

class Solution {
     
public:
    vector<vector<int>> intervalIntersection(vector<vector<int>>& A, vector<vector<int>>& B) {
     
        vector<vector<int>>res;
        
        int i=0,j=0;
        while(i<A.size()&&j<B.size())
        {
     
            vector<int>temp;
            int start=max(A[i][0],B[j][0]);
            int end=min(A[i][1],B[j][1]);
            if(start<=end)
            {
     
                temp.push_back(start);
                temp.push_back(end);
                res.push_back(temp);
            }
            //较早结束的子区间不可能再和别的子区间重叠了，所以较早结束的子区间要移到下一个子区间，而另一个子区间不需要移动
            A[i][1]<B[j][1]?i++:j++;
        }

        return res;
        

    }
};

很简单的双指针，只要维护区间内0的个数不超过K即可，如果区间内有K+1个0，那么左指针右移，直到区间内只有K个0

class Solution {
     
public:
//双指针
    int longestOnes(vector<int>& A, int K) {
     
        int left=0,right=0;
        int used=0;
        int res=0;
        while(right<A.size())
        {
     
            if(A[right]==0)
            {
     
                used++;
                if(used==K+1)
                {
     
                    while(A[left]!=0)
                        left++;
                    left++;
                    used--;
                }
                
            }
            res=max(res,right-left+1);
            right++;


        }
        return res;


    }
};