//数组
//实现一个支持动态扩容的数组
//实现一个大小固定的有序数组,支持动态增删改操作
//实现两个有序数组合并为一个有序数组
//学习哈希表思想,并完成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;
}
}