【LeetCode23-29+518】 K个有序子链，交换链表顺序（指针调换），Vector删除元素，移位运算符>>，DP算法

23.连接K个有序子链，在21题的基础上加一个循环就好了……

class Solution {
public:
ListNode* mergeKLists(vector<ListNode*>& lists) {
ListNode result(0);
ListNode *temp=&result;
for(int i=0;i<lists.size();i++){
temp->next=mergeTwoLists(temp->next,lists[i]);
}
return result.next;
}
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
ListNode result(0);
ListNode *temp;temp = &result;
//  result.val = l1->val > l2->val ? l2->val : l1->val;
while (l1 && l2) {
if (l1->val < l2->val) {
temp->next = l1;
l1 = l1->next;
}
else {
temp->next = l2;
l2 = l2->next;
}
temp = temp->next;
}
temp->next = l1 ? l1 : l2;//很重要，把空的都解决了。。。
return result.next;
}
};

24.每两个交换单链表顺序

//解题感受是，指针得画个图才能弄得清，不然容易出错…

Given 

1->2->3->4

,
you should return the list as 

2->1->4->3

.

/**
* Definition for singly-linked list.
* struct ListNode {
*     int val;
*     ListNode *next;
*     ListNode(int x) : val(x), next(NULL) {}
* };
*/

class Solution {
public:
ListNode* swapPairs(ListNode* head) {

if(!head||!head->next)return head;

ListNode result(0);
ListNode *temp=&result;
//   head->next = swapPairs(result->next);
//    result->next = head;

//   return result;

while(head&&head->next){
temp->next=head->next;
//指针指针指针，和值传参不一样，得画个图……
//比如用temp指向了head的一位，然后修改temp的下一位的时候其实把head的下一位也修改了，所以要考虑顺序……
//head往后挪一位相当于原来的挪两位…
head->next=temp->next->next;//顺序真的非常重要
temp=temp->next;
temp->next=head;
temp=temp->next;
head=head->next;

}
return result.next;

}

/*
ListNode* swapPairs(ListNode* head) {
ListNode **pp = &head, *a, *b;
while ((a = *pp) && (b = a->next)) {
a->next = b->next;
b->next = a;
*pp = b;
pp = &(a->next);
}
return head;
}*/
};

25.类似于24，每K个交换单链表顺序

Given this linked list: 

1->2->3->4->5

For k = 2, you should return: 

2->1->4->3->5

For k = 3, you should return: 

3->2->1->4->5

//做的时候用了vector存储了ListNode的地址……

//用到了迭代的思想，看着会舒服很多

//23ms，击败38%

/**
* Definition for singly-linked list.
* struct ListNode {
*     int val;
*     ListNode *next;
*     ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* reverseKGroup(ListNode* head, int k) {
//试试用迭代

ListNode result(0);
ListNode *temp=&result;
vector<ListNode*>T;
ListNode *origin=head;//origin的作用是在修改了head之后还能返回之前的…之所以不用T[0]是因为T可能为空
for(int i=0;i<k;i++){if(!head)return origin;T.push_back(head);head=head->next;}
for(int i=0;i<k;i++){temp->next=T[k-1-i];temp=temp->next;}
temp->next=reverseKGroup(head,k);
return result.next;
}
};

26.删除有序数组里重复的数据并返回数组大小

//相对挺容易的，但要注意Vector删除元素的用法

class Solution {
public:
int removeDuplicates(vector<int>& nums) {
//  unordered_map<int,int> mapping;
//   int result=0;
//    for(int i=0;i<nums.size();i++){
//        if(mapping.find(nums[i])==mapping.end()){mapping[nums[i]]=0;result++;}
//     }
//      return result;

int length=nums.size();
for(int i=0;i<length-1;i++){
if(nums[i]==nums[i+1]){
vector<int>::iterator it = nums.begin()+i+1; nums.erase(it);//删除元素
i--; length--;
}
}
return length;

//删除元素的用法
/*   std::vector<int>::iterator it = vec.begin()+10;vec.erase(it);*/
}
};

27.删除数组里特定数值并返回长度

//知道怎么删除Vector数组里指定位置元素就很简单了

class Solution {
public:
int removeElement(vector<int>& nums, int val) {
int length=nums.size();
for(int i=0;i<length;i++){
if(nums[i]==val){
vector<int>::iterator it=nums.begin()+i;
nums.erase(it);
length--;
i--;
}
}
return length;
}
};

28.字符串中第一次出现制定字符串位置

//判断字符串是否一样还是用==，不要想太多…………

class Solution {
public:
int strStr(string haystack, string needle) {
int result=-1;
if(needle=="")return 0;
int length=needle.size();
if(haystack.size()<length)return -1;
for(int i=0;i<haystack.size()-length+1;i++){
if(haystack[i]==needle[0]){
if(needle==haystack.substr(i,length))return i;
}
}
return result;
}
};

29.实现整数的出发，不能用乘除和模运算（需要用到移位运算法）

typedef long long ll;
#define MAX 2147483647
class Solution {
public:
int divide(int n, int d) {
ll result=0;
ll n_=abs(ll(n));
ll d_=abs(ll(d));

while(n_>=d_){
int m=1;
ll temp=d_;//本质上的除法又实现了一遍
while((temp<<1)<n_){m<<=1;temp<<=1;}//注意<<=才是真正移位了！！
result+=m;
n_-=temp;
}
if((n<0&&d>0)||(n>0&&d<0))result= -result;
if(result>MAX||result<-MAX-1)return MAX;
return result;

}

};

518,给出找零钱所有策略个数

Example 1:

Input: amount = 5, coins = [1, 2, 5]
Output: 4
Explanation: there are four ways to make up the amount:
5=5
5=2+2+1
5=2+1+1+1
5=1+1+1+1+1

Example 2:

Input: amount = 3, coins = [2]
Output: 0
Explanation: the amount of 3 cannot be made up just with coins of 2.

Example 3:

Input: amount = 10, coins = [10]
Output: 1

//DP算法……

class Solution {
public:
int change(int amount, vector<int>& coins) {
unordered_map <int,int>mapping;
mapping[0]=1;
for(int i=0;i<coins.size();i++){
for(int j=coins[i];j<=amount;j++)
mapping[j]+=mapping[j-coins[i]];
}
return mapping[amount];
}
};