Question 1
My way
PS: This way is slow
mimic the exchange way like bubble sort th exchange each group of element’s position.
/**
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
class Solution {
public:
/**
*
* @param head ListNode类
* @param k int整型
* @return ListNode类
*/
ListNode* reverseKGroup(ListNode* head, int k) {
if(k == 1){
return head;
}
// count how many elements
int n = 0;
ListNode* cnt = head;
while(cnt != NULL){
cnt = cnt->next;
n+=1;
}
if(k == 2){
ListNode* start = new ListNode(0);
start->next = head;
ListNode* start1 = start;
for(int i = 0; i<=n-2; i+= 2){
ListNode* p = start->next;
ListNode* q = start->next->next;
// exchange
p->next = q->next;
q->next = p;
start->next = q;
for(int j = 0; j<2;j++){
start = start->next;
}
}
return start1->next;
}
// Similar to bubble sort
ListNode* start = new ListNode(0);
start->next = head;
ListNode* start0 = start;
for(int i = 0; i<=n-k; i+= k){
ListNode* start1 = start;
ListNode* start2 = start;
for(int o = 0; o<k-1;o++){
start1 = start2;
for(int l = k-1; l > o; l--){
ListNode* p = start1->next;
ListNode* q = start1->next->next;
p->next = q->next;
q->next = p;
start1->next = q;
start1 = start1->next;
}
}
for(int j = 0; j < k;j++){
start = start->next;
}
}
return start0->next;
}
};
A Better way
import java.util.*;
public class Solution {
public ListNode reverseKGroup (ListNode head, int k) {
if(head==null||head.next==null||k==1) return head;
ListNode res = new ListNode(0);
res.next = head;
int length = 0;
ListNode pre = res,
cur = head,
temp = null;
while(head!=null){
length++;
head = head.next;
}
//分段使用头插法将链表反序
for(int i=0; i<length/k; i++){
//pre作为每一小段链表的头节点,负责衔接
for(int j=1; j<k; j++){
temp = cur.next;
cur.next = temp.next;
//相当于头插法,注意:
//temp.next = cur是错误的,temp需要连接的不是前一节点,而是子序列的头节点
temp.next = pre.next;
pre.next = temp;
}
//每个子序列反序完成后,pre,cur需要更新至下一子序列的头部
pre = cur;
cur = cur.next;
}
return res.next;
}
}
Question 2
Solve
/**
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
class Solution {
public:
/**
*
* @param root TreeNode类
* @return bool布尔型
*/
// is symmetric left and right
bool isSym(TreeNode* left, TreeNode* right){
if(left == NULL && right == NULL){
return true;
}
else if(left == NULL || right == NULL){
return false;
}
else if(left->val == right->val && isSym(left->left,right->right) && isSym(left->right,right->left)){
return true;
}else{
return false;
}
}
bool isSymmetric(TreeNode* root) {
// write code here
if (root == NULL){ // 少了这句,导致段错误而过不了
return true;
}
TreeNode* left = root->left;
TreeNode* right = root->right;
return isSym(left,right);
}
};
lesson: Didn’t check whether root is NULL, which resulting to segmentation fault continously.
Solve with iteration
import java.util.*;
public class Solution {
public boolean isSymmetric (TreeNode root) {
if(root == null)
return true;
Queue<TreeNode> q = new LinkedList<>();
q.offer(root.left);
q.offer(root.right);
while(!q.isEmpty()){
TreeNode left = q.poll();
TreeNode right = q.poll();
if(left == null && right == null)
continue;
if(left == null || right == null)
return false;
if(left.val != right.val)
return false;
q.offer(left.left);
q.offer(right.right);
q.offer(left.right);
q.offer(right.left);
}
return true;
}
}