个人基础算法训练

tip:题目来自  https://leetcode-cn.com/problemset/algorithms/

给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。

你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

public static int[] twoSum(int[] nums, int target) {
        int[] ret = new int[2];
        boolean flag = true;
        for (int i = 0; i < nums.length; i++) {
            if (flag) {
                ret[0] = nums[i];
                for (int k = 0; k < nums.length; k++) {
                    if (i == k) {
                        continue;
                    }
                    if (target == nums[i] + nums[k]) {
                        ret[1] = nums[k];
                        flag = false;
                        break;
                    }
                }
            }
        }
        return ret;
    }

　　

给定 nums = [3,2,2,3], val = 3,

函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。

你不需要考虑数组中超出新长度后面的元素。

1.利用set特性

 public static int duplicateRemoval(int[] nums) {
        Set<Integer> set = new HashSet<Integer>();
        int[] ret = null;
        int retIndex = 0;
        for (int i = 0; i < nums.length; i++) {
            if (set.contains(nums[i])) {
                continue;
            }
            set.add(nums[i]);
        }return set.size();
    }

 2.双指针

public int removeElement(int[] nums, int val) {
    int i = 0;
    for (int j = 0; j < nums.length; j++) {
        if (nums[j] != val) {
            nums[i] = nums[j];
            i++;
        }
    }
    return i;
}

 

给定两个非空链表来表示两个非负整数。位数按照逆序方式存储，它们的每个节点只存储单个数字。将两数相加返回一个新的链表。

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

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

public static class ListNode {
        int val;
        ListNode next;

        ListNode(int x) {
            val = x;
        }

        boolean hasNext() {
            return next != null;
        }

        public static ListNode reverse1(ListNode head) {
            ListNode temp = head;
            ListNode prev = null;
            while (temp != null) {
                ListNode next = temp.next;
                temp.next = prev;
                prev = temp;
                temp = next;
            }
            return prev;
        }

        public static int parseNode2Int(ListNode source) {
            StringBuffer sb = new StringBuffer();
            ListNode temp = source;
            while (temp != null) {
                sb.append(temp.val);
                temp = temp.next;
            }
            return Integer.parseInt(sb.toString());
        }

        public static ListNode string2ListNode(String source) {
            char[] strArray = source.toCharArray();
            boolean flag = true;
            int i = 0;
            ListNode prev = null;
            ListNode ret = null;
            ListNode temp = null;
            while (flag) {
                char c = strArray[i];
                Integer val = Integer.parseInt(Character.toString(c));
                if (i == 0) {
                    ret = new ListNode(val);
                    prev = ret;
                } else {
                    temp = new ListNode(val);
                    prev.next = temp;
                    prev = temp;
                }
                i++;
                if (i == strArray.length) {
                    flag = false;
                }
            }
            return ret;
        }
    }


    public static ListNode addTwoLinkTableReverse(ListNode l1, ListNode l2) {
        ListNode rel1 = ListNode.reverse1(l1);
        ListNode rel2 = ListNode.reverse1(l2);
        int re1Int = ListNode.parseNode2Int(rel1);
        int re2Int = ListNode.parseNode2Int(rel2);
        int total = re1Int + re2Int;
        ListNode retNode = ListNode.string2ListNode(total + "");
        return retNode;
    }

    public static void main(String[] args) {
        ListNode listNode1 = new ListNode(2);
        ListNode listNode11 = new ListNode(4);
        ListNode listNode12 = new ListNode(3);
        listNode1.next = listNode11;
        listNode11.next = listNode12;

        ListNode listNode2 = new ListNode(2);
        ListNode listNode21 = new ListNode(3);
        ListNode listNode22 = new ListNode(4);
        listNode2.next = listNode11;
        listNode21.next = listNode22;

        ListNode result = addTwoLinkTableReverse(listNode1, listNode2);

        ListNode reverseResult = ListNode.reverse1(result);

    }