diff --git a/.idea/compiler.xml b/.idea/compiler.xml index ab52643..8944a20 100644 --- a/.idea/compiler.xml +++ b/.idea/compiler.xml @@ -6,10 +6,13 @@ - + + + + diff --git a/.idea/modules.xml b/.idea/modules.xml index 9dde46f..8424352 100644 --- a/.idea/modules.xml +++ b/.idea/modules.xml @@ -2,6 +2,7 @@ + @@ -289,6 +290,7 @@ + diff --git a/.idea/workspace.xml b/.idea/workspace.xml index 4b16f3e..036877e 100644 --- a/.idea/workspace.xml +++ b/.idea/workspace.xml @@ -2,16 +2,13 @@ - - - - - - - - - + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + - - - - - - - - + + + - - - - - - - + + + - - - - - + + + - - - + + + - - - + + + - - - - - - - - + + + - - - + + + - - - - + diff --git a/Greedy algorithm/Greedy algorithm.iml b/Greedy algorithm/Greedy algorithm.iml new file mode 100644 index 0000000..8d8ffd9 --- /dev/null +++ b/Greedy algorithm/Greedy algorithm.iml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Greedy algorithm/pom.xml b/Greedy algorithm/pom.xml new file mode 100644 index 0000000..4825cac --- /dev/null +++ b/Greedy algorithm/pom.xml @@ -0,0 +1,15 @@ + + + + leetcode + wjc.leetcode + 1.0-SNAPSHOT + + 4.0.0 + + Greedy algorithm + + + diff --git a/Greedy algorithm/src/main/java/com/jianglai/greedy/algorithm/BubbleSort.java b/Greedy algorithm/src/main/java/com/jianglai/greedy/algorithm/BubbleSort.java new file mode 100644 index 0000000..5ffdbdd --- /dev/null +++ b/Greedy algorithm/src/main/java/com/jianglai/greedy/algorithm/BubbleSort.java @@ -0,0 +1,67 @@ +package com.jianglai.greedy.algorithm; + +import java.util.ArrayList; +import java.util.Scanner; + +/** + * @author leon + * @ClassName BubbleSort.java + * @createTime 2021年01月19日 20:12:00 + * @Decription: 冒泡排序 + * + */ +public class BubbleSort { + + public static void main(String[] args) { + System.out.println("请输入数据："); + Scanner scanner = new Scanner(System.in); + // 转换为数组列表 + ArrayList dataArrayList = getDataArrayList(scanner); + System.out.println("你输入的数据是："+dataArrayList.toString()); + // 冒泡排序 + sortByBubbleSort(dataArrayList); + System.out.println("排序后："+dataArrayList.toString()); + } + + /** + * 冒泡排序 + * @param dataArrayList + */ + private static void sortByBubbleSort(ArrayList dataArrayList) { + for(int i=dataArrayList.size()-2; i>=0; i--){ + for(int j=0; j dataArrayList.get(j+1)){ + swap(dataArrayList, j, j+1); + } + } + } + } + + /** + * 置换位置 + * @param dataArrayList + * @param left + * @param right + */ + private static void swap(ArrayList dataArrayList, int left, int right) { + int tmp = dataArrayList.get(right); + dataArrayList.set(right, dataArrayList.get(left)); + dataArrayList.set(left, tmp); + } + + /** + * 获取数据的ArrayList + * @param scanner + * @return + */ + private static ArrayList getDataArrayList(Scanner scanner) { + ArrayList dataArrayList = new ArrayList(); + if(scanner.hasNext()){ + String[] str = scanner.nextLine().split(" "); + for(int i = 0; i < str.length; i++){ + dataArrayList.add(Integer.valueOf(str[i])); + } + } + return dataArrayList; + } +} diff --git a/Greedy algorithm/src/main/java/com/jianglai/greedy/algorithm/ChildAndCookie.java b/Greedy algorithm/src/main/java/com/jianglai/greedy/algorithm/ChildAndCookie.java new file mode 100644 index 0000000..af3201d --- /dev/null +++ b/Greedy algorithm/src/main/java/com/jianglai/greedy/algorithm/ChildAndCookie.java @@ -0,0 +1,74 @@ +package com.jianglai.greedy.algorithm; + +import java.util.*; + +/** + * @author leon + * @ClassName ChildAndCookie.java + * @createTime 2021年01月16日 11:23:00 + * @Discription + * 题目描述 + * 有一群孩子和一堆饼干,每个孩子有一个饥饿度,每个饼干都有一个大小。每个孩子只能吃 + * 最多一个饼干,且只有饼干的大小大于孩子的饥饿度时,这个孩子才能吃饱。求解最多有多少孩 + * 子可以吃饱。 + * 输入输出样例 + * 输入两个数组,分别代表孩子的饥饿度和饼干的大小。输出最多有多少孩子可以吃饱的数 + * 量。 + */ +public class ChildAndCookie { + + public static void main(String[] args) { + + System.out.println("请输入每个孩子的饥俄程度：\n"); + Scanner scanner1 = new Scanner(System.in); + System.out.println("请输入每个饼干的大小: \n"); + Scanner scanner2 = new Scanner(System.in); + ArrayList childArray = new ArrayList(); + ArrayList cookieArray = new ArrayList(); + if(scanner1.hasNext()){ + // 将输入转换为数组 + childArray = getChildArray(scanner1); + Collections.sort(childArray); + + } + if(scanner2.hasNext()){ + cookieArray = getCookieArray(scanner2); + Collections.sort(cookieArray); + } + + System.out.println("经排序后的child:"+ childArray.toString()); + System.out.println("经排序后的cookie:"+ cookieArray.toString()); + + // 喂孩子 + int childNum = 0; int cookieNum = 0; + while (childNum < childArray.size() && cookieNum < cookieArray.size()){ + if(childArray.get(childNum) < cookieArray.get(cookieNum)){ + ++childNum; + }else{ + ++cookieNum; + } + } + System.out.println("孩子可以喂饱："+ childNum + "个。"); + + } + + private static ArrayList getCookieArray(Scanner scanner2) { + String[] childStr = scanner2.nextLine().split(" "); + ArrayList child = new ArrayList(); + for(int n = 0; n < childStr.length; n++){ + child.add(Integer.valueOf(childStr[n])); + } + return child; + } + + private static ArrayList getChildArray(Scanner scanner1) { + String[] cookieStr = scanner1.nextLine().split(" "); + ArrayList cookie = new ArrayList(); + for(int n = 0; n < cookieStr.length; n++){ + cookie.add(Integer.valueOf(cookieStr[n])); + } + return cookie; + } + + +} diff --git a/Greedy algorithm/src/main/java/com/jianglai/greedy/algorithm/DistributeCandy.java b/Greedy algorithm/src/main/java/com/jianglai/greedy/algorithm/DistributeCandy.java new file mode 100644 index 0000000..c05a9cd --- /dev/null +++ b/Greedy algorithm/src/main/java/com/jianglai/greedy/algorithm/DistributeCandy.java @@ -0,0 +1,64 @@ +package com.jianglai.greedy.algorithm; + +import java.util.ArrayList; +import java.util.Scanner; + +/** + * @author leon + * @ClassName DistributeCandy.java + * @createTime 2021年01月16日 12:07:00 + * @Discription: + * 题目描述 + * 一群孩子站成一排,每一个孩子有自己的评分。现在需要给这些孩子发糖果,规则是如果一 + * 个孩子的评分比自己身旁的一个孩子要高,那么这个孩子就必须得到比身旁孩子更多的糖果;所 + * 有孩子至少要有一个糖果。求解最少需要多少个糖果。 + * 输入输出样例 + * 输入是一个数组,表示孩子的评分。输出是最少糖果的数量。 + */ +public class DistributeCandy { + public static void main(String[] args) { + System.out.println("请输入孩子们的分数：\n"); + Scanner scanner = new Scanner(System.in); + // 转换为数组 + ArrayList childArray = getChildArray(scanner); + System.out.println("孩子分数转换为数组："+ childArray.toString()); + // 创建糖果分配数组，并初始化为1 + ArrayList candyArray = new ArrayList(); + for(int i = 0; i < childArray.size(); i++){ + candyArray.add(1); + } + System.out.println("糖果分发数组："+candyArray.toString()); + // 左循环 + for(int i =0; i < childArray.size()-1; i++){ + for(int j = i+1; j <= childArray.size()-1; ){ + if(childArray.get(j) > childArray.get(i)){ + candyArray.set(j, candyArray.get(i)+1); + } + break; + } + } + System.out.println("完成左循环的candyArray："+candyArray.toString()); + // 右循环 + for(int i = childArray.size()-1; i > 0; i--){ + for(int j = i -1; j >=0;){ + if(childArray.get(j) > childArray.get(i) && candyArray.get(j) <= candyArray.get(i)){ + candyArray.set(j, candyArray.get(i)+1); + } + break; + } + } + + System.out.println("最小糖果数量:"+candyArray.toString()); + } + + private static ArrayList getChildArray(Scanner scanner) { + ArrayList child = new ArrayList(); + if(scanner.hasNext()){ + String[] childStr = scanner.nextLine().split(" "); + for(int n = 0; n < childStr.length; n++){ + child.add(Integer.valueOf(childStr[n])); + } + } + return child; + } +} diff --git a/Greedy algorithm/src/main/java/com/jianglai/greedy/algorithm/NoOverlappingInterval.java b/Greedy algorithm/src/main/java/com/jianglai/greedy/algorithm/NoOverlappingInterval.java new file mode 100644 index 0000000..4811413 --- /dev/null +++ b/Greedy algorithm/src/main/java/com/jianglai/greedy/algorithm/NoOverlappingInterval.java @@ -0,0 +1,101 @@ +package com.jianglai.greedy.algorithm; + +import java.math.BigDecimal; +import java.util.*; + +/** + * @author leon + * @ClassName NoOverlappingInterval.java + * @createTime 2021年01月16日 13:27:00 + * @Description + * 题目描述 + * 给定多个区间,计算让这些区间互不重叠所需要移除区间的最少个数。起止相连不算重叠。 + * 输入输出样例 + * 输入是一个数组,数组由多个长度固定为 2 的数组组成,表示区间的开始和结尾。输出一个 + * 整数,表示需要移除的区间数量。 + * Input: [[1,2], [2,4], [1,3]] + * Output: 1 + */ +public class NoOverlappingInterval { + + public static void main(String[] args) { + + System.out.println("请输入计算区间的数组(区间用\"，\"号间隔 数组元素用\" \"间隔 ):\n"); + Scanner scanner = new Scanner(System.in); + // 获取区间数组 + ArrayList> intervalsArray = getIntervalsArray(scanner); + System.out.println(intervalsArray.toString()); + + // 对其排序-按照区间大小 + LinkedList> sortIntegerList = sortIntervalsArray(intervalsArray); + System.out.println("排序后的区间数组："+sortIntegerList.toString()); + + // 判断最少减少几个区间 + HashMap>> result = getResultHashMap(sortIntegerList); + System.out.println("最少减少："+result.keySet().toArray()[0]+"个区间，这个区间是："+ result.get(result.keySet().toArray()[0]).toString()); + + } + + /** + * 判断最少减少几个区间 + * @param sortIntegerList + * @return + */ + private static HashMap>> getResultHashMap(LinkedList> sortIntegerList) { + HashMap>> result = new HashMap>>(); + ArrayList> dataArrayList = new ArrayList>(); + Integer num = 0; + for(int i=0; i sortIntegerList.get(i+1).get(0)){ + dataArrayList.add(sortIntegerList.get(i+1)); + sortIntegerList.remove(i+1); + num +=1; + }else{ + flag = false; + break; + } + if(i == sortIntegerList.size()-1){ + flag = false; + break; + } + } + + } + result.put(num, dataArrayList); + return result; + } + + private static LinkedList> sortIntervalsArray(ArrayList> intervalsArray) { + ArrayList> newintervalsArray = new ArrayList>(); + TreeMap> dataTreemap = new TreeMap>(); + LinkedList> integersList= new LinkedList>(); + Integer[] integerArray = new Integer[intervalsArray.size()]; + // 利用TreeMap根据区间尾的大小排序 + for(int i=0; i> getIntervalsArray(Scanner scanner) { + ArrayList> arrayLists = new ArrayList>(); + if(scanner.hasNext()){ + String[] intervalsArray = scanner.nextLine().split(" "); + for(int n =0; n < intervalsArray.length; n++){ + ArrayList integers = new ArrayList(); + String[] splits = intervalsArray[n].split(","); + integers.add(Integer.valueOf(splits[0])); + integers.add(Integer.valueOf(splits[1])); + arrayLists.add(integers); + } + } + return arrayLists; + } +} + diff --git a/jianglai_algorithm/jianglai_algorithm.iml b/jianglai_algorithm/jianglai_algorithm.iml new file mode 100644 index 0000000..d4368c1 --- /dev/null +++ b/jianglai_algorithm/jianglai_algorithm.iml @@ -0,0 +1,16 @@ + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/jianglai_algorithm/pom.xml b/jianglai_algorithm/pom.xml new file mode 100644 index 0000000..113baac --- /dev/null +++ b/jianglai_algorithm/pom.xml @@ -0,0 +1,15 @@ + + + + leetcode + wjc.leetcode + 1.0-SNAPSHOT + + 4.0.0 + + jianglai_algorithm + + + diff --git a/jianglai_algorithm/src/main/java/com/jianglai/algorithm/common/BubbleSort.java b/jianglai_algorithm/src/main/java/com/jianglai/algorithm/common/BubbleSort.java new file mode 100644 index 0000000..1c3771a --- /dev/null +++ b/jianglai_algorithm/src/main/java/com/jianglai/algorithm/common/BubbleSort.java @@ -0,0 +1,53 @@ +package com.jianglai.algorithm.common; + +import com.sun.org.apache.xerces.internal.impl.xs.SchemaNamespaceSupport; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.Scanner; + +/** + * @author leon + * @ClassName BubbleSoert.java + * @createTime 2021年01月16日 13:49:00 + * @Description: + * 冒泡排序是一种交换排序，基本思想是：两两比较相邻记录的关键字，如果反序，则交换，直到没有反序记录为止 + * 时间复杂度：O(n^2) + */ +public class BubbleSort { + public static void main(String[] args) { + System.out.println("请输入需要排序的数组，用\' \'间隔：\n"); + Scanner scanner = new Scanner(System.in); + // 获取输入的数据为数组 + ArrayList dataArray = getDataArray(scanner); + System.out.println("输入的数组是："+dataArray.toString()); + // 排序 + ArrayList sortedArray = sortDataByBubbleSort(dataArray); + + System.out.println("排序后的数组："+ sortedArray.toString()); + } + + public static ArrayList getDataArray(Scanner scanner){ + ArrayList integers = new ArrayList(); + if(scanner.hasNext()){ + String[] numStr = scanner.nextLine().split(" "); + for(String str : numStr){ + integers.add(Integer.valueOf(str)); + } + } + return integers; + } + + public static ArrayList sortDataByBubbleSort(ArrayList dataArray){ + for(int i =0; i< dataArray.size()-1; i++){ + for(int j =0; j dataArray.get(j+1)){ + int max = dataArray.get(j); + dataArray.set(j, dataArray.get(j+1)); + dataArray.set(j+1, max); + } + } + } + return dataArray; + } +} diff --git a/jianglai_algorithm/src/main/java/com/jianglai/algorithm/common/QuickSort.java b/jianglai_algorithm/src/main/java/com/jianglai/algorithm/common/QuickSort.java new file mode 100644 index 0000000..3d5e8fa --- /dev/null +++ b/jianglai_algorithm/src/main/java/com/jianglai/algorithm/common/QuickSort.java @@ -0,0 +1,113 @@ +package com.jianglai.algorithm.common; + +import jdk.nashorn.internal.parser.JSONParser; + +import java.util.*; + +/** + * @author leon + * @ClassName quickSort.java + * @createTime 2021年01月16日 14:57:00 + * @Description: + * 快速排序： + * 通过一趟排序将待排序记录分隔成独立的两个部分， + * 其中一部分记录的关键字均比另一部分关键字小， + * 则可以分别对这两部分记录继续进行排序，以达到整个序列有序 + * + */ +public class QuickSort { + public static void main(String[] args) { + System.out.println("请输入需要排序的数组：\n"); + Scanner scanner = new Scanner(System.in); + + // 将输入数据转换为数组 + ArrayList dataArray = getDataArray(scanner); + System.out.println("输入的数组是："+dataArray.toString()); + + // 快速排序 + ArrayList quickSortResult = quickSort(dataArray, 0, dataArray.size()-1); + System.out.println("快速排序结果："+quickSortResult.toString()); + + } + + /** + * 快速排序 + * @param dataArray + * @return + */ + private static ArrayList quickSort(ArrayList dataArray, int start, int end) { + + System.out.println("调用："); + // code + if(dataArray.isEmpty() || end < start){ + return null; + } + Integer spaceIndex = arrayPartition(dataArray, start, end); + if(spaceIndex > start){ + quickSort(dataArray, start, spaceIndex -1); + } + if(spaceIndex < end){ + quickSort(dataArray, spaceIndex + 1, end); + } + + return dataArray; + } + + /** + * 分区快排 + * @param dataArray + * @param start + * @param end + * @return + */ + private static Integer arrayPartition(ArrayList dataArray, int start, int end) { + // 随机选择一个waterMakr + Integer waterMakr = (int) (start + Math.random() * (end - start + 1)); + System.out.println("waterMark==="+waterMakr+"start==>"+start+", end===>"+end); + Integer spaceIndex = start; + // 将随机waterMark置换到首位 + swap(dataArray, start, waterMakr); + System.out.println("置换首位后："+dataArray.toString()); + for(int i = start + 1; i <= end; i++){ + if(dataArray.get(i) <= dataArray.get(start)){ + spaceIndex++; + if(i > spaceIndex){ + swap(dataArray, spaceIndex, i); + } + } + } + swap(dataArray, start, spaceIndex); + System.out.println("本次排序后："+dataArray.toString()+"=== spaceIndex："+spaceIndex); + return spaceIndex; + } + + /** + * 交换两个元素 + * @param dataArray + * @param small + * @param big + */ + private static void swap(ArrayList dataArray, int small, int big) { + Integer max = dataArray.get(big); + dataArray.set(big, dataArray.get(small)); + dataArray.set(small, max); + } + + /** + * 读取输入为ArrayList + * @param scanner + * @return + */ + private static ArrayList getDataArray(Scanner scanner) { + ArrayList integers = new ArrayList(); + if(scanner.hasNext()){ + String[] strArray = scanner.nextLine().split(" "); + for(int n =0 ; n < strArray.length; n++){ + integers.add(Integer.valueOf(strArray[n])); + } + } + return integers; + } + + +} diff --git a/jianglai_algorithm/src/main/java/com/jianglai/algorithm/tensents/FightingMonsters.java b/jianglai_algorithm/src/main/java/com/jianglai/algorithm/tensents/FightingMonsters.java new file mode 100644 index 0000000..2ad6af8 --- /dev/null +++ b/jianglai_algorithm/src/main/java/com/jianglai/algorithm/tensents/FightingMonsters.java @@ -0,0 +1,30 @@ +package com.jianglai.algorithm.tensents; + +import java.sql.SQLOutput; +import java.util.Scanner; + +/** + * @author leon + * @ClassName FightingMonsters.java + * @createTime 2021年01月16日 10:41:00 + */ +public class FightingMonsters { + public static void main(String[] args) { + Scanner scanner = new Scanner(System.in); + System.out.println("请输入：\n"); + if (scanner.hasNext()){ + String[] s = scanner.nextLine().split(" "); + int num = Integer.valueOf(s[0]); + int q = Integer.valueOf(s[1]); + int maxEarning = -1; + for(int n = 0; n < num; n++){ + String[] s1 = scanner.nextLine().split(" "); + // 判断本局是否收益大于消耗 + if(Integer.valueOf(s1[1]) > (Integer.valueOf(s1[0]) / q)){ + maxEarning += Integer.valueOf(s1[1])- (Integer.valueOf(s1[0]) / q); + } + } + System.out.println("最大收益是："+ maxEarning); + } + } +} diff --git a/jianglai_algorithm/src/main/java/com/jianglai/algorithm/tree/Node.java b/jianglai_algorithm/src/main/java/com/jianglai/algorithm/tree/Node.java new file mode 100644 index 0000000..e1d2fb3 --- /dev/null +++ b/jianglai_algorithm/src/main/java/com/jianglai/algorithm/tree/Node.java @@ -0,0 +1,40 @@ +package com.jianglai.algorithm.tree; + +/** + * @author leon + * @ClassName Node.java + * @createTime 2021年01月20日 19:51:00 + */ +public class Node { + private E data; + private int index; + + public Node(E data, int index) { + this.data = data; + this.index = index; + } + + public E getData() { + return data; + } + + public void setData(E data) { + this.data = data; + } + + public int getIndex() { + return index; + } + + public void setIndex(int index) { + this.index = index; + } + + @Override + public String toString() { + return "Node{" + + "data=" + data + + ", index=" + index + + '}'; + } +} diff --git a/jianglai_algorithm/src/main/java/com/jianglai/algorithm/tree/TreeNode.java b/jianglai_algorithm/src/main/java/com/jianglai/algorithm/tree/TreeNode.java new file mode 100644 index 0000000..b9ed3a4 --- /dev/null +++ b/jianglai_algorithm/src/main/java/com/jianglai/algorithm/tree/TreeNode.java @@ -0,0 +1,20 @@ +package com.jianglai.algorithm.tree; + +/** + * @author leon + * @ClassName TreeNode.java + * @createTime 2021年01月20日 19:21:00 + */ +public class TreeNode { + private int val; + private TreeNode leftChild; + private TreeNode rightChild; + private int parent; + + public TreeNode(int val, TreeNode leftChild, TreeNode rightChild) { + this.val = val; + this.leftChild = leftChild; + this.rightChild = rightChild; + } + +} diff --git a/jianglai_algorithm/src/main/java/com/jianglai/algorithm/tree/TreeNodeArray.java b/jianglai_algorithm/src/main/java/com/jianglai/algorithm/tree/TreeNodeArray.java new file mode 100644 index 0000000..bb4c8c6 --- /dev/null +++ b/jianglai_algorithm/src/main/java/com/jianglai/algorithm/tree/TreeNodeArray.java @@ -0,0 +1,121 @@ +package com.jianglai.algorithm.tree; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Iterator; +import java.util.List; + +/** + * @author leon + * @ClassName TreeNodeArray.java + * @createTime 2021年01月20日 19:38:00 + */ +public class TreeNodeArray { + private static final int DEFAULT_SIZE = 20; + private int size; + private Node[] nodes; + private int nodeNum; + + public TreeNodeArray(E data){ + size = DEFAULT_SIZE; + nodes = new Node[size]; + nodes[0] = new Node(data, -1); + nodeNum++; + } + + public TreeNodeArray(E data, int capacity){ + size = capacity; + nodes = new Node[size]; + nodes[0] = new Node(data, -1); + nodeNum++; + } + + /** + * 传入升序的ArrayList + * @param dataArray + */ + public TreeNodeArray(ArrayList dataArray){ + size = dataArray.size(); + nodes = new Node[size]; + int waterMark = -1; + waterMark = (size%2 == 0) ? (size/2 -1) : ((size-1)/2); + nodes[waterMark] = new Node(dataArray.get(waterMark), -1); + Node parentNode = nodes[waterMark]; + for(int i = waterMark-1; i>=0; i--){ + E data = dataArray.get(i); + this.addNode(data, i,parentNode); + parentNode = this.getNode(i); + } + for(int i=size-1; i>=waterMark+1; i--){ + E data = dataArray.get(i); + this.addNode(data, dataArray.indexOf(data),parentNode); + parentNode = this.getNode(dataArray.indexOf(data)); + } + } + + /** + * 添加节点 + * @param data + * @param parent + * @return + */ + public Node addNode(E data, Node parent){ + for(int i = 0; i < size; i++){ + if(null == nodes[i]){ + nodes[i] = new Node(data, pos(parent)); + nodeNum++; + return nodes[i]; + } + } + throw new RuntimeException("该树已满，无法添加新节点;"); + } + + public Node addNode(E data, int index, Node parent){ + if(null == nodes[index]){ + nodes[index] = new Node(data, pos(parent)); + nodeNum++; + return nodes[index]; + } + throw new RuntimeException("该树已满，无法添加新节点;"); + } + /** + * 根据索引获取节点 + * @param index + * @return + */ + public Node getNode(int index){ + Node node = this.nodes[index]; + return node; + } + /** + * 查找该节点的索引值 + * @param node + * @return + */ + public int pos(Node node){ + for(int i=0; i < size; i++){ + if(nodes[i] == node ) return i; + } + return -1; + } + + public int getNodeNum() { + return nodeNum; + } + + @Override + public String toString() { + String nodes = "["; + for(int i =0; i< this.nodes.length; i++){ + nodes += this.nodes[i].toString(); + } + nodes+="]"; + return "TreeNodeArray{" + + "size=" + size + + ", nodes=" + nodes + + ", nodeNum=" + nodeNum + + '}'; + } + + +} diff --git a/jianglai_algorithm/src/main/java/com/jianglai/algorithm/tree/testTree.java b/jianglai_algorithm/src/main/java/com/jianglai/algorithm/tree/testTree.java new file mode 100644 index 0000000..0a01815 --- /dev/null +++ b/jianglai_algorithm/src/main/java/com/jianglai/algorithm/tree/testTree.java @@ -0,0 +1,54 @@ +package com.jianglai.algorithm.tree; + + +import java.util.ArrayList; +import java.util.Scanner; + +/** + * @author leon + * @ClassName testTree.java + * @createTime 2021年01月20日 19:19:00 + */ +public class testTree { + public static void main(String[] args) { + + System.out.println("请输入数据，不相同的整数："); + Scanner scanner = new Scanner(System.in); + // 转化为数组 + ArrayList dataArray = getDataArray(scanner); + // 排序 + ArrayList integers = sortDataByBubbleSort(dataArray); + System.out.println("输入的数据是："+ integers.toString()); + + TreeNodeArray treeNodeArray = new TreeNodeArray(integers); + for(int i=0; i"+treeNodeArray.getNode(i)); + } + + //System.out.println("树===>"+treeNodeArray.toString()); + } + + public static ArrayList getDataArray(Scanner scanner){ + ArrayList integers = new ArrayList(); + if(scanner.hasNext()){ + String[] numStr = scanner.nextLine().split(" "); + for(String str : numStr){ + integers.add(Integer.valueOf(str)); + } + } + return integers; + } + + public static ArrayList sortDataByBubbleSort(ArrayList dataArray){ + for(int i =0; i< dataArray.size()-1; i++){ + for(int j =0; j dataArray.get(j+1)){ + int max = dataArray.get(j); + dataArray.set(j, dataArray.get(j+1)); + dataArray.set(j+1, max); + } + } + } + return dataArray; + } +} diff --git a/jianglai_algorithm/src/test/LinkedHashMapTest.java b/jianglai_algorithm/src/test/LinkedHashMapTest.java new file mode 100644 index 0000000..164f5ad --- /dev/null +++ b/jianglai_algorithm/src/test/LinkedHashMapTest.java @@ -0,0 +1,41 @@ +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.Set; + +/** + * @author leon + * @ClassName LinkedHashMapTest.java + * @createTime 2021年01月18日 17:34:00 + */ +public class LinkedHashMapTest { + + public static void main(String[] args) { + // 第三个参数用于指定accessOrder值 + Map linkedHashMap = new LinkedHashMap(16, 0.75f, true); + linkedHashMap.put("name1", "josan1"); + linkedHashMap.put("name2", "josan2"); + linkedHashMap.put("name3", "josan3"); + System.out.println("开始时顺序："); + Set> set = linkedHashMap.entrySet(); + Iterator> iterator = set.iterator(); + while(iterator.hasNext()) { + Map.Entry entry = iterator.next(); + String key = (String) entry.getKey(); + String value = (String) entry.getValue(); + System.out.println("key:" + key + ",value:" + value); + } + System.out.println("通过get方法，导致key为name1对应的Entry到表尾"); + linkedHashMap.get("name1"); + Set> set2 = linkedHashMap.entrySet(); + Iterator> iterator2 = set2.iterator(); + while(iterator2.hasNext()) { + Map.Entry entry = iterator2.next(); + String key = (String) entry.getKey(); + String value = (String) entry.getValue(); + System.out.println("key:" + key + ",value:" + value); + } + + } + +} diff --git a/jianglai_algorithm/target/classes/META-INF/jianglai_algorithm.kotlin_module b/jianglai_algorithm/target/classes/META-INF/jianglai_algorithm.kotlin_module new file mode 100644 index 0000000..a49347a Binary files /dev/null and b/jianglai_algorithm/target/classes/META-INF/jianglai_algorithm.kotlin_module differ diff --git a/pom.xml b/pom.xml index f4d3123..721bc2c 100644 --- a/pom.xml +++ b/pom.xml @@ -6,7 +6,12 @@ wjc.leetcode leetcode + pom 1.0-SNAPSHOT + + jianglai_algorithm + Greedy algorithm + - \ No newline at end of file +