java算法学习

1、无重复字符的最长子串

输入: "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

public class Solution {
    public int lengthOfLongestSubstring(String s) {
        int n = s.length();
        int res = 0;
        int end=0,start=0;
        Set<Character> set=new HashSet<>();
        while(start<n && end<n){
           if(set.contains(s.charAt(end))){
               set.remove(s.charAt(start++));
           }else{
               set.add(s.charAt(end++));
               res=Math.max(res,end-start);
           }
            
        }
        return res;
    }
 
   
}

2、简化路径

以 Unix 风格给出一个文件的绝对路径，你需要简化它。或者换句话说，将其转换为规范路径。

在 Unix 风格的文件系统中，一个点（.）表示当前目录本身；此外，两个点 （..） 表示将目录切换到上一级（指向父目录）；两者都可以是复杂相对路径的组成部分。更多信息请参阅：Linux / Unix中的绝对路径 vs 相对路径

请注意，返回的规范路径必须始终以斜杠 / 开头，并且两个目录名之间必须只有一个斜杠 /。最后一个目录名（如果存在）不能以 / 结尾。此外，规范路径必须是表示绝对路径的最短字符串。

示例 1：

输入："/home/"
输出："/home"
解释：注意，最后一个目录名后面没有斜杠。
示例 2：

输入："/../"
输出："/"
解释：从根目录向上一级是不可行的，因为根是你可以到达的最高级。
示例 3：

输入："/home//foo/"
输出："/home/foo"
解释：在规范路径中，多个连续斜杠需要用一个斜杠替换。
示例 4：

输入："/a/./b/../../c/"
输出："/c"
示例 5：

输入："/a/../../b/../c//.//"
输出："/c"
示例 6：

输入："/a//bc/d//././/.."
输出："/a/b/c"

class Solution {
     public String simplifyPath(String path) {
        Stack<String> stringStack  = new Stack<>();
        String[] arr = path.split("/");
        for(String str:arr)
        {
            if(str.equals("")||str.equals("."))
                continue;
            if(str.equals("..")) {
                if(!stringStack.empty())
                    stringStack.pop();
            }
            else
                stringStack.push(str);
        }
 
        String ans = "";
        while (!stringStack.empty())
        {
            ans="/"+stringStack.pop()+ans;
        }
        if(ans.equals(""))
            return "/";
        return ans;
    }
}

3、复原IP地址

示例:

输入: "25525511135"
输出: ["255.255.11.135", "255.255.111.35"]

思路：DFS加回溯法，找到符合条件的String分配就加入结果中

class Solution {
    List<String> res=new ArrayList<String>();
    public List<String> restoreIpAddresses(String s) {
        if(s==null||s.length()==0){
            return res;
        }
        String[] str=new String[4];//用来存放IP地址的数组，长度固定为4
        dfs(s,0,0,str,res);//DFS
        return res;
    }
    //start为当前读取到几个IP，cur为当前读取到s的哪一位
    public void dfs(String s,int start,int cur,String[] str,List<String> res){
        if(start==4&&cur==s.length()){//当读取了4个IP并且s遍历完，将结果放入res中
            String ans="";
            for(int i=0;i<4;i++){
                ans=ans+str[i]+".";
            }
            ans=ans.substring(0,ans.length()-1);
            res.add(ans);
            return;
        }
        if(start==4&&cur!=s.length()){//当读取了4个IP但s没有遍历完，则直接返回
            return;
        }
        for(int i=cur;i<cur+3&&i<s.length();i++){//每个IP最大为255,因此最长3位
            String temp=s.substring(cur,i+1);//读取IP地址
            if(Integer.valueOf(temp)<=255){
                str[start]=temp;
                dfs(s,start+1,i+1,str,res);//当前IP符合条件，DFS
                str[start]="";//回溯
            }
            //01,012,00这些IP非法
            if(temp.equals("0")){//如果当前读取到的第一位为0，则无需再读取后面的2、3位情况
                break;
            }
        }
        return;
    }
}

4、三数和

class Solution {
    public static List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> ans = new ArrayList();
        int len = nums.length;
        if(nums == null || len < 3) return ans;
        Arrays.sort(nums); // 排序 o(logn)
        for (int i = 0; i < len ; i++) {
            if(nums[i] > 0) break; // 如果当前数字大于0，则三数之和一定大于0，所以结束循环
            if(i > 0 && nums[i] == nums[i-1]) continue; // 去重
            int L = i+1;
            int R = len-1;
            while(L < R){
                int sum = nums[i] + nums[L] + nums[R];
                if(sum == 0){
                    ans.add(Arrays.asList(nums[i],nums[L],nums[R]));
                    while (L<R && nums[L] == nums[L+1]) L++; // 去重
                    while (L<R && nums[R] == nums[R-1]) R--; // 去重
                    L++;
                    R--;
                }
                else if (sum < 0) L++;
                else if (sum > 0) R--;
            }
        }        
        return ans;
    }
}

5、岛屿的最大面积

class Solution {

    public int maxAreaOfIsland(int[][] grid) {
        int maxArea = 0;
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[i].length; j++) {
                //计算最大面积
                int currMaxArea = getMaxArea(i, j, grid);
                maxArea = Math.max(currMaxArea, maxArea);
            }
        }

        return maxArea;
    }

    private int getMaxArea(int i, int j, int[][] grid) {
        if (i < 0 || i >= grid.length || j < 0 || j >= grid[0].length || grid[i][j] == 0) {
            return 0;
        }
        //通过将经过的岛屿设置为0来确保下次不会重复访问
        grid[i][j] = 0;

        int upMaxArea = getMaxArea(i - 1, j, grid);

        int downMaxArea = getMaxArea(i + 1, j, grid);

        int leftMaxArea = getMaxArea(i, j - 1, grid);

        int rightMaxArea = getMaxArea(i, j + 1, grid);

        return upMaxArea + downMaxArea + leftMaxArea + rightMaxArea + 1;
    }
}

旋转数组的最小数字

class Solution {
      
        public int minArray(int[] numbers) {
            //二分查找
           int low=0;
           int height=numbers.length-1;
           while(low<height){
               int mid=low+(height-low)/2;
                if(numbers[mid]<numbers[height]){
                    height=mid;
                }else if(numbers[mid]>numbers[height]){
                    low=mid+1;
                }else{
                    height-=1;
                }

           }
           return numbers[low];
        }

}

朋友圈：

class Solution {
   public void dfs(int[][] M, int[] visited, int i) {
        for (int j = 0; j < M.length; j++) {
            if (M[i][j] == 1 && visited[j] == 0) {
                visited[j] = 1;
                dfs(M, visited, j);
            }
        }
    }
    public int findCircleNum(int[][] M) {
        int[] visited = new int[M.length];
        int count = 0;
        for (int i = 0; i < M.length; i++) {
            if (visited[i] == 0) {
                dfs(M, visited, i);
                count++;
            }
        }
        return count;
    }

}

接雨水

class Solution {
     public int trap(int[] height) {
        int ans=0;
        for(int i=0;i<height.length;i++){

            int maxLeft=0;
            for(int l=i;l>=0;l--){
                maxLeft=Math.max(height[l],maxLeft);
            }
            int maxRight=0;
            for(int r=i;r<height.length;r++){
                maxRight=Math.max(height[r],maxRight);
            }
            
            ans+=Math.min(maxLeft,maxRight)-height[i];
        }
        return ans;
    }
}

链表反转

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {

    public ListNode reverseList(ListNode head) {//4
        if(head==null||head.next==null){
            return head;
        }
        
        ListNode node=reverseList(head.next);//5
        head.next.next=head;
        head.next=null;
        return node;
    }
}

两数相加

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
       ListNode node=new ListNode();
       int jinwei=0;
       ListNode head=node;
       while(l1!=null||l2!=null){
           int val1=l1!=null?l1.val:0;
           int val2=l2!=null?l2.val:0;
           int total=val1+val2+jinwei;
           jinwei=total/10;
           ListNode next=new ListNode();
           next.val=total%10;
           node.next=next;
           node=next;
           if(l1!=null){l1=l1.next; }
           if(l2!=null){ l2=l2.next;}
       }
        if(jinwei > 0) {
        node.next = new ListNode(jinwei);
        }
        return head.next;
    }
}