21 Merge Two Sorted Lists
思路:新建一个链表,比较l1和l2中的值,哪个小就把它加到新的链表中去,最后总会有一个链表先到尾部,那么直接把剩下的链表接到新链表尾部就可以啦,注意链表为空问题判断,必须先初始化。
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
ListNode temp(0);
ListNode* dummy = &temp; //如果只写ListNode* dummy,会报错。
ListNode* cur;
cur = dummy;
while(l1 && l2) {
if (l1->val < l2->val) {
cur->next = l1;
l1 = l1->next;
}
else {
cur->next = l2;
l2 = l2->next;
}
cur = cur->next;
}
cur->next = l1 ? l1 : l2;
return dummy->next;
}
思路2:递归算法
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
if (!l1) return l2;
if (!l2) return l1;
if (l1->val < l2->val) {
l1->next = mergeTwoLists(l1->next,l2);
return l1;
}
else {
l2->next = mergeTwoLists(l1,l2->next);
return l2;
}
}
22.Generate Parentheses
思路:我在这里用递归和回溯法,卡住了半个月,这一段时间,一直没绕过来这个弯,什么递归啦,回溯法,DFS,虽然现在也不是特别懂,但是我想,还是多多刷题,找感觉。
left表示剩余左括号数,right表示剩余右括号数,首先遵循原则:先生成左括号,然后右括号 ,右括号剩余个数必须要比左括号多。当左右括号剩余都为0时,结束。
class Solution {
public:
vector<string> generateParenthesis(int n) {
vector<string> v;
helper(v,"",n,n);
return v;
}
void helper(vector<string> &v,string temp,int left,int right) {
if (left == 0 && right == 0) {
v.push_back(temp);
return;
}
if (left > 0 ) {
helper(v,temp+"(",left-1,right);
}
if (right > left) {
helper(v,temp+")",left,right-1);
}
}
};
23.Merge k Sorted Lists
思路:k个链表进行合并,可以用归并,先写一个合并两个链表的函数mergeTwo(l1,l2),比较l1和l2的val,最后如果其中一个链表为空,则指向另外一个链表。
ListNode* mergeKLists(vector<ListNode*>& lists) {
if (lists.size() == 0)
return NULL;
int n = lists.size();
while(n > 1) {
int k = (n + 1) / 2;
for (int i = 0;i < n/2;i++) {
lists[i] = mergeTwo(lists[i],lists[i+k]);
}
n = k;
}
return lists[0];
}
ListNode* mergeTwo(ListNode* l1,ListNode* l2) {
ListNode* dummy = new ListNode(-1);
ListNode* pre = dummy;
while(l1 && l2) {
if (l1->val < l2->val) {
pre->next = l1;
l1 = l1->next;
}
else {
pre->next = l2;
l2 = l2->next;
}
pre = pre->next;
}
if (l1) pre->next = l1;
if (l2) pre->next = l2;
return dummy->next;
}
24.Swap Nodes in Pairs
思路1:需要一个假节点,指向head,首先判断head是否为NULL,如果NULL,则返回NULL,然后进行pre,head,head->next之间的交换,最主要就是各节点之间的指向关系变换。
ListNode* swapPairs(ListNode* head) {
if (!head)
return NULL;
ListNode* pre = new ListNode(-1);
pre->next = head;
ListNode* temp = pre;
while (temp->next&& temp->next->next) {
ListNode* t = temp->next->next;
temp->next->next = t->next;
t->next = temp->next;
temp->next = t;
temp = temp->next->next;
}
return pre->next;
}
思路2:递归。判断head和head->next是否为空,为空的话,返回head。否则,t = head->next,然后swapPairs(t->next)递归调用,返回的值相当于是第三个节点,然后让head指向它,t指向head,返回t.
ListNode* swapPairs(ListNode* head) {
if (!head || !head->next) {
return head;
}
ListNode* t = head->next;
head->next = swapPairs(t->next);
t->next = head;
return t;
}
26.Remove Duplicates from Sorted Array
思路:要求在原址上进行删除操作,但是并不是实际上的删除重复元素。比如说,数组为【0,0,0,1,1,2,2,3】,我们只需要得到数组为【0,1,2,3,0,0,1,2】就可以啦,返回前边非重复的数字个数4,并且可以通过下标进行访问,下标就是0-3.所以用双指针,i表示慢的那个指针,j表示快的指针,初始化j=i+1,然后如果nums[j] == nums[i],那就说明重复项,跳过,j+1,再进行比较,如果nums[i] != nums[j],说明不是重复项,可以接在i后面,也就是让i+1,swap(nums[i],nums[j])。最后返回的是i的值。
class Solution {
public:
int removeDuplicates(vector<int>& nums) {
if (nums.empty())
return 0;
int i = 0;
for (int j = i + 1; j < nums.size(); j++) {
if (nums[j] != nums[i]) {
i++;
swap(nums[i],nums[j]);
}
}
return i+1;
}
};
27.Remove Element
思路:这题和上一道题差不多,还是要用两个指针,比较和val值是否相等,如果不相等就放入nums[i]
class Solution {
public:
int removeElement(vector<int>& nums, int val) {
int i = 0;
for (int j = 0; j < nums.size(); j++) {
if (nums[j] != val) {
nums[i] = nums[j];
i++;
}
}
return i;
}
};
28.Implement strStr()
思路:这道题是找子字符串在原字符串中出现的位置,用到了C++中的substr函数。首先判断needle是否为空,然后判断haystack的长度是否比needle小;从 i = 0开始,到haystack.size() - needle.size()+1结束,判断从i开始长度为needle.size() 的字符串是否和needle一样,如果相等,直接输出i。
class Solution {
public:
int strStr(string haystack, string needle) {
if (needle.empty())
return 0;
if (needle.size() > haystack.size())
return -1;
for (int i = 0; i < haystack.size() - needle.size() + 1; i++) {
if (haystack.substr(i,needle.size()) == needle)
return i;
}
return -1;
}
};
29. Divide Two Integers
思路:计算除法,不能用乘法,取模等,所以这时候用到位运算。首先,除数被除数都变成long long 类型绝对值,最后用符号判断是否乘-1;如果除数为0,返回INT_MAX;如果m >= n,这时候count = 1,p赋值为n,判断m和p<<1的大小,如果大的话count也扩大两倍也就是count<<1.当m < p<<1的时候,退出内层循环,m = m - p,继续进行上面的循环判断。最后return 判断的是被除数是比如被除数是-2147483648,在int范围内,当除数是-1时,结果就超出了int范围,需要返回INT_MAX这种情况。
int divide(int dividend, int divisor) {
long long m = abs((long long) dividend);
long long n = abs((long long) divisor);
long long res = 0;
if (divisor == 0 )
return INT_MAX;
while (m >= n) {
long long p = n;
long long count = 1;
while (m >= p<<1) {
count <<= 1;
p <<= 1;
}
m = m - p;
res += count;
}
res = (dividend < 0) ^ (divisor < 0) ? -res : res;
return res > INT_MAX ? INT_MAX : res;
}
30.Next Permutation
思路:求下一个全排列。首先,我们要清楚全排列是怎么生成的。1.从增序开始,(1,2,3,4,5)2.从末尾元素向前找,找到第一个非递减元素,标记i;3.然后从末尾向前找,第一个比nums[i]大的元素j,swap(nums[i],nums[j]);4.从i+1到末尾,进行reverse().5.如果是54321,那么下一个排列是reverse()–>12345.
void nextPermutation(vector<int>& nums) {
int n = nums.size();
for (int i = n - 2; i >= 0; i--) {
if (nums[i] <= nums[i+1]) {
for (int j = n - 1; j > i; j--) {
if (nums[j] > nums[i]) {
swap(nums[i],nums[j]);
reverse(nums.begin()+i+1,nums.end());
return;
}
}
}
}
reverse(nums.begin(),nums.end());
}