LeetCode 92反转链表Ⅱ&93复制ip地址&94二叉树的中序遍历

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseBetween(ListNode head, int m, int n) {
        ListNode value=new ListNode(0);//头节点
    value.next=head;
    ListNode team=value;//临时节点
    int index=1;//记录标记
    while (index<m) {
      team=team.next;
      index++;
    }
    //team 后面需要头插
    ListNode tail=team.next;//m节点，最后会在最后
    ListNode node=team.next;
    while (index<=n) {
      ListNode nextNode=node.next;//先储存右侧节点
      node.next=team.next;//插入第一步。将自己右侧指向
      team.next=node;//插入第二步，前面team指过来
      node=nextNode;
            index++;
    }
    tail.next=node; //逆置的链表和后面节点连接
    return value.next;
    }
}

class Solution {
  public List<String> restoreIpAddresses(String s) {
    List<String>list=new ArrayList<String>();
    List<String>value=new ArrayList<String>();
    char ch[]=s.toCharArray();
    dfs(value,list,ch,0,0);
    return value;
    }
  private void dfs(List<String> value, List<String> list, char[] ch, int index, int num) {
    // TODO Auto-generated method stub
    if(num==4&&index==ch.length)
    {
      StringBuilder sBuilder=new StringBuilder();
      sBuilder.append(list.get(0));
      for(int i=1;i<4;i++)
      {
        sBuilder.append('.');
        sBuilder.append(list.get(i));
      }
      value.add(sBuilder.toString());
    }
    else if(num==4||index>=ch.length) return;
    else {
      if((4-num)*3<ch.length-index-1||ch.length-index<4-num)//剩下的已经不可能
      {
        return;
      }
      else if (ch[index]=='0') {
        list.add("0");
        dfs(value, list, ch, index+1, num+1);
                list.remove(list.size()-1);
      }
      else {
        StringBuilder sBuilder=new StringBuilder();
        for(int i=0;i<3&&index+i<ch.length;i++)
        {
          sBuilder.append(ch[index+i]);
          if(i==2&&Integer.parseInt(sBuilder.toString())>255)
            return;
          list.add(sBuilder.toString());
          dfs(value, list, ch, index+i+1, num+1);
          list.remove(list.size()-1);
        }
      }
    }
  }
}

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
   public List<Integer> inorderTraversal(TreeNode root) {
    List<Integer>value=new ArrayList<Integer>();
    dfs(root,value);
    return value;
  }
   private void dfs(TreeNode root, List<Integer> value) {
    // TODO Auto-generated method stub
     if(root==null)
       return;
     dfs(root.left, value);
     value.add(root.val);
     dfs(root.right, value);  
  }
}