Linked List 专栏

问题一:

    merge two sorted linkedlist.

Key to solve this problem

The key to solve the problem is defining a fake head. Then compare the first elements from each list. Add the smaller one to the merged list. Finally, when one of them is empty, simply append it to the merged list, since it is already sorted.

　　

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
 
        ListNode p1 = l1;
        ListNode p2 = l2;
 
        ListNode fakeHead = new ListNode(0);
        ListNode p = fakeHead;
 
        while(p1 != null && p2 != null){
          if(p1.val <= p2.val){
              p.next = p1;
              p1 = p1.next;
          }else{
              p.next = p2;
              p2 = p2.next;
          }
 
          p = p.next;
        }
 
        if(p1 != null)
            p.next = p1;
        if(p2 != null)
            p.next = p2;
 
        return fakeHead.next;
    }
}

 

 问题 二：

Given a node from a cyclic linked list which has been sorted, write a function to insert a value into the list such that it remains a cyclic sorted list. The given node can be any single node in the list.

 

详解

 

public void insert(Node aNode,int x){
        
        
        if(aNode == null){
            aNode = new Node(x);
            aNode.next = aNode;
            return;
        }
        
        Node p = aNode;
        Node prev = null;
        
        do{
            prev = p;
            p = p.next;
            if(prev.data <= x && p.data >=x) break;// case 1
            if((prev.data > p.data) && (prev.data < x || p.data > x))break; //case2
        }while(p.next!=aNode); // case 3
            
        Node newNode = new Node(x);
        prev.next = newNode;
        newNode.next = p;
            
    }

}
class Node{
    
    int data;
    Node next;
    Node(int x){data = x; next =null;}
}

 

问题三  巧用prev.

 

Reversing linked list can be done both iteratively and recursively. In my opinion, the iterative solution should be more efficient and less memory overhead than its recursive counterpart (Imagine reversing a link list that has one million elements recursively! It would quickly run out of stack space).

The recursive solution can be coded in fewer lines of code, but is harder to code correctly. On the other hand, the iterative solution requires more code but is easier to verify.

1) The iterative way:

 

void reverse(Node*& head) {
  if (!head) return;
  Node* prev = NULL;
  Node* curr = head;
  while (curr) {
    Node* next = curr->next;
    curr->next = prev;
    prev = curr;
    curr = next;
  }
  head = prev;
}

 

 

Please do note that the head pointer is passed in by reference. If you have trouble understanding the syntax, think the pointer as a type, and an & sign followed by a type signifies the variable is passed by reference. The head pointer must be passed in by reference whenever there might be a change to the head pointer itself!

 

三.2

LeetCode – Remove Duplicates from Sorted List

Given a sorted linked list, delete all duplicates such that each element appear only once.

For example,

Given 1->1->2, return 1->2.
Given 1->1->2->3->3, return 1->2->3.

Thoughts

The key of this problem is using the right loop condition. And change what is necessary in each loop. You can use different iteration conditions like the following 2 solutions.

 

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head == null || head.next == null)
            return head;
 
        ListNode prev = head;    
        ListNode p = head.next;
 
        while(p != null){
            if(p.val == prev.val){
                prev.next = p.next;
                p = p.next;
                //no change prev
            }else{
                prev = p;
                p = p.next; 
            }
        }
 
        return head;
    }
}