Leetcode题解(二)

1.binary-tree-postorder-traversal

        由题可知，本题主要求的是二叉树的后序遍历，根据二叉树后序遍历的顺序是先遍历左节点、然后遍历右节点、最后遍历根节点的顺序要求编写，代码如下：/**
* Definition for binary tree
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
import java.util.*;
public class Solution {
public ArrayList<Integer> postorderTraversal(TreeNode root) {
ArrayList<Integer> list=new ArrayList<>();
if(root==null)
return list;
postorder(root,list);
return list;

}
private static void postorder(TreeNode root,ArrayList<Integer> list)//左右根的顺序进行后续遍历,为便于递归，直接重新
{
if(root.left!=null)
postorder(root.left,list);
if(root.right!=null)
postorder(root.right,list);
list.add(root.val);
}

}

2.binary-tree-preorder-traversal

        由题目可知，该题求的是二叉树的前序遍历，前序遍历则是根据根左右的顺序进行遍历的，代码如下：/**
* Definition for binary tree
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> preorderTraversal(TreeNode root) {
ArrayList<Integer> result=new ArrayList<>();
if(root==null)
return result;
preorder(root,result);
return result;

}
private static void preorder(TreeNode root,ArrayList<Integer> list)//左右根的顺序进行后续遍历,为便于递归，直接重新
{
list.add(root.val);
if(root.left!=null)
preorder(root.left,list);
if(root.right!=null)
preorder(root.right,list);

}

}

3.reorder-list

        本题主要是的是另类的翻转链表，将后半部分翻转之后再依次插入前半部分两个结点之间即可。主要考察几个知识点，首先是寻找中间结点，从中间结点断开，分为前后两个链表，然后将后面那个链表翻转，最后将后面链表的元素根据要求插入到前面的链表中。实现代码如下：/**
* Definition for singly-linked list.
* class ListNode {
* int val;
* ListNode next;
* ListNode(int x) {
*
4000
val = x;
* next = null;
* }
* }
*/
public class Solution {
public void reorderList(ListNode head) {
ListNode pre=head;
ListNode res;
if(head==null) return;
ListNode slow=head;
ListNode fast=head;
while(fast.next!=null&&fast.next.next!=null)
{
slow=slow.next;
fast=fast.next.next;
}
res=slow.next;//后半段的头指针
slow.next=null;
ListNode temp=null;
ListNode mid;
//翻转链表
while(res!=null)
{
mid=res.next;
res.next=temp;
temp=res;
res=mid;
}
ListNode after=temp;//翻转后的链表

while(pre!=null&&after!=null)
{
ListNode node1=pre.next;
ListNode node2=after.next;
pre.next=after;
after.next=node1;
after=node2;
pre=node1;
}
}

}

4.linked-list-cycle

        这题是判断链表有没有环的问题，不占额外空间且效率比较高的算法是快慢指针的算法，即设置一个快指针一个慢指针，另快指针的速度是慢指针的两倍，然后两个指针都从头结点出发，如果两个指针最终还能相遇，则说明有环。/**
* Definition for singly-linked list.
* class ListNode {
* int val;
* ListNode next;
* ListNode(int x) {
* val = x;
* next = null;
* }
* }
*/
public class Solution {//使用快慢指针的方法来判断是否有环
public boolean hasCycle(ListNode head) {
if(head==null) return false;
ListNode fast=head;
ListNode slow=head;
while(fast.next!=null&&fast.next.next!=null)
{
fast=fast.next.next;
slow=slow.next;
if(fast==slow)
return true;
}
return false;

}

}

5.linked-list-cycle-ii

        本题在判断如果有环的基础上还需要找到环的入口，那么如下图进行计算：


        首先，快慢指针都从O点出发，假设最终在B点相遇，根据两者速度关系，应该慢指针未满一圈就会被赶上，假设快指针跑了n圈然后在B点与慢指针相遇，两者的路程关系为2*(a+b)=a+b+n*(b+c);最后化简为a=(n-1)*(b+c)+c，所以可以发现如果慢指针运动距离为a的路径，将会回到A点，那么可以将快指针变为慢指针，并从O点出发，原来的慢指针从B点同时出发，最终相遇的地点就是A点，也就是环的入口。实现代码如下：

/**
* Definition for singly-linked list.
* class ListNode {
*     int val;
*     ListNode next;
*     ListNode(int x) {
*         val = x;
*         next = null;
*     }
* }
*/
public class Solution {
public ListNode detectCycle(ListNode head) {
if(head==null)
return null;
ListNode fast=head;
ListNode slow=head;
boolean isCircle=false;
while(fast.next!=null&&fast.next.next!=null)
{
fast=fast.next.next;
slow=slow.next;
if(slow==fast)
{
isCircle=true;
break;
}
}
if(isCircle)
{
fast=head;
while(slow!=fast)
{
slow=slow.next;
fast=fast.next;
}
return slow;
}
return null;

}

}