2021-04-01

反转链表

输入一个链表，反转链表后，输出新链表的表头。

此题想考察的是：如何调整链表指针，来达到反转链表的目的。
初始化：3个指针cur,pre,nex
1）pre指针指向已经反转好的链表的最后一个节点，最开始没有反转，所以指向nullptr
2）cur指针指向待反转链表的第一个节点，最开始第一个节点待反转，所以指向head
3）nex指针指向待反转链表的第二个节点，目的是保存链表，因为cur改变指向后，后面的链表则失效了，所以需要保存
接下来，循环执行以下三个操作
1）nex = cur->next, 保存作用
2）cur->next = pre 未反转链表的第一个节点的下个指针指向已反转链表的最后一个节点
3）pre = cur， cur = nex; 指针后移，操作下一个未反转链表的第一个节点
循环条件，当然是cur != nullptr
循环结束后，cur当然为nullptr，所以返回pre，即为反转后的头结点

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        ListNode* cur=pHead;
        ListNode* nex=NULL;
        ListNode* pre=NULL;
        while(cur)
        {
            nex=cur->next;
            cur->next=pre;
            pre=cur;
            cur=nex;
        }
        return pre;
    }
};

判断链表中是否有环

快慢指针的解法， 一个指针走两步 一个指针走一步，如果快指针直接到了null 说明没有环， 如果有环的话 总有一次结果会让快指针和慢指针相等。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode *fast=head,*slow=head;
        if(head==NULL) return false;
        while(fast&&fast->next)
        {
            fast=fast->next->next;
            slow=slow->next;
            if(fast==slow) return true;
        }
        return false;
    }
};

最小的k个数

给定一个数组，找出其中最小的K个数。例如数组元素是4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。如果K>数组的长度，那么返回一个空的数组

法一、直接排序，然后取前k小数据。

时间复杂度：O(nlongn)
空间复杂度：O(1)

class Solution {
public:
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        vector<int>ret;
        if(k==0||k>input.size()) return ret;
        sort(input.begin(),input.end());
        return vector<int>(input.begin(),input.begin()+k); 
    }
};

法二、建立一个容量为k的大根堆的优先队列。遍历一遍元素，如果队列大小<k,就直接入队，否则，让当前元素与队顶元素相比，如果队顶元素大，则出队，将当前元素入队

class Solution {
public:
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        vector<int>ret;
        if(k==0||k>input.size()) return ret;

        priority_queue<int,vector<int>> pq;
        for(const int val:input)
        {
            if(pq.size()<k)
            {
                pq.push(val);
            }
            else 
            {
                if(val<pq.top())
                {
                    pq.pop();
                    pq.push(val);
                }
            }
        }
        while(!pq.empty())
        {
            ret.push_back(pq.top());
            pq.pop();
        }
        return ret;
    }
};

法三：快排思想

对数组[l, r]一次快排partition过程可得到，[l, p), p, [p+1, r)三个区间,[l,p)为小于等于p的值
[p+1,r)为大于等于p的值。
然后再判断p，利用二分法

1. 如果[l,p), p，也就是p+1个元素（因为下标从0开始），如果p+1 == k, 找到答案
   2。 如果p+1 < k, 说明答案在[p+1, r)区间内，
   3， 如果p+1 > k , 说明答案在[l, p)内

class Solution {
public:
    int partition(vector<int>&input,int l,int r)
    {
        int pivot=input[r-1];
        int i=l;
        for(int j=l;j<r-1;j++)
        {
            if(input[j]<pivot)
                swap(input[i++],input[j]);
        }
        swap(input[i],input[r-1]);
        return i;
    }
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        vector<int>ret;
        if(k==0||k>input.size()) return ret;
        int l=0,r=input.size();
        while(l<r)
        {
            int p=partition(input, l, r);
            if(p+1==k) return vector<int>(input.begin(),input.begin()+k);
            if(p+1<k) l=p+1;
            else r=p;
        }
        
    return ret;
    }
    
};