leetcode题库第一天

从今天开始的一个月，每天都在leetcode题库或者其他地方的有关算法等其他相关的题来做，并写出有关解法的代码，可能一开始的代码都是参考他人的，但我相信不断的写应该可以最后完完全全自己想出来，可能路途遥远，不过，加油

package A;
/*
 * 给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，
 * 并且它们的每个节点只能存储 一位 数字。
如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807
 */
public class Solution_001 {
	   public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
	        ListNode root = new ListNode(0);
	        ListNode cursor = root; //指向首节点
	        int carry = 0;  
	        while(l1 != null || l2 != null || carry != 0) {
	            int l1Val = l1 != null ? l1.data : 0;  //三目运算
	            int l2Val = l2 != null ? l2.data : 0;  //三目运算
	            int sumVal = l1Val + l2Val + carry;   //carry用来计算是否进一位
	            carry = sumVal / 10;  
	            
	            ListNode sumNode = new ListNode(sumVal % 10);  
	            //创造一个节点计算出来的数用来放在sumNode然后sumVal%10是为了防止溢出
	            cursor.next = sumNode;      
	            cursor = sumNode;
	            
	            if(l1 != null) l1 = l1.next;  //用来指向下一位
	            if(l2 != null) l2 = l2.next;  //用来指向下一位
	        }
	        
	        return root.next;
	    }
}
class ListNode{
	public int data;
	public ListNode next;
	public ListNode() {
		this(0,null);
	}
	public ListNode(int data) {
		this(data,null);
	}
	public ListNode(int data,ListNode next) {
		this.data=data;
		this.next=next;
	}
}

package A;
/*
 * 给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:
输入: "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:
输入: "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。

 */
public class Solution_002 {
	public int lengthOfLongestSubstring(String s) {
		int i=1; // 用来计算有多少个重复字符串
		int count=1;
		char[] a=new char[10];  //用来将字符串转化为字符数组方便for循环的时候来判断，那个程序有毒老是报错
		for(int j=0;j<s.length();j++) {
			a[j]=(char)s.indexOf(j);  //将字符串转化为一个个字符,这里报错了
		}
		for(int j=s.length();j<0;j--) {
			for(int k=0;k<(j-1);k++) {
				if(a[k]!=a[k++]) {  //这样保证数组不越界
					count++;
				}
				if(count>i) {
					i=count;
				}
			}
		}
		return i;
    }
	public static void main(String args) {
		
	}
}

package A;
/*
给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:
输入: "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:
输入: "pwwkew"
输出: 3
 */
//2020.1.11始，2020.1.11.12：22终结解法1
/*
1、解题思路
首先考虑string长度为0和1的情况单独列出。
题目要求输出最长无重复子串的长度，可以用变量max保存长度，max初始化为1。
用i记录字串最左边位置，count2记录最右边位置，k作为循环变量遍历查找字串中是否有重复元素。
一个遍历下来，
1.若有重复值，左边位置couont1=k+1，右边位置count2++；
2.若无重复值，左边位置i不变，右边位置count2++；
计算新字串长度（count2-1），并与max比较，得到新的最大长度。
 */
/*
 *2、 执行结果：
通过
显示详情 
执行用时 :2 ms 在所有 Java 提交中击败了100.00%的用户
内存消耗 :36.7 MB, 在所有 Java 提交中击败了96.47%的用户
 */
/*3、总结：没有考虑到各种情况
 * 基础真的不牢固
 * 
 * */

public class Solution_003 {
	/*
	 * 算法一:从第一个开始判断，判断出一个最长，依次判断第二个，如若第二个组合起来的更长则第二个覆盖
	 * 第一个，一此类推，*/
public int lengthOfLongestSubstring(String s) {

		//将字符串输入进来，并创建与之对应长度的数组
		char [] strArr1 = s.toCharArray(); 
		//上面是将字符串转化为字符串数组,注意返回值是char数组 
		int count1=0,count2=1,count3=1,k;
		while(count2 < s.length())
        {
            for(k = count1;k <count2;k++)
            {
                if(strArr1[k] == strArr1[count2])
                {
                    count1 = k + 1;
                    break;
                }
            }
            count2++;
            if(count2-count1 > count3)
                count3 = count2-count1;
        }
		if(s.length()==0) 
				return 0;
		if(s.length()==1) 
			return 1;
		return count3; 	
    }

}

/*给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
示例 1:
输入: 123
输出: 321
 示例 2:
输入: -123
输出: -321
示例 3:
输入: 120
输出: 21
注意:
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231,  231 − 1]。
请根据这个假设，如果反转后整数溢出那么就返回 0。
 */
package A;
import java.util.*;
public class Solution_007 {
	 public static int reverse(int x) {
			        long n = 0;
			        while(x != 0) {
			            n = n*10 + x%10;//可以用这种思路来将x分解一个个数字
			            x = x/10;
			        }
			        return (int)n==n? (int)n:0;
			    }
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		System.out.print(reverse(n));
	}
}

package A;
/*
 * 请你来实现一个 atoi 函数，使其能将字符串转换成整数。
首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。当我们寻找到的第
一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字组合起来，作为该整数的正负号；假
如第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成整数。该字符串除了有效的整数
部分之后也可能会存在多余的字符，这些字符可以被忽略，它们对于函数不应该造成影响。注意：假如该字符
串中的第一个非空格字符不是一个有效整数字符、字符串为空或字符串仅包含空白字符时，则你的函数不需要
进行转换。在任何情况下，若函数不能进行有效的转换时，请返回 0。
说明：
假设我们的环境只能存储 32 位大小的有符号整数，那么其数值范围为 [−231,  231 − 1]。
如果数值超过这个范围，请返回  INT_MAX (231 − 1) 或 INT_MIN (−231) 。
示例 1:
输入: "42"
输出: 42
示例 2:
输入: "   -42"
输出: -42
解释: 第一个非空白字符为 '-', 它是一个负号。
     我们尽可能将负号与后面所有连续出现的数字组合起来，最后得到 -42 。
示例 3:
输入: "4193 with words"
输出: 4193
解释: 转换截止于数字 '3' ，因为它的下一个字符不为数字。
示例 4:
输入: "words and 987"
输出: 0
解释: 第一个非空字符是 'w', 但它不是数字或正、负号。
     因此无法执行有效的转换。
示例 5:
输入: "-91283472332"
输出: -2147483648
解释: 数字 "-91283472332" 超过 32 位有符号整数范围。 
     因此返回 INT_MIN (−231) 
 */
public class Solution_008 {
	 public static int myAtoi(String str) {
	    	long res = 0;
	        boolean flag = true;
	        int f = -1;
	        char[] c = str.toCharArray();
	        for(int i = 0; i<c.length;i++) {            
	        	if(f==-1 && (c[i]=='-' || c[i]=='+') ) {
	        		flag = c[i]=='-'?false:true;
	                f = 1;
	        	}else if(Character.isDigit(c[i])) {//判断是否为数字
	        		res = res*10 + (c[i]-'0');
	                if(res>Integer.MAX_VALUE){
	                    if(!flag) return  Integer.MIN_VALUE;
	                    return Integer.MAX_VALUE;
	                }//防止越界
	                f = 1;
	        	}else if(c[i]>30 ){
	                if(f==-1 && c[i]==' ') continue;
	                break;
	            }
	        }
	        return flag == true?(int)res:(int)-res;
	    }
	 public static void main(String[] args) {
		 String m="-42";
		 System.out.println(myAtoi(m));
	 }
}