leetcode（1-5）

public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] nums = { 2, 7, 11, 15 };
		int target = 9;
		System.out.println(twoSum(nums, target)[0] + " " + twoSum(nums, target)[1]);
		System.out.println("-----------------------------");
		ListNode l2 = new ListNode(2);
		ListNode l4 = new ListNode(4);
		ListNode l3 = new ListNode(3);
		ListNode l5 = new ListNode(5);
		ListNode l6 = new ListNode(6);
		ListNode l7 = new ListNode(4);

		l2.next = l4;
		l4.next = l3;

		l5.next = l6;
		l6.next = l7;

		Solution solution = new Solution();
		solution.addTwoNumbers(l2, l5);
		System.out.println("------------------");
		System.out.println(new Solution1().lengthOfLongestSubstring("abcabcbb"));
		System.out.println("----------------------");
		int[] nums1 = { 1, 3 };
		int[] nums2 = { 2 };
		System.out.println(new Solution2().findMedianSortedArrays(nums1, nums2));
		System.out.println("---------------------------");
		System.out.println(new Solution3().longestPalindrome("babad"));

	}

/*
 * 
 * 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
 * 你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。 示例: 给定 nums = [2, 7, 11, 15], target
 * = 9
 * 
 * 因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1] 来源：力扣（LeetCode）
 * 链接：https://leetcode-cn.com/problems/two-sum
 * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 */
// 两数之和

public static int[] twoSum(int[] nums, int target) {
		int length = nums.length;
		int[] sums = new int[2];
		for (int i = 0; i < length - 1; i++) {
			for (int j = 0; j < length; j++) {
				if (i != j) {
					if (target == nums[i] + nums[j]) {
						sums[0] = i;
						sums[1] = j;
						return sums;
					}

				}
			}
		}
		return sums;
	}
}

/*

• 给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
• 如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
• 您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
• 示例：
• 输入：(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出：7 -> 0 -> 8 原因：342 + 465 = 807
• 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/add-two-numbers
• 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
  */
  // 两数相加

// Definition for singly-linked list.

class ListNode {
	int val;
	ListNode next;
	ListNode(int x) {
		val = x;
		}
	}
	class Solution {
	public ListNode root = null;
	public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
		int length = linksize(l1);
		int[] l1arrr = new int[length];
		int[] l2arrr = new int[length];
		int i = 0;
		int sum = 0;
		while (l1 != null && l2 != null) {
			l1arrr[i] = l1.val;
			l2arrr[i] = l2.val;
			i++;
			l1 = l1.next;
			l2 = l2.next;
		}
		sum = sum(l1arrr) + sum(l2arrr);
		String str = String.valueOf(sum);
		char[] in = str.toCharArray();
		ListNode listNode;
		for (int k = in.length - 1; k > -1; k--) {
			listNode = new ListNode(in[k]);
			insert(listNode);
		}
		return root;

	}

	public static int linksize(ListNode l1) {
		int lenght = 0;
		while (l1 != null) {
			l1 = l1.next;
			lenght++;
		}
		return lenght;
	}

	public static int sum(int[] arr) {
		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i] * Math.pow(10, arr.length - 1 - i);
		}
		return sum;
	}

	public void insert(ListNode node) {
		if (root == null) {
			root = node;
		} else {
			ListNode parent = root;
			while (parent.next != null) {
				parent = parent.next;
			}
			parent.next = node;

		}
	}
}

//给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
/*

• 给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
• 示例 1:
• 输入: “abcabcbb” 输出: 3 解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。 示例 2:
• 输入: “bbbbb” 输出: 1 解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。 示例 3:
• 输入: “pwwkew” 输出: 3 解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。 请注意，你的答案必须是 子串
• 的长度，“pwke” 是一个子序列，不是子串。
• 来源：力扣（LeetCode）
• 链接：https://leetcode-cn.com/problems/longest-substring-without-repeating-
• characters 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
  */
  //滑动窗口法

class Solution1 {
	public int lengthOfLongestSubstring(String s) {
		int[] middle = new int[200];
		int length = s.length();
		int max = 0;
		int front = 0;
		int after = 0;
		while (front < length && after < length) {
			if (middle[s.charAt(front)] == 0) {
				middle[s.charAt(front)] = 1;
				front++;
				max = Math.max(max, Math.abs(front - after));
			} else {
				middle[s.charAt(after)] = 0;
				after++;
			}
		}
		return max;

	}
}

//寻找两个有序数组的中位数
/*
*

• 给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。
• 请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。
• 你可以假设 nums1 和 nums2 不会同时为空。
• 示例 1:
• nums1 = [1, 3] nums2 = [2]
• 则中位数是 2.0 示例 2:
• nums1 = [1, 2] nums2 = [3, 4]
• 则中位数是 (2 + 3)/2 = 2.5
• 来源：力扣（LeetCode）
• 链接：https://leetcode-cn.com/problems/median-of-two-sorted-arrays
• 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
  */

class Solution2 {
	public double findMedianSortedArrays(int[] nums1, int[] nums2) {
		double middle = 0;
		int length1 = nums1.length;
		int lenght2 = nums2.length;
		int arr[] = new int[nums1.length + nums2.length];
		for (int i = 0; i < arr.length; i++) {
			if (i < length1)
				arr[i] = nums1[i];
			else
				arr[i] = nums2[i - length1];
		}
		Arrays.sort(arr);
		if (arr.length % 2 == 0)
			middle = (double) (arr[arr.length / 2] + arr[arr.length / 2 - 1]) / 2;
		else
			middle = arr[arr.length / 2];
		return middle;

	}
}

//最长回文子串
/*

• 给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
• 示例 1：
• 输入: “babad” 输出: “bab” 注意: “aba” 也是一个有效答案。 示例 2：
• 输入: “cbbd” 输出: “bb”
• 来源：力扣（LeetCode）
• 链接：https://leetcode-cn.com/problems/longest-palindromic-substring
• 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
  */

class Solution3 {
	String sub = "";
	int max = 0;
	public String longestPalindrome(String s) {
		if (s.length() <= 1)
			return s;
		for (int i = 0; i < s.length() - 1; i++) {
			findLong(s, i, i);
			findLong(s, i + 1, i);
		}
		return sub;

	}

	// 核心思想从中心往两边找，对每一条数据进行两边查找
	public void findLong(String str, int height, int low) {
		while (height < str.length() && low >= 0) {
			if (str.charAt(height) == str.charAt(low)) {
				if (max < height + 1 - low) {
					max = height + 1 - low;
					sub = str.substring(low, height + 1);
				}
				height++;
				low--;
			} else
				break;
		}
	}