Datawhale编程【任务1 - 数组与链表】

//数组
//实现一个支持动态扩容的数组
//实现一个大小固定的有序数组，支持动态增删改操作
//实现两个有序数组合并为一个有序数组
//学习哈希表思想，并完成leetcode上的两数之和(1)及Happy  Number(202)！
//(要求全部用哈希思想实现！)（选做）（注意：在第四天会进行继续学习）

package arrayTask;

import java.util.Arrays;

//数组
//实现一个大小固定的有序数组，支持动态增删改操作
public class Array2 {

	private static int find(int[] arr, int val) {
		if (arr == null)
			return -1;
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] == val)
				return i;
		}
		return -1;
	}

	private static void del(int[] arr, int val) {
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] == val) {
				arr[i] = 0;
			}
		}
		Arrays.sort(arr);
	}

	private static void insert(int[] arr, int val) {
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] == 0) {
				arr[i] = val;
				break;
			}
		}
		Arrays.sort(arr);
	}

	private static void modifiy(int[] arr, int val, int replaceVal) {
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] == val) {
				arr[i] = replaceVal;
				break;
			}
		}
	}

	private static void printArr(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + ",");
		}
		System.out.println();
	}

	public static void main(String[] args) {
		int[] arr = { 1, 2, 3, 4, 5, 6, 7 };
		printArr(arr);
		find(arr, 4);
		printArr(arr);
		del(arr, 4);
		printArr(arr);
		insert(arr, 4);
		printArr(arr);
		modifiy(arr, 4, 5);
		printArr(arr);
	}
}

 

package arrayTask;

import java.util.Arrays;

//数组
//实现两个有序数组合并为一个有序数组
public class Array3 {

	private static int[] merge1(int[] arr1, int[] arr2) {
		if (arr1 == null || arr1.length < 1 || arr2 == null || arr2.length < 1)
			return new int[1];
		int[] merge = new int[arr1.length + arr2.length];
		for (int i = 0; i < merge.length; i++) {
			if (i >= 0 && i < arr1.length)
				merge[i] = arr1[i];
			else
				merge[i] = arr2[i - arr1.length];
		}
		Arrays.sort(merge);
		return merge;
	}

	private static int[] merge2(int[] arr1, int[] arr2) {
		if (arr1 == null || arr1.length < 1 || arr2 == null || arr2.length < 1)
			return new int[1];
		int[] merge = new int[arr1.length + arr2.length];
		int p1 = 0, p2 = 0;
		for (int i = 0; i < merge.length; i++) {
			if (p1 == arr1.length) {
				merge[i] = arr2[p2];
				p2++;
			} else if (p2 == arr2.length) {
				merge[i] = arr1[p1];
				p1++;
			} else {
				if (arr1[p1] <= arr2[p2]) {
					merge[i] = arr1[p1];
					p1++;
				} else {
					merge[i] = arr2[p2];
					p2++;
				}
			}
		}
		return merge;
	}

	private static void printArr(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + ",");
		}
		System.out.println();
	}

	public static void main(String[] args) {
		int[] arr1 = { 1, 2, 3, 4, 5, 6, 7 };
		int[] arr2 = { 3, 4, 5, 6, 7, 8, 9 };
		printArr(merge1(arr1, arr2));
		printArr(merge2(arr1, arr2));
	}
}

//链表//实现单链表、循环链表、双向链表，支持增删操作
//实现单链表反转
//实现两个有序的链表合并为一个有序链表
//实现求链表的中间结点

package listTask;

//链表
//实现单链表、循环链表、双向链表，支持增删操作
public class List1 {
	// 插入操作, 在node节点后面插入一个 addNode节点
	public static void addListNode(ListNode head, ListNode node, ListNode addNode) {
		ListNode curNode = head;
		while (curNode != null) {
			if (curNode == node) {
				if (curNode.next != null) {
					ListNode nextNode = curNode.next;
					curNode.next = addNode;
					addNode.next = nextNode;
				} else {
					curNode.next = addNode;
				}
			}
			curNode = curNode.next;
		}
	}

	// 删除操作
	public static ListNode delListNode(ListNode head, ListNode delNode) {
		// 删除节点，删除的是头节点，新的头节点即原头节点的下一个节点；
		// 删除的不是头节点，pre指向cur的next的节点
		if (head == null || delNode == null)
			return null;
		if (head == delNode) {
			if (head.next != null)
				head = head.next;
			else
				head = null;
		} else {
			ListNode preNode = head;
			ListNode curNode = head.next;
			while (curNode != null) {
				if (curNode == delNode) {
					curNode = curNode.next;
					preNode.next = curNode;
					break;
				}
				preNode = preNode.next;
				curNode = curNode.next;
			}
			if (curNode == null)
				return null;
		}
		return head;
	}

	// 输出链表中的值
	public static void printListNode(ListNode head) {
		ListNode node = head;
		while (node != null) {
			System.out.print(node.val);
			node = node.next;
		}
	}

	public static void main(String[] args) {
		ListNode node1 = new ListNode(1);
		ListNode node2 = new ListNode(2);
		ListNode node3 = new ListNode(3);
		ListNode node4 = new ListNode(4);
		ListNode node5 = new ListNode(4);
		node1.next = node2;
		node2.next = node3;
		node3.next = node4;

		printListNode(node1);
		System.out.println();
		System.out.println(delListNode(node1, node3).val);
		printListNode(node1);
		System.out.println();
		addListNode(node1, node2, node3);
		printListNode(node1);
	}
}

package listTask;

//链表
//实现单链表反转
//实现两个有序的链表合并为一个有序链表
//实现求链表的中间结点
public class List2 {

	public static void printList(ListNode head) {
		while (head != null) {
			System.out.print(head.val + "->");
			head = head.next;
		}
		System.out.println("null");
	}

	static ListNode revNodeList(ListNode n1) {
		if (n1 == null)
			return null;
		ListNode preNode = null;
		ListNode curNode = n1;
		ListNode nextNode = null;
		while (curNode != null) {
			nextNode = curNode.next;
			if (nextNode == null) {
				// 尾节点要指定前面，否则链表断开
				curNode.next = preNode;
				return curNode;
			}
			// 只处理当前节点，不用处理nextNode节点，避免链表指向出错
			curNode.next = preNode;
			// 指针前移
			preNode = curNode;
			curNode = nextNode;
		}
		return curNode;
	}

	public static void main(String[] args) {
		ListNode head = new ListNode();
		head.val = 1;
		head.next = new ListNode();
		head.next.val = 2;
		head.next.next = new ListNode();
		head.next.next.val = 3;
		head.next.next.next = new ListNode();
		head.next.next.next.val = 4;
		head.next.next.next.next = new ListNode();
		head.next.next.next.next.val = 5;
		head.next.next.next.next.next = new ListNode();
		head.next.next.next.next.next.val = 6;
		head.next.next.next.next.next.next = new ListNode();
		head.next.next.next.next.next.next.val = 7;
		head.next.next.next.next.next.next.next = new ListNode();
		head.next.next.next.next.next.next.next.val = 8;
		head.next.next.next.next.next.next.next.next = new ListNode();
		head.next.next.next.next.next.next.next.next.val = 9;
		printList(head);
		head = revNodeList(head);
		printList(head);
		head = revNodeList(head);
		printList(head);
	}

}

package listTask;

//链表
//实现两个有序的链表合并为一个有序链表
public class List3 {
	private static void printList(ListNode head) {
		while (head != null) {
			System.out.print(head.val + ",");
			head = head.next;
		}
	}

	private static ListNode merge(ListNode head1, ListNode head2) {
		if (head1 == null)
			return head2;
		if (head2 == null)
			return head1;
		ListNode mergeListNode = null;
		if (head1.val < head2.val) {
			mergeListNode = head1;
			head1.next = merge(head1.next, head2);
		} else {
			mergeListNode = head2;
			head2.next = merge(head1, head2.next);
		}
		return mergeListNode;
	}

	public static void main(String[] args) {
		ListNode head = new ListNode();
		head.val = 1;
		head.next = new ListNode();
		head.next.val = 2;
		head.next.next = new ListNode();
		head.next.next.val = 3;
		head.next.next.next = new ListNode();
		head.next.next.next.val = 4;
		head.next.next.next.next = new ListNode();
		head.next.next.next.next.val = 5;
		ListNode head2 = new ListNode();
		head2.val = 1;
		head2.next = new ListNode();
		head2.next.val = 3;
		head2.next.next = new ListNode();
		head2.next.next.val = 5;
		head2.next.next.next = new ListNode();
		head2.next.next.next.val = 6;
		head2.next.next.next.next = new ListNode();
		head2.next.next.next.next.val = 7;
		head = merge(head, head2);
		printList(head);
	}

}

对应的 LeetCode 练习题

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        if (nums == null || nums.length < 1)
            return result;
        // 先排序
        Arrays.sort(nums);
        for (int i = 0; i <= nums.length - 1; i++) {
            if (nums[i] > 0) 
                break;
            if (i > 0 && nums[i] == nums[i-1])
                continue;
            int target = 0 - nums[i];
            // 前后指针扫描
            int k = i + 1;
            int j = nums.length - 1;
            while (k < j) {
                if (nums[k] + nums[j] == target) {
                    List<Integer> list = Arrays.asList(nums[i],nums[k],nums[j]);
                    result.add(list);
                    // 跳过重复
                    while ( k < j && nums[k] == nums[k+1])
                        k++;
                    while ( k < j && nums[j] == nums[j-1])
                        j--;
                    k++;
                    j--;
                } else if (nums[k] + nums[j] < target)
                    k++;
                else
                    j--;
            }
        }
        return result;
    }
}