website·Indexed 30 days ago
http://docs.ayuisokay.comA collection of personal technical notes covering algorithm problem solutions (including sorting, linked lists, and binary trees), development tips, interview experiences, and post-mortems of work-related issues such as Dataworks data synchronization and system failures.
insert update operations on the same primary key in a production database may not always execute sequentially. If two different batches attempt to update the same record simultaneously, the resulting record may contain a mix of field values from both batches, leading to corrupted data. To resolve this, it is recommended to reset the corrupted data to a known correct state and re-insert missing records with corrected primary keys.class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
if(root == null) return new ArrayList<>();
// Result list
List<List<Integer>> lists = new ArrayList<>();
// Node queue
Queue<TreeNode> queue = new LinkedList<>();
// Add root node
queue.add(root);
while(!queue.isEmpty()){
// Use size to ensure only current level nodes are traversed
int size = queue.size();
List<Integer> list = new ArrayList<>();
while(size-- > 0){
TreeNode temp = queue.poll();
list.add(temp.val);
// Add left and right children to queue
if(temp.left != null) queue.add(temp.left);
if(temp.right != null) queue.add(temp.right);
}
lists.add(list);
}
return lists;
}
}public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
if(headA == null || headB == null) return null;
ListNode p = headA;
ListNode q = headB;
while(p != q) {
p = p == null ? headB : p.next;
q = q == null ? headA : q.next;
}
return p;
}
}To reverse a specific segment of a linked list between positions left and right:
superior).superior node to the new head of the reversed segment.class Solution {
public ListNode reverseBetween(ListNode head, int left, int right) {
ListNode dummyHead = new ListNode(-1);
dummyHead.next = head;
ListNode superior = dummyHead;
for(int i = 1; i < left; i++) {
superior = superior.next;
}
ListNode curr = superior.next;
ListNode prev = null;
for(; left <= right; left++) {
ListNode temp = curr.next;
curr.next = prev;
prev = curr;
curr = temp;
}
superior.next.next = curr;
superior.next = prev;
return dummyHead.next;
}
}/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode middleNode(ListNode head) {
ListNode fast = head;
ListNode slow = head;
while (fast.next != null && fast.next.next !=null) {
fast = fast.next.next;
slow = slow.next;
}
if(fast.next == null) return slow;
return slow.next;
}
}k positions, first determine the length of the list. Since rotating a list of length deep by deep times results in the original list, only k % deep rotations are necessary. The process involves: 1. Calculating the list length and identifying the tail node. 2. Connecting the tail node to the head to create a circular linked list. 3. Finding the new tail node at position deep - (k % deep) and the new head node immediately following it. 4. Breaking the circular connection by setting the new tail's next pointer to null./**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode rotateRight(ListNode head, int k) {
// Handle cases where rotation is not needed
if (head == null || k == 0 || head.next == null) {
return head;
}
// Find the length of the list and the last node
ListNode temp = head;
int deep = 1;
while (temp.next != null) {
temp = temp.next;
deep++;
}
// Calculate the actual number of rotations needed
int n = deep - k % deep;
if (n == deep) {
return head;
}
// Make the list circular
temp.next = head;
// Move to the node preceding the new head
while (n > 0) {
temp = temp.next;
n--;
}
// Set the new head and break the circle
ListNode res = temp.next;
temp.next = null;
return res;
}
}