LeetCode 刷题记录 1；Java代码；

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

暴力破解法

class Solution {
    public int[] twoSum(int[] nums, int target) {
        boolean b = true;//得到答案就返回，题目交代了答案的唯一性
        int result1 = 0;//记录结果下标1顺便参与对比
        int result2 = 0;//记录结果下标2
        for(int i = 0;i < nums.length&&b;i++){
            result1 = target - nums[i];
            for(int j=0;j<nums.length;j++){
                if(i == j)
                    continue;答案下标相等时返回跳过；
                if(nums[j] == result1){
                    b = false;
                    result2 = j;
                    result1 = i;
                    break;
                }
                    
            }
            
        }
        int[] result = {result1,result2};
        return result;
    }
}

第二题

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

翻译为：给你两个链表，链表储存的数据表示一个数，从头到尾即为从个位到最高位，返回一个新的链表，新的链表表示的数字为传入的两个链表表示的数字的和（有进位的）

public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode head = null, tail = null;
        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 (head == null) {
                head = tail = new ListNode(sum % 10);
            } else {
                tail.next = new ListNode(sum % 10);
                tail = tail.next;
            }
            carry = sum / 10;
            if (l1 != null) {
                l1 = l1.next;
            }
            if (l2 != null) {
                l2 = l2.next;
            }
        }
        if (carry > 0) {
            tail.next = new ListNode(carry);
            System.out.println("tail:"+tail.val);
        }
        return head;
    }

记录关键点：

链表的遍历赋值，用head保存头结点之后用tail遍历赋值链表，

tail.next = new ListNode(sum % 10);
tail = tail.next;

虽然tail被覆盖，但是tail的对象值被保存再head.next.next........之中；

注意：l1与l2长度相等的时候，得到的结果最后一位可能需要进位，但此时循环已经结束，另外需要手动添加结果的最后一位进位，即判断进位是否为0，为零则结束返回，不为零则进位再天极爱一个节点

26.给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

 

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
int len = removeDuplicates(nums);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

跳出思维定式：即我们得到的结果并不是被删除了元素的数组，因为空间复杂度只能为O（1），所以无法修剪原来的数组，但是由于检查AC的机制依赖返回的长度，所以可以把数组的前面几位替换为被修剪好的数组，来达到一样的效果

class Solution {
    public int removeDuplicates(int[] nums) {
        int i = 0,j = 0;//i遍历输入的nums，j给我们需要显示的前半部分数组赋值
        
        while(i < nums.length){

            if(nums[i] != nums[j]){
                nums[j+1]=nums[i];
                j++;
                
            }

            i++;

        }
        return j+1;
    }
}