力扣前五题

//for循环的解决方法
class Solution {
    public int[] twoSum(int[] nums, int target) {
        for(int i = 0; i < nums.length - 1; i++){
            for(int j = i + 1; j < nums.length - 1; j++){
                if(nums[i] + nums[j] == target){
                    return new int[]{i,j};
                }
            }
        }
        return new int[0];
    }
}

//哈希表
class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer,Integer> hashtable = new HashMap<>();
        //忘了加上=号
        for(int i = 0; i <= nums.length - 1; i++){
            //注意方法后面大小写，有时候写错了、、、、、、
            if(hashtable.containsKey(target - nums[i])){
                return new int[]{hashtable.get(target - nums[i]), i};
            }
            hashtable.put(nums[i], i);
        }
        return new int[0];
    }
}

哈希表的作用其实主要还是应用在保存两种变量的时候。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
 //两个链表相加得到一个新的链表，而且是一个有头节点的。
 //所以就要先定义一个头节点，再弄一个辅助指针。也就是头节点先指向辅助指针，然后辅助指针继续创造节点。
 //选一个两个数中的一个进行赋值，用三目运算符。
 //小技巧：对于链表问题，返回结果为头结点时，通常需要先初始化一个预先指针 pre，该指针的下一个节点指向真正的头结点head。使用预先指针的目的在于链表初始化时无可用节点值，而且链表构造过程需要指针移动，进而会导致头指针丢失，无法返回结果。
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode pre = new ListNode(0); 
        ListNode cur = pre;
        int carry = 0;
        while (l1 != null || l2 != null){
            int n1 = l1 != null ? l1.val : 0;
            int n2 = l2 != null ? l2.val : 0;
            int sum = n1 + n2 + carry;
            // if (pre == null){
            //     //head = new ListNode(sum % 10);
            //     tail = new ListNode(sum % 10);
            //     head = tail;
            // } else {
            cur.next = new ListNode(sum % 10);
            cur = cur.next;
            // }
            carry = sum / 10;
            if (l1 != null){
                //这边的等于理解成指向的意思，怕忘记标注一下。
                l1 = l1.next; 
            }
            if (l2 != null){
                l2 = l2.next;
            }
        }
        if (carry > 0){
            cur.next = new ListNode(carry);
            //tail = tail.next;
        }
        return pre.next;
    }
}

 节点是前节点指向后节点，并非赋值啊。

class Solution {
    public int lengthOfLongestSubstring(String s) {
        if (s == null) return 0;
        HashMap<Character,Integer> map = new HashMap<>();
        int left = 0;
        int max = 0;
        //length()需要加上括号
        for (int i = 0; i <= s.length() - 1; i++) {
            if(map.containsKey(s.charAt(i))){
                //是map中的字符！！！一直想怎么定位到重复字符出现的第一次的位置
                left = Math.max(left ,map.get(s.charAt(i)) + 1);
            }
            map.put(s.charAt(i),i);
            max = Math.max(max ,i - left + 1);
        }
        return max;
    }
}

 和第一题应用的hashmap比较类似

这个题目是滑动窗口。将字符串挨个往hashmap中放置，直至放置完全，拿出所求的最大的值。好好理解一下，怎么回到最开始重复字符串出现的位置。

 

//暴力求解，列举所有的子串，判断是否为回文串，保存最长的回文串。
class Solution {
    public boolean isPalindromic(String s) {
		int len = s.length();
        //重点理解这边找对称的字符串，还有就是，把写法从<=x -1，改成< x吧。
		for (int i = 0; i < len / 2; i++) {
			if (s.charAt(i) != s.charAt(len - i - 1)) {
				return false;
			}
		}
		return true;
	}
    public String longestPalindrome(String s) {
        String ans = "";
        int max = 0;
        int len = s.length();
        for (int i = 0; i < len; i++)
            for (int j = i + 1; j <= len; j++) {
                String test = s.substring(i, j);
                if (isPalindromic(test) && test.length() > max) {
                    ans = s.substring(i, j);
                    max = Math.max(max, ans.length());
                }
            }
        return ans;
    }
}

 

class Solution {
    public String convert(String s, int numRows) {
        if(numRows == 1) return s;
        List<StringBuilder> rows = new ArrayList<>();
        for(int i = 0; i < numRows; i++){
            rows.add(new StringBuilder());
        } 
        int curRow = 0;
        boolean goingDown = false;
        for(char x : s.toCharArray()){
            rows.get(curRow).append(x);
    //这边吊炸天，直接就是0.1.2..行数轮回给值，然后ArrayList集合中的泛型才设置成StringBuilder。
            if(curRow == 0 || curRow == numRows - 1) goingDown = !goingDown;
            curRow = goingDown ? curRow + 1 : curRow - 1;
        }
        StringBuilder res = new StringBuilder();
        for (StringBuilder x : rows) res.append(x);
        return res.toString();
    }
}