Ip ip段去重Java算法_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;

Setset=new HashSet<>();

while(start

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) {

StackstringStack = 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 {

Listres=new ArrayList();

public ListrestoreIpAddresses(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,Listres){

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

4、三数和

class Solution {

public static List> threeSum(int[] nums) {

List> 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 (L0) 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(lownumbers[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=0;l--){

maxLeft=Math.max(height[l],maxLeft);

}

int maxRight=0;

for(int r=i;r

链表反转

/**

* 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;

}

}