2016年08月_varcom

10月 09月 08月

原创 55. Jump Game

深搜＋剪枝class Solution {public: void Jump(vector& nums,int sta,bool vist[],bool& tag) { if(sta>=nums.size()-1||sta+nums[sta]>=nums.size()-1) { tag=true;

2016-08-31 22:34:13 173

原创 41. First Missing Positive

桶排序，当nums[i]!=i+1时，交换nums[i]和nums[nums[i]-1]],这一步后nums[nums[i]-1]中就是正确的值。所以若存在i+1，最终会换到nums[i]。class Solution {public: int firstMissingPositive(vector& nums) { int n=nums.size();

2016-08-31 21:45:51 153

原创 4. Median of Two Sorted Arrays

这道题一开始的想法是比较中位数，在去掉较小的左半段，和较大的右半段，但十分复杂，要考虑到许多边界情况，改成求第K位数就简单很多class Solution {public: int getKthSorted(vector& nums1,int sta1,int len1,vector& nums2,int sta2,int len2,int k) { if(l

2016-08-31 21:05:29 127

原创 42. Trapping Rain Water

取一条左边的较高边，再往右找一条>=左边的边，或者左边最高的边class Solution {public: int trap(vector& height) { int n=height.size(); int i=0,j,left,right; int ans=0; while(i<n&&height[i]==0)

2016-08-31 18:13:17 152

原创 40. Combination Sum II

回溯，因为每个数字只能出现一次，所以当下一个数字和当前数字相同时，若当前数退出时，下一个数不需要进栈了class Solution {public: void GetRes(vector& nums,int sta,vector>& res,int sum,vector ans,int target) { if(sum==target&&ans.size()>

2016-08-31 10:48:35 140

原创 39. Combination Sum

回溯class Solution {public: void Getans(vector& nums,int sta,vector>& res,int cur,vector ans,int target) { if(cur==target&&ans.size()>0) { res.push_back(ans);

2016-08-31 09:53:51 152

原创 33. Search in Rotated Sorted Array

这里只会有两种情况

2016-08-30 23:31:52 148

原创 34. Search for a Range

二分搜索，在找最左端，要找的目标值小于target，所以最后必定left指向最左端，right指向最左端的前一个数字，同理，最右端class Solution {public: vector searchRange(vector& nums, int target) { int n=nums.size(); int left=0,right=n-1,m

2016-08-30 20:30:46 187

原创 35. Search Insert Position

二分查找class Solution {public: int searchInsert(vector& nums, int target) { int n=nums.size(); int left=0,right=n-1; while(left<=right) { int mid=(left+

2016-08-30 19:57:04 157

原创 11. Container With Most Water

使用线段数，先枚举一条边作为较小的一条边，再找左边比它大和最右边比它大的边，两者的较大值就是以这条边为较短边的最大面积，构建和查询线段数的时间是log(n)，总的时间是nlog(n)class Solution {struct segTree{ int l,r; int v; segTree* left,*right; segTree(int val):v(v

2016-08-30 15:36:16 133

原创 18. 4Sum

枚举第一个数和最后一个数，中间两个数二分查找class Solution {public: vector> fourSum(vector& nums, int target) { int n=nums.size(); int i,j,k,t; sort(nums.begin(),nums.end());

2016-08-29 23:21:59 323

原创 16. 3Sum Closest

枚举＋二分搜索class Solution {public: int threeSumClosest(vector& nums, int target) { int n=nums.size(); int i,j,k; int ans=nums[0]+nums[1]+nums[2]; sort(nums.begin(),n

2016-08-29 22:42:39 282

原创 15. 3Sum

先枚举前两个数，再看第三个数在不在，在这里主要需处理好重复的问题，所以先排好序，若第一个数字相同，跳过，若第二个数字想同，也跳过class Solution {public: vector> threeSum(vector& nums) { int n=nums.size(); int i,j,k,length; int ans;

2016-08-29 22:03:42 262

原创 26. Remove Duplicates from Sorted Array

class Solution {public: int removeDuplicates(vector& nums) { int n=nums.size(); int i,k=0,length=n; for(i=1;i<n;i++) { if(nums[i]==nums[i-1-k])

2016-08-29 20:16:01 265

原创 27. Remove Element

class Solution {public: int removeElement(vector& nums, int val) { int n=nums.size(); int i,k=0,len; for(i=0;i<n;i++) { if(nums[i]==val)

2016-08-29 20:09:00 260

原创 31. Next Permutation

从最后第二个开始往前遍历，找到第一个并非大于后面数据的数，进行交换，因为最大的数据必定是维持整个数列单调递减class Solution {public: void nextPermutation(vector& nums) { int n=nums.size(); vector:: iterator it,jt; int tmp;

2016-08-29 20:01:41 265

原创 1. Two Sum

使用映射表map , unordered_mapmap基于红黑树，unordered_map基于哈希，显然unordered_map更加合适class Solution {public: vector twoSum(vector& nums, int target) { int n=nums.size(); int i; unord

2016-08-29 17:09:06 254

原创 385. Mini Parser

递归实现，判断字符串结束最好用iclass Solution {public: NestedInteger deserialize(string s) { bool level=false; int len=s.size(); if(s[0]=='[') { level=true;

2016-08-21 23:14:50 272

原创 383. Ransom Note

方法1:class Solution {public: bool canConstruct(string ransomNote, string magazine) { int alp[30],alpc[30]; memset(alp,0,sizeof(alp)); memset(alpc,0,sizeof(alpc));

2016-08-21 16:51:06 149

原创 138. Copy List with Random Pointer

方法1:先将节点放入vector中，先连接好每个节点的random。class Solution {public: int getNum(RandomListNode* head,RandomListNode* p) { if(p==NULL) return -1; int cnt=1; Random

2016-08-21 14:45:38 139

原创 341. Flatten Nested List Iterator

方法1:NestedInteger实际上是一个树结构，递归实现。class NestedIterator {public: NestedIterator(vector &nestedList) { int len=nestedList.size(); int it=0; while(it<len) {

2016-08-21 10:00:03 170

原创 147. Insertion Sort List

方法1:从后往前比较/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public:

2016-08-21 09:32:46 149

原创 237. Delete Node in a Linked List

不能是尾结点class Solution {public: void deleteNode(ListNode* node) { if(node==NULL&&node->next) return; node->val=node->next->val; node->next=node->next->next;

2016-08-21 09:20:13 146

原创 109. Convert Sorted List to Binary Search Tree

方法1:分治法；/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; *//** * Definition for a binar

2016-08-21 09:14:14 151

原创 382. Linked List Random Node

应用reservior sampling ，第i个被选中的概率为1/i，之后没有被选中的概率i－1/i，所以第1个被选中的概率为1/1*（1/2）＊（2/3）＊...(n-1)/n=1/n，class Solution {public: /** @param head The linked list's head. Note that the head is

2016-08-20 15:51:09 159

原创 142. Linked List Cycle II

从head到起始点为a，起始点到相遇点为b，圈常为x；fast走了a＋b＋n＊x，slow走了a＋b＋m＊x；a+b+n＊x＝2*（a+b+m＊x）＝》a+b＝（n－2*m）＊x＝》在fast和slow相遇后再走a步即为起始点class Solution {public: ListNode* detectCycle(ListNode *head) { Li

2016-08-20 10:31:18 166

原创 141. Linked List Cycle

class Solution {public: bool hasCycle(ListNode *head) { if(head==NULL||head->next==NULL) return false; ListNode* fast=head->next,*slow=head; while(fast&&slow&&

2016-08-20 09:01:01 132

原创 160. Intersection of Two Linked Lists

class Solution {public: ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) { ListNode* pa=headA,*pb=headB; int la=0,lb=0; while(pa) { la++

2016-08-19 22:50:01 139

原创 86. Partition List

方法1:插入&删除class Solution {public: ListNode* partition(ListNode* head, int x) { ListNode* Head=new ListNode(-1); Head->next=head; ListNode* pre=Head,*cur=head,*p=

2016-08-19 18:22:53 179

原创 234. Palindrome Linked List

方法1:将前半段压入栈中，时间O(n)，空间O(n);class Solution {public: bool isPalindrome(ListNode* head) { stack st; ListNode* cur=head; int len=0; while(cur) {

2016-08-19 15:52:36 139

原创 328. Odd Even Linked List

class Solution {public: ListNode* oddEvenList(ListNode* head) { if(head==NULL||head->next==NULL) return head; ListNode* pre=head,*cur=head->next,*nx=NULL; List

2016-08-19 11:21:53 141

原创 23. Merge k Sorted Lists

方法1:堆排序，否则会超时class Solution {public: void MinHeadFixup(vector& vec,ListNode* p,int len) { vec.push_back(p); for(int i=len-1,j=(i-1)/2;(j>=0&&i!=0)&&vec[i]->valval;i=j,j=(i

2016-08-18 02:17:33 192

原创 21. Merge Two Sorted Lists

加虚拟头节点class Solution {public: ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) { ListNode* head=new ListNode(-1),*p=head; while(l1&&l2) { if(l1->valval)

2016-08-17 19:29:49 174

原创 143. Reorder List

先将后len／2的链表节点翻转，再依次插入前半段链表中class Solution {public: void reorderList(ListNode* head) { if(head==NULL||head->next==NULL) return; int len=0; ListNode*

2016-08-17 01:03:09 153

原创 19. Remove Nth Node From End of List

class Solution {public: ListNode* removeNthFromEnd(ListNode* head, int n) { ListNode* Head=new ListNode(-1); Head->next=head; ListNode* pre=Head,*cur=Head;

2016-08-17 00:27:37 166

原创 203. Remove Linked List Elements

class Solution {public: ListNode* removeElements(ListNode* head, int val) { ListNode* Head=new ListNode(-1); Head->next=head; ListNode* cur=head,*pre=Head; while(c

2016-08-17 00:12:07 149

原创 82. Remove Duplicates from Sorted List II

class Solution {public: ListNode* deleteDuplicates(ListNode* head) { if(head==NULL||head->next==NULL) return head; ListNode* Head=new ListNode(-1); He

2016-08-16 23:49:11 220

原创 83. Remove Duplicates from Sorted List

注意释放删除节点的空间；class Solution {public: ListNode* deleteDuplicates(ListNode* head) { if(head==NULL||head->next==NULL) return head; ListNode* pre=head,*p=head->n

2016-08-16 21:56:14 202

原创 148. Sort List

使用归并排序；/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: Li

2016-08-16 20:20:00 160