├── .gitignore ├── README.md └── src ├── HOT100 ├── Main1.java ├── Main10.java ├── Main101.java ├── Main102.java ├── Main104.java ├── Main105.java ├── Main106.java ├── Main107.java ├── Main11.java ├── Main114.java ├── Main128.java ├── Main129.java ├── Main136.java ├── Main139.java ├── Main14.java ├── Main141.java ├── Main142.java ├── Main147.java ├── Main148.java ├── Main15.java ├── Main152.java ├── Main155.java ├── Main160.java ├── Main169.java ├── Main17.java ├── Main19.java ├── Main2.java ├── Main20.java ├── Main200.java ├── Main206.java ├── Main207.java ├── Main208.java ├── Main21.java ├── Main215.java ├── Main22.java ├── Main221.java ├── Main23.java ├── Main234.java ├── Main236.java ├── Main238.java ├── Main239.java ├── Main240.java ├── Main279.java ├── Main283.java ├── Main287.java ├── Main3.java ├── Main300.java ├── Main301.java ├── Main31.java ├── Main32.java ├── Main322.java ├── Main33.java ├── Main34.java ├── Main347.java ├── Main39.java ├── Main394.java ├── Main399.java ├── Main4.java ├── Main406.java ├── Main416.java ├── Main437.java ├── Main438.java ├── Main448.java ├── Main461.java ├── Main494.java ├── Main5.java ├── Main538.java ├── Main543.java ├── Main560.java ├── Main581.java ├── Main617.java ├── Main621.java ├── Main647.java ├── Main70.java ├── Main72.java ├── Main739.java ├── Main75.java ├── Main76.java ├── Main78.java ├── Main79.java ├── Main85.java ├── Main96.java └── Main98.java ├── JZOffer2 ├── CreateTree.java ├── Interview13.java ├── Interview45.java ├── Interview59.java ├── Interview67.java ├── ListNode.java ├── Main12.java ├── Main14.java ├── Main16.java ├── Main20.java ├── Main26.java ├── Main27.java ├── Main27_1.java ├── Main28.java ├── Main28_1.java ├── Main29.java ├── Main29_1.java ├── Main30.java ├── Main31.java ├── Main32.java ├── Main32II.java ├── Main32III.java ├── Main33.java ├── Main34.java ├── Main35.java ├── Main36.java ├── Main38.java ├── Main39.java ├── Main4.java ├── Main40.java ├── Main42.java ├── Main44.java ├── Main45.java ├── Main46.java ├── Main47.java ├── Main48.java ├── Main49.java ├── Main50.java ├── Main52.java ├── Main53.java ├── Main53II.java ├── Main54.java ├── Main55.java ├── Main55II.java ├── Main56I.java ├── Main56II.java ├── Main57.java ├── Main57II.java ├── Main58.java ├── Main58II.java ├── Main59I.java ├── Main60.java ├── Main61.java ├── Main62.java ├── Main63.java ├── Main64.java ├── Main65.java ├── Main66.java ├── Main68.java ├── Main68II.java ├── Main7.java └── TreeNode.java ├── JZOfferTuJi ├── Main1.java ├── Main10.java ├── Main11.java ├── Main12.java ├── Main13.java ├── Main14.java ├── Main15.java ├── Main16.java ├── Main17.java ├── Main18.java ├── Main19.java ├── Main2.java ├── Main20.java ├── Main21.java ├── Main22.java ├── Main23.java ├── Main24.java ├── Main25.java ├── Main26.java ├── Main3.java ├── Main30.java ├── Main35.java ├── Main37.java ├── Main38.java ├── Main4.java ├── Main43.java ├── Main44.java ├── Main45.java ├── Main47.java ├── Main49.java ├── Main5.java ├── Main50.java ├── Main52.java ├── Main53.java ├── Main54.java ├── Main56.java ├── Main57.java ├── Main58.java ├── Main6.java ├── Main60.java ├── Main61.java ├── Main62.java ├── Main63.java ├── Main64.java ├── Main66.java ├── Main67.java ├── Main7.java ├── Main70.java ├── Main74.java ├── Main76.java ├── Main8.java ├── Main83.java └── Main9.java ├── NiukeTOP101 ├── BM1.java ├── BM10.java ├── BM100.java ├── BM101.java ├── BM11.java ├── BM12.java ├── BM13.java ├── BM14.java ├── BM15.java ├── BM16.java ├── BM17.java ├── BM18.java ├── BM19.java ├── BM2.java ├── BM20.java ├── BM21.java ├── BM22.java ├── BM23.java ├── BM24.java ├── BM25.java ├── BM26.java ├── BM27.java ├── BM28.java ├── BM29.java ├── BM3.java ├── BM30.java ├── BM31.java ├── BM32.java ├── BM33.java ├── BM34.java ├── BM35.java ├── BM36.java ├── BM37.java ├── BM38.java ├── BM4.java ├── BM40.java ├── BM41.java ├── BM42.java ├── BM43.java ├── BM44.java ├── BM45.java ├── BM46.java ├── BM47.java ├── BM48.java ├── BM49.java ├── BM5.java ├── BM50.java ├── BM51.java ├── BM52.java ├── BM53.java ├── BM54.java ├── BM55.java ├── BM56.java ├── BM57.java ├── BM58.java ├── BM59.java ├── BM6.java ├── BM60.java ├── BM61.java ├── BM62.java ├── BM63.java ├── BM64.java ├── BM65.java ├── BM66.java ├── BM67.java ├── BM68.java ├── BM69.java ├── BM7.java ├── BM70.java ├── BM71.java ├── BM72.java ├── BM73.java ├── BM74.java ├── BM75.java ├── BM78.java ├── BM79.java ├── BM8.java ├── BM80.java ├── BM81.java ├── BM82.java ├── BM83.java ├── BM84.java ├── BM85.java ├── BM86.java ├── BM87.java ├── BM88.java ├── BM89.java ├── BM9.java ├── BM90.java ├── BM91.java ├── BM92.java ├── BM93.java ├── BM94.java ├── BM95.java ├── BM96.java ├── BM97.java ├── BM98.java ├── BM99.java ├── ListNode.java ├── MergeSort.java └── TreeNode.java ├── Thread ├── CompletableFutureTest.java ├── ProducerAndConsumer.java └── ThreadTest.java ├── designPattern ├── adapter │ ├── classAdapter │ │ ├── Client.java │ │ ├── Computer.java │ │ ├── SDAdapterTF.java │ │ ├── SDCard.java │ │ ├── SDCardImpl.java │ │ ├── TFCard.java │ │ └── TFCardImpl.java │ └── objectAdapter │ │ ├── Client.java │ │ ├── Computer.java │ │ ├── SDAdapterTF.java │ │ ├── SDCard.java │ │ ├── SDCardImpl.java │ │ ├── TFCard.java │ │ └── TFCardImpl.java ├── bridge │ ├── AviFile.java │ ├── Client.java │ ├── Mac.java │ ├── OperationSystem.java │ ├── RmvbFile.java │ ├── VideoFile.java │ └── Windows.java ├── builder │ ├── demo1 │ │ ├── Bike.java │ │ ├── Builder.java │ │ ├── Client.java │ │ ├── Director.java │ │ ├── MobileBuilder.java │ │ └── OfoBuilder.java │ └── demo2 │ │ ├── Client.java │ │ └── Phone.java ├── combination │ ├── Client.java │ ├── Menu.java │ ├── MenuComponent.java │ └── MenuItem.java ├── command │ ├── Client.java │ ├── Command.java │ ├── Order.java │ ├── OrderCommand.java │ ├── SeniorChef.java │ └── Waiter.java ├── decorator │ ├── Bacon.java │ ├── Client.java │ ├── Egg.java │ ├── FastFood.java │ ├── FriedNoddles.java │ ├── FriedRice.java │ └── Garnish.java ├── facade │ ├── AirCondition.java │ ├── Client.java │ ├── Light.java │ ├── SmartAppliancesFacade.java │ └── TV.java ├── factory │ ├── abstractFactory │ │ ├── AmericanCoffee.java │ │ ├── AmericanDessertFactory.java │ │ ├── Client.java │ │ ├── Coffee.java │ │ ├── Dessert.java │ │ ├── DessertFactory.java │ │ ├── ItalyDessertFactory.java │ │ ├── LatteCoffee.java │ │ ├── MatchaMousse.java │ │ └── Tiramisu.java │ ├── before │ │ ├── AmericanCoffee.java │ │ ├── Client.java │ │ ├── Coffee.java │ │ ├── CoffeeStore.java │ │ └── LatteCoffee.java │ ├── configFactory │ │ ├── AmericanCoffee.java │ │ ├── Client.java │ │ ├── Coffee.java │ │ ├── CoffeeFactory.java │ │ ├── LatteCoffee.java │ │ └── bean.properties │ ├── factoryMethod │ │ ├── AmericanCoffee.java │ │ ├── AmericanCoffeeFactory.java │ │ ├── Client.java │ │ ├── Coffee.java │ │ ├── CoffeeFactory.java │ │ ├── CoffeeStore.java │ │ ├── LatteCoffee.java │ │ └── LatteCoffeeFactory.java │ └── simpleFactory │ │ ├── AmericanCoffee.java │ │ ├── Client.java │ │ ├── Coffee.java │ │ ├── CoffeeStore.java │ │ ├── LatteCoffee.java │ │ └── SimpleCoffeeFactory.java ├── flyWeight │ ├── AbstractBox.java │ ├── BoxFactory.java │ ├── Client.java │ ├── IBox.java │ ├── LBox.java │ └── OBox.java ├── interpreter │ ├── AbstractExpression.java │ ├── Client.java │ ├── Context.java │ ├── Minus.java │ ├── Plus.java │ └── Variable.java ├── iterator │ ├── Client.java │ ├── Student.java │ ├── StudentAggregate.java │ ├── StudentAggregateImpl.java │ ├── StudentIterator.java │ └── StudentIteratorImpl.java ├── mediator │ ├── Client.java │ ├── HouseOwner.java │ ├── Mediator.java │ ├── MediatorStructure.java │ ├── Person.java │ └── Tenant.java ├── memento │ ├── blackBox │ │ ├── Client.java │ │ ├── GameRole.java │ │ ├── Memento.java │ │ └── RoleStateCaretaker.java │ └── whiteBox │ │ ├── Client.java │ │ ├── GameRole.java │ │ ├── RoleStateCaretaker.java │ │ └── RoleStateMemento.java ├── observer │ ├── Client.java │ ├── Observer.java │ ├── Subject.java │ ├── SubscriptionSubject.java │ └── WeChatUser.java ├── prototype │ ├── demo │ │ ├── Client.java │ │ └── RealizeType.java │ ├── test │ │ ├── Citation.java │ │ ├── CitationTest.java │ │ └── Student.java │ └── test1 │ │ ├── Citation.java │ │ ├── CitationTest.java │ │ └── Student.java ├── proxy │ ├── jdkProxy │ │ ├── Client.java │ │ ├── ProxyFactory.java │ │ ├── SellTickets.java │ │ └── TrainStation.java │ └── staticProxy │ │ ├── Client.java │ │ ├── ProxyPoint.java │ │ ├── SellTickets.java │ │ └── TrainStation.java ├── responsibility │ ├── Client.java │ ├── GeneralManager.java │ ├── GroupLeader.java │ ├── Handler.java │ ├── LeaveRequest.java │ └── Manager.java ├── singleton │ ├── demo1 │ │ └── Singleton.java │ ├── demo2 │ │ └── Singleton.java │ ├── demo3 │ │ └── Singleton.java │ ├── demo4 │ │ └── Singleton.java │ ├── demo5 │ │ └── Singleton.java │ ├── demo6 │ │ └── Singleton.java │ ├── demo7 │ │ └── Singleton.java │ └── demo8 │ │ └── RuntimeDemo.java ├── state │ ├── after │ │ ├── Client.java │ │ ├── ClosingState.java │ │ ├── Context.java │ │ ├── LiftState.java │ │ ├── OpeningState.java │ │ ├── RunningState.java │ │ └── StoppingState.java │ └── before │ │ ├── Client.java │ │ ├── ILift.java │ │ └── Lift.java ├── strategy │ ├── Client.java │ ├── SalesMan.java │ ├── Strategy.java │ ├── StrategyA.java │ ├── StrategyB.java │ └── StrategyC.java ├── template │ ├── AbstractClass.java │ ├── Client.java │ ├── ConcreteClassCabbage.java │ └── ConcreteClassChoySum.java └── visitor │ ├── Animal.java │ ├── Cat.java │ ├── Client.java │ ├── Dog.java │ ├── Home.java │ ├── Owner.java │ ├── Person.java │ └── Someone.java ├── designPrinciples ├── demo1 │ ├── AbstractSkin.java │ ├── Client.java │ ├── DefaultSkin.java │ ├── KingSkin.java │ └── SougouInput.java ├── demo2 │ ├── after │ │ ├── Quadrilateral.java │ │ ├── Rectangle.java │ │ ├── RectangleDemo.java │ │ └── Square.java │ └── before │ │ ├── Rectangle.java │ │ ├── RectangleDemo.java │ │ └── Square.java └── demo3 │ ├── Computer.java │ ├── ComputerDemo.java │ ├── Cpu.java │ ├── HardDisk.java │ ├── IntelCpu.java │ ├── KingstonMemory.java │ ├── Memory.java │ └── XiJieHardDisk.java ├── featuredTop └── LeetCode7.java ├── image ├── img.png └── img1.png ├── problems ├── JZOfferTwo32.java ├── LeetCode1.java ├── LeetCode1005.java ├── LeetCode101.java ├── LeetCode103.java ├── LeetCode104.java ├── LeetCode1049.java ├── LeetCode105.java ├── LeetCode107.java ├── LeetCode108.java ├── LeetCode110.java ├── LeetCode112.java ├── LeetCode113.java ├── LeetCode1143.java ├── LeetCode1155.java ├── LeetCode121.java ├── LeetCode122.java ├── LeetCode123.java ├── LeetCode124.java ├── LeetCode127.java ├── LeetCode129.java ├── LeetCode130.java ├── LeetCode131.java ├── LeetCode134.java ├── LeetCode135.java ├── LeetCode1365.java ├── LeetCode1382.java ├── LeetCode141.java ├── LeetCode142.java ├── LeetCode146.java ├── LeetCode1472.java ├── LeetCode148.java ├── LeetCode1480.java ├── LeetCode150.java ├── LeetCode1545.java ├── LeetCode155.java ├── LeetCode160.java ├── LeetCode17.java ├── LeetCode1755.java ├── LeetCode179.java ├── LeetCode198.java ├── LeetCode20.java ├── LeetCode200.java ├── LeetCode206.java ├── LeetCode209.java ├── LeetCode213.java ├── LeetCode215.java ├── LeetCode216.java ├── LeetCode217.java ├── LeetCode22.java ├── LeetCode225.java ├── LeetCode226.java ├── LeetCode23.java ├── LeetCode230.java ├── LeetCode230_1.java ├── LeetCode230_2.java ├── LeetCode232.java ├── LeetCode234.java ├── LeetCode235.java ├── LeetCode236.java ├── LeetCode239.java ├── LeetCode264.java ├── LeetCode27.java ├── LeetCode279.java ├── LeetCode297.java ├── LeetCode3.java ├── LeetCode300.java ├── LeetCode303.java ├── LeetCode322.java ├── LeetCode327.java ├── LeetCode328.java ├── LeetCode337.java ├── LeetCode338.java ├── LeetCode341.java ├── LeetCode343.java ├── LeetCode347.java ├── LeetCode35.java ├── LeetCode368.java ├── LeetCode376.java ├── LeetCode377.java ├── LeetCode378.java ├── LeetCode382.java ├── LeetCode385.java ├── LeetCode39.java ├── LeetCode4.java ├── LeetCode40.java ├── LeetCode406.java ├── LeetCode416.java ├── LeetCode42.java ├── LeetCode45.java ├── LeetCode455.java ├── LeetCode46.java ├── LeetCode47.java ├── LeetCode474.java ├── LeetCode475.java ├── LeetCode48.java ├── LeetCode49.java ├── LeetCode491.java ├── LeetCode493.java ├── LeetCode494.java ├── LeetCode50.java ├── LeetCode501.java ├── LeetCode51.java ├── LeetCode516.java ├── LeetCode518.java ├── LeetCode53.java ├── LeetCode530.java ├── LeetCode54.java ├── LeetCode543.java ├── LeetCode55.java ├── LeetCode56.java ├── LeetCode567.java ├── LeetCode57.java ├── LeetCode58.java ├── LeetCode59.java ├── LeetCode60.java ├── LeetCode61.java ├── LeetCode617.java ├── LeetCode62.java ├── LeetCode63.java ├── LeetCode64.java ├── LeetCode647.java ├── LeetCode654.java ├── LeetCode66.java ├── LeetCode662.java ├── LeetCode674.java ├── LeetCode69.java ├── LeetCode70.java ├── LeetCode700.java ├── LeetCode701.java ├── LeetCode71.java ├── LeetCode718.java ├── LeetCode719.java ├── LeetCode72.java ├── LeetCode724.java ├── LeetCode739.java ├── LeetCode74.java ├── LeetCode746.java ├── LeetCode75.java ├── LeetCode752.java ├── LeetCode76.java ├── LeetCode77.java ├── LeetCode778.java ├── LeetCode78.java ├── LeetCode79.java ├── LeetCode80.java ├── LeetCode81.java ├── LeetCode82.java ├── LeetCode83.java ├── LeetCode84.java ├── LeetCode86.java ├── LeetCode860.java ├── LeetCode875.java ├── LeetCode879.java ├── LeetCode89.java ├── LeetCode90.java ├── LeetCode92.java ├── LeetCode922.java ├── LeetCode93.java ├── LeetCode95.java ├── LeetCode951.java ├── LeetCode96.java ├── LeetCode971.java ├── LeetCode973.java └── LeetCode98.java ├── summarize ├── backtrack.md ├── binary-search.md ├── dynamic-programming.md ├── head-stack-hash.md ├── linked-list.md ├── monotone-stack.md ├── search.md ├── slide-window.md ├── sort.md └── tree.md ├── test ├── LRUCache.java ├── MergeSort.java ├── QuickSort.java ├── RedBook22Test.java ├── Test.java └── TestMain.java └── tree ├── BalancedTree.java ├── BinaryTree.java ├── CreateTree.java └── TreeNode.java /.gitignore: -------------------------------------------------------------------------------- 1 | .idea 2 | out 3 | leetcode.iml 4 | 5 | -------------------------------------------------------------------------------- /src/HOT100/Main1.java: -------------------------------------------------------------------------------- 1 | package HOT100; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | 6 | public class Main1 { 7 | public int[] twoSum(int[] nums, int target) { 8 | Map hashtable = new HashMap(); 9 | for (int i = 0; i < nums.length; ++i) { 10 | if (hashtable.containsKey(target - nums[i])) { 11 | return new int[]{hashtable.get(target - nums[i]), i}; 12 | } 13 | hashtable.put(nums[i], i); 14 | } 15 | return new int[0]; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/HOT100/Main104.java: -------------------------------------------------------------------------------- 1 | package HOT100; 2 | 3 | public class Main104 { 4 | public int maxDepth(TreeNode root) { 5 | if(root==null){ 6 | return 0; 7 | } 8 | int leftHeight = maxDepth(root.left); 9 | int rightHeight = maxDepth(root.right); 10 | return Math.max(leftHeight, rightHeight)+1; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/HOT100/Main128.java: -------------------------------------------------------------------------------- 1 | package HOT100; 2 | 3 | import java.util.HashSet; 4 | import java.util.Set; 5 | 6 | public class Main128 { 7 | public int longestConsecutive(int[] nums) { 8 | Set num_set = new HashSet<>(); 9 | for(int num: nums){ 10 | num_set.add(num); 11 | } 12 | int longestNum = 0; 13 | for(int num: nums){ 14 | if(num_set.contains(num-1)){ 15 | continue; 16 | } 17 | int currentNum = num; 18 | int currentStreak=1; 19 | while (num_set.contains(currentNum+1)){ 20 | currentNum +=1; 21 | currentStreak +=1; 22 | } 23 | longestNum = Math.max(longestNum, currentStreak); 24 | } 25 | return longestNum; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/HOT100/Main136.java: -------------------------------------------------------------------------------- 1 | package HOT100; 2 | 3 | public class Main136 { 4 | public int singleNumber(int[] nums) { 5 | int single = 0; 6 | for (int num : nums) { 7 | single ^= num; 8 | } 9 | return single; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/HOT100/Main142.java: -------------------------------------------------------------------------------- 1 | package HOT100; 2 | 3 | import java.util.HashSet; 4 | import java.util.Set; 5 | 6 | // Definition for singly-linked list. 7 | public class Main142 { 8 | 9 | public ListNode detectCycle(ListNode head) { 10 | ListNode pos = head; 11 | Set visited = new HashSet(); 12 | while (pos != null){ 13 | if(visited.contains(pos)){ 14 | return pos; 15 | }else { 16 | visited.add(pos); 17 | } 18 | pos=pos.next; 19 | } 20 | return null; 21 | } 22 | 23 | public static void main(String[] args) { 24 | 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/HOT100/Main152.java: -------------------------------------------------------------------------------- 1 | package HOT100; 2 | 3 | public class Main152 { 4 | public int maxProduct(int[] nums) { 5 | int n = nums.length; 6 | if(n == 0){ 7 | return 0; 8 | } 9 | int[] maxF = new int[n]; 10 | int[] minF = new int[n]; 11 | System.arraycopy(nums,0, maxF, 0, n); 12 | System.arraycopy(nums,0, minF, 0, n); 13 | for(int i=1; i=0; i--){ 18 | sum*=nums[i+1]; 19 | prefix[i]=sum * prefix[i]; 20 | } 21 | // for(int i=0; i=n-count; i--){ 18 | nums[i]=0; 19 | } 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/HOT100/Main287.java: -------------------------------------------------------------------------------- 1 | package HOT100; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Arrays; 5 | 6 | public class Main287 { 7 | public int findDuplicate(int[] nums) { 8 | if(nums.length==1){ 9 | return nums[0]; 10 | } 11 | Arrays.sort(nums); 12 | for(int i=1; i map = new HashMap<>(); 13 | for (rightPoint = 0; rightPoint < s.length(); rightPoint++) { 14 | if(map.containsKey(s.charAt(rightPoint))) { 15 | leftPoint = Math.max(leftPoint, map.get(s.charAt(rightPoint)) + 1); 16 | } 17 | map.put(s.charAt(rightPoint), rightPoint); 18 | maxLength = Math.max(maxLength, rightPoint - leftPoint + 1); 19 | } 20 | return maxLength; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/HOT100/Main300.java: -------------------------------------------------------------------------------- 1 | package HOT100; 2 | 3 | public class Main300 { 4 | public int lengthOfLIS(int[] nums) { 5 | return 0; 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /src/HOT100/Main32.java: -------------------------------------------------------------------------------- 1 | package HOT100; 2 | 3 | public class Main32 { 4 | public int longestValidParentheses(String s) { 5 | int max = 0; 6 | int[] dp = new int[s.length()]; 7 | for (int i = 1; i < s.length(); i++) { 8 | if(s.charAt(i) == ')') { 9 | if(s.charAt(i - 1) == '(') { 10 | dp[i] = (i >= 2 ? dp[i - 2] : 0) + 2; 11 | } else if (i - dp[i - 1] > 0 && s.charAt(i - dp[i - 1] - 1) == '(') { 12 | dp[i] = dp[i - 1] + ((i - dp[i - 1]) >= 2 ? dp[i - dp[i - 1] - 2] : 0) + 2; 13 | } 14 | max = Math.max(max, dp[i]); 15 | } 16 | } 17 | return max; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/HOT100/Main34.java: -------------------------------------------------------------------------------- 1 | package HOT100; 2 | 3 | public class Main34 { 4 | public int[] searchRange(int[] nums, int target) { 5 | int start = binarySearch(nums, target)+1; 6 | int end = binarySearch(nums, target+1); 7 | if (start <= end && nums[start] == target) { 8 | return new int[]{start, end}; 9 | } 10 | return new int[]{-1, -1}; 11 | } 12 | 13 | int binarySearch(int[] nums, int target){ 14 | int n = nums.length; 15 | int left=0, right=n-1; 16 | while(left<=right){ 17 | int mid=(left+right)/2; 18 | if(nums[mid]>=target) { 19 | right = mid - 1; 20 | }else { 21 | left = mid + 1; 22 | } 23 | } 24 | return right; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/HOT100/Main406.java: -------------------------------------------------------------------------------- 1 | package HOT100; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Arrays; 5 | import java.util.Comparator; 6 | import java.util.List; 7 | 8 | public class Main406 { 9 | public int[][] reconstructQueue(int[][] people) { 10 | Arrays.sort(people, new Comparator() { 11 | public int compare(int[] person1, int[] person2) { 12 | if (person1[0] != person2[0]) { 13 | return person2[0] - person1[0]; 14 | } else { 15 | return person1[1] - person2[1]; 16 | } 17 | } 18 | }); 19 | List ans = new ArrayList(); 20 | for (int[] person : people) { 21 | ans.add(person[1], person); 22 | } 23 | return ans.toArray(new int[ans.size()][]); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/HOT100/Main461.java: -------------------------------------------------------------------------------- 1 | package HOT100; 2 | 3 | public class Main461 { 4 | public int hammingDistance(int x, int y) { 5 | return Integer.bitCount(x^y); 6 | } 7 | } 8 | 9 | class Main461_1{ 10 | public int hammingDistance(int x, int y){ 11 | int s = x ^ y, ret = 0; 12 | while (s != 0){ 13 | ret += s & 1; 14 | s >>= 1; 15 | } 16 | return ret; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/HOT100/Main543.java: -------------------------------------------------------------------------------- 1 | package HOT100; 2 | 3 | public class Main543 { 4 | int maxd = 0; 5 | public int diameterOfBinaryTree(TreeNode root) { 6 | maxd = depth(root); 7 | return maxd; 8 | } 9 | 10 | private int depth(TreeNode root){ 11 | if(root==null){ 12 | return 0; 13 | } 14 | int left = depth(root.left); 15 | int right = depth(root.right); 16 | maxd = Math.max(left + right, maxd); 17 | return Math.max(left, right) + 1; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/HOT100/Main617.java: -------------------------------------------------------------------------------- 1 | package HOT100; 2 | 3 | public class Main617 { 4 | public TreeNode mergeTrees(TreeNode root1, TreeNode root2) { 5 | if(root1==null){ 6 | return root2; 7 | } 8 | if(root2==null){ 9 | return root1; 10 | } 11 | TreeNode merged = new TreeNode(root1.val + root2.val); 12 | merged.left = mergeTrees(root1.left, root2.left); 13 | merged.right = mergeTrees(root1.right, root2.right); 14 | return merged; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/HOT100/Main647.java: -------------------------------------------------------------------------------- 1 | package HOT100; 2 | 3 | public class Main647 { 4 | 5 | /* 6 | * 中心扩展 7 | * 长度为n的字符串会生成2n-1组会问中心[l_i,r_i]，其中 8 | * */ 9 | public int countSubstrings(String s) { 10 | int n = s.length(); 11 | int length = 2 * n - 1; 12 | int ans = 0; 13 | for(int i=0; i0 && right> res; 8 | List ans = new ArrayList<>(); 9 | public List> subsets(int[] nums) { 10 | res = new ArrayList<>(); 11 | dfs(nums, 0); 12 | return res; 13 | } 14 | 15 | private void dfs(int[] nums, int start) { 16 | res.add(new ArrayList<>(ans)); 17 | for(int i = start; i < nums.length; i++){ 18 | // 将当前数加入list 19 | ans.add(nums[i]); 20 | // 递归 不能重复使用当前数 因此下一轮从i+1开始 21 | dfs(nums, i+1); 22 | // 回溯 回退刚刚加的数 23 | ans.remove(ans.size()-1); 24 | } 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/HOT100/Main96.java: -------------------------------------------------------------------------------- 1 | package HOT100; 2 | 3 | public class Main96 { 4 | public int numTrees(int n) { 5 | int[] g = new int[n+1]; 6 | g[0]=1; 7 | g[1]=1; 8 | for(int i=2; i<=n; i++){ 9 | for(int j=1; j<=i; j++){ 10 | g[i] += g[j-1] * g[i-j]; 11 | } 12 | } 13 | return g[n]; 14 | } 15 | 16 | // 卡塔兰数 17 | public int numTrees1(int n) { 18 | // 提示：我们在这里需要用 long 类型防止计算过程中的溢出 19 | long C = 1; 20 | for (int i = 0; i < n; ++i) { 21 | C = C * 2 * (2 * i + 1) / (i + 2); 22 | } 23 | return (int) C; 24 | } 25 | 26 | public static void main(String[] args) { 27 | 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/JZOffer2/Interview67.java: -------------------------------------------------------------------------------- 1 | package JZOffer2; 2 | 3 | public class Interview67 { 4 | public int strToInt(String str) { 5 | char[] c = str.trim().toCharArray(); 6 | if(c.length == 0) { 7 | return 0; 8 | } 9 | int res = 0, boundary = Integer.MAX_VALUE / 10; 10 | int i = 1, sign = 1; 11 | if(c[0] == '-') { 12 | sign = -1; 13 | } 14 | else if (c[0] != '+') { 15 | i = 0; 16 | } 17 | for (int j = i; j < c.length; j++) { 18 | if(c[j] < '0' || c[j] > '9') { 19 | break; 20 | } 21 | if(res > boundary || res == boundary && c[j] > '7') { 22 | return sign == 1 ? Integer.MAX_VALUE : Integer.MIN_VALUE; 23 | } 24 | res = res * 10 + (c[j] - '0'); 25 | } 26 | return sign * res; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/JZOffer2/ListNode.java: -------------------------------------------------------------------------------- 1 | package JZOffer2; 2 | 3 | public class ListNode { 4 | int val; 5 | ListNode next; 6 | ListNode(int x) { 7 | val = x; 8 | next = null; 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /src/JZOffer2/Main14.java: -------------------------------------------------------------------------------- 1 | package JZOffer2; 2 | 3 | /** 4 | * 当 i >= 2时，假设对正整数 i 拆分成第一个整数 j (1 <= j < i)，有两种方案： 5 | * 将 i 拆分成 j 和 i - j 的和，且 i - j 不再拆分成多个正整数，此时的乘积是 j * (i - j) 6 | * 将 i 拆分成 j 和 i - j 的和，且 i - j 继续拆分成多个正整数，此时的乘积是 j * dp[i - j] 7 | */ 8 | public class Main14 { 9 | public int cuttingRope(int n) { 10 | int[] dp = new int[n + 1]; 11 | for (int i = 2; i <= n; i++) { 12 | int curMax = 0; 13 | for (int j = 1; j < i; j++) { 14 | curMax = Math.max(curMax, Math.max(j * (i - j), j * dp[i - j])); 15 | } 16 | dp[i] = curMax; 17 | } 18 | return dp[n]; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/JZOffer2/Main20.java: -------------------------------------------------------------------------------- 1 | package JZOffer2; 2 | 3 | public class Main20 { 4 | public boolean isNumber(String s) { 5 | return false; 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /src/JZOffer2/Main27.java: -------------------------------------------------------------------------------- 1 | package JZOffer2; 2 | 3 | public class Main27 { 4 | public TreeNode mirrorTree(TreeNode root) { 5 | if(root == null){ 6 | return null; 7 | } 8 | TreeNode left = mirrorTree(root.left); 9 | TreeNode right = mirrorTree(root.right); 10 | root.left = right; 11 | root.right = left; 12 | return root; 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/JZOffer2/Main27_1.java: -------------------------------------------------------------------------------- 1 | package JZOffer2; 2 | 3 | import java.util.Stack; 4 | 5 | public class Main27_1 { 6 | public TreeNode mirrorType(TreeNode root){ 7 | if(root == null){ 8 | return null; 9 | } 10 | Stack stack = new Stack(){{add(root);}}; 11 | while(!stack.isEmpty()){ 12 | TreeNode node = stack.pop(); 13 | if(node.left != null){ 14 | stack.add(node.left); 15 | } 16 | if(node.right != null){ 17 | stack.add(node.right); 18 | } 19 | TreeNode tmp = node.left; 20 | node.left = node.right; 21 | node.right = tmp; 22 | } 23 | return root; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/JZOffer2/Main28.java: -------------------------------------------------------------------------------- 1 | package JZOffer2; 2 | 3 | public class Main28 { 4 | public boolean isSymmetric(TreeNode root) { 5 | return isSame(root, root); 6 | } 7 | 8 | public boolean isSame(TreeNode root, TreeNode mirror){ 9 | if(root == null && mirror == null){ 10 | return true; 11 | } 12 | if(root == null || mirror == null){ 13 | return false; 14 | } 15 | return root.val == mirror.val&&isSame(root.left, mirror.right) && isSame(root.right, mirror.left); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/JZOffer2/Main32.java: -------------------------------------------------------------------------------- 1 | package JZOffer2; 2 | 3 | import java.util.*; 4 | 5 | public class Main32 { 6 | public int[] levelOrder(TreeNode root) { 7 | if(root == null){ 8 | return new int[0]; 9 | } 10 | Deque queue = new ArrayDeque<>(); 11 | queue.add(root); 12 | List result = new ArrayList<>(); 13 | while (!queue.isEmpty()){ 14 | TreeNode temp = queue.pollFirst(); 15 | result.add(temp.val); 16 | if(temp.left != null){ 17 | queue.add(temp.left); 18 | } 19 | if(temp.right != null){ 20 | queue.add(temp.right); 21 | } 22 | } 23 | return result.stream().mapToInt(Integer::valueOf).toArray(); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/JZOffer2/Main32II.java: -------------------------------------------------------------------------------- 1 | package JZOffer2; 2 | 3 | import java.util.ArrayList; 4 | import java.util.LinkedList; 5 | import java.util.List; 6 | import java.util.Queue; 7 | 8 | public class Main32II { 9 | public List> levelOrder(TreeNode root) { 10 | Queue queue = new LinkedList<>(); 11 | List> res = new ArrayList<>(); 12 | if(root != null) queue.add(root); 13 | while (!queue.isEmpty()){ 14 | List tmp = new ArrayList<>(); 15 | for(int i = queue.size(); i>0; i--){ 16 | TreeNode node = queue.poll(); 17 | tmp.add(node.val); 18 | if(node.left != null) queue.add(node.left); 19 | if(node.right != null) queue.add(node.right); 20 | } 21 | res.add(tmp); 22 | } 23 | return res; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/JZOffer2/Main44.java: -------------------------------------------------------------------------------- 1 | package JZOffer2; 2 | 3 | public class Main44 { 4 | /** 5 | * 将101112,...中的每一位称为数位，记为 n; 6 | * 将10,11,12,...称为数字，记为 num; 7 | * 数字10是一个两位数，称此数字的位数为2，记为 digit; 8 | * 每digit位数的起始数字（即:1,10,100,...)，记为start 9 | * 可推出各digit下的数位数量count的计算公式：count = 9 * start * digit 10 | * @param n 11 | * @return 12 | */ 13 | public int findNthDigit(int n) { 14 | int digit = 1; 15 | long start = 1; 16 | long count = 9; 17 | while (n > count) { 18 | n -= count; 19 | digit += 1; 20 | start *= 10; 21 | count = digit * start * 9; 22 | } 23 | long num = start + (n - 1) / digit; 24 | return Long.toString(num).charAt((n - 1) % digit) - '0'; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/JZOffer2/Main45.java: -------------------------------------------------------------------------------- 1 | package JZOffer2; 2 | 3 | public class Main45 { 4 | public String minNumber(int[] nums) { 5 | int n = nums.length; 6 | return null; 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /src/JZOffer2/Main46.java: -------------------------------------------------------------------------------- 1 | package JZOffer2; 2 | 3 | public class Main46 { 4 | public int translateNum(int num) { 5 | String str = String.valueOf(num); 6 | int[] dp = new int[str.length() + 1]; 7 | dp[0] = 1; dp[1] = 1; 8 | for (int i = 2; i <= str.length(); i++) { 9 | String sub = str.substring(i - 2, i); 10 | if(sub.compareTo("10") >= 0 && sub.compareTo("25") <= 0) { 11 | dp[i] = dp[i - 1] + dp[i - 2]; 12 | } else { 13 | dp[i] = dp[i - 1]; 14 | } 15 | } 16 | return dp[str.length()]; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/JZOffer2/Main47.java: -------------------------------------------------------------------------------- 1 | package JZOffer2; 2 | 3 | public class Main47 { 4 | public int maxValue(int[][] grid) { 5 | int n = grid.length; 6 | int m = grid[0].length; 7 | int[][] dp = new int[n][m]; 8 | dp[0][0] = grid[0][0]; 9 | for(int j=1; j res = new ArrayList<>(); 10 | Stack stack = new Stack<>(); 11 | while (root != null || !stack.isEmpty()) 12 | { 13 | if(root != null){ 14 | stack.push(root); 15 | root=root.left; 16 | } 17 | else{ 18 | root = stack.pop(); 19 | res.add(root.val); 20 | root=root.right; 21 | } 22 | } 23 | return res.get(res.size() - k); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/JZOffer2/Main56I.java: -------------------------------------------------------------------------------- 1 | package JZOffer2; 2 | 3 | public class Main56I { 4 | public int[] singleNumbers(int[] nums) { 5 | int res = 0; 6 | for (int num : nums) { 7 | res ^= num; 8 | } 9 | int div = 1; 10 | while ((div & res) == 0){ 11 | div <<= 1; 12 | } 13 | int a = 0, b = 0; 14 | for (int num : nums) { 15 | if ((div & num) != 0) { 16 | a ^= num; 17 | } else { 18 | b ^= num; 19 | } 20 | } 21 | return new int[]{a, b}; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/JZOffer2/Main58II.java: -------------------------------------------------------------------------------- 1 | package JZOffer2; 2 | 3 | public class Main58II { 4 | public String reverseLeftWords(String s, int n) { 5 | StringBuilder sb = new StringBuilder(); 6 | for (int i = n; i < s.length(); i++) { 7 | sb.append(s.charAt(i)); 8 | } 9 | for (int i = 0; i < n; i++) { 10 | sb.append(s.charAt(i)); 11 | } 12 | return sb.toString(); 13 | } 14 | 15 | public String reverseLeftWords1(String s, int n) { 16 | StringBuilder res = new StringBuilder(); 17 | for(int i = n; i < n + s.length(); i++) 18 | res.append(s.charAt(i % s.length())); 19 | return res.toString(); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/JZOffer2/Main63.java: -------------------------------------------------------------------------------- 1 | package JZOffer2; 2 | 3 | /** 4 | * dp[i]代表以prices[i]为结尾的子数组的最大利润（以下简称为前i日的最大利润） 5 | * 前i日最大利润 = max(前(i-1)日最大利润，第i日价格 - 前i日最低价格） 6 | * dp[i] = max(dp[i-1], prices[i] - min(prices[0:i])) 7 | */ 8 | public class Main63 { 9 | public int maxProfit(int[] prices) { 10 | int cost = Integer.MAX_VALUE, profit = 0; 11 | for (int price : prices) { 12 | cost = Math.min(cost, price); 13 | profit = Math.max(profit, price - cost); 14 | } 15 | return profit; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/JZOffer2/Main64.java: -------------------------------------------------------------------------------- 1 | package JZOffer2; 2 | 3 | public class Main64 { 4 | public int sumNums(int n) { 5 | boolean flag = n > 0 && (n += sumNums(n - 1)) > 0; 6 | return n; 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /src/JZOffer2/Main65.java: -------------------------------------------------------------------------------- 1 | package JZOffer2; 2 | 3 | /** 4 | * 无进位和n 与 进位c 的计算公式如下： 5 | * n=a⊕b 非进位和：异或运算 6 | * c=a&b<<1 进位：与运算 + 左移一位 7 | * （和 s ）=（非进位和 n ）+（进位 c ）。即可将 s = a + b 转化为： 8 | * s=a+b => s=n+c 9 | * 循环求 n 和 c ，直至进位 c = 0 ；此时 s = n ，返回 n 即可。 10 | */ 11 | public class Main65 { 12 | public int add(int a, int b) { 13 | while(b != 0) { // 当进位为 0 时跳出 14 | int c = (a & b) << 1; // c = 进位 15 | a ^= b; // a = 非进位和 16 | b = c; // b = 进位 17 | } 18 | return a; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/JZOffer2/Main68.java: -------------------------------------------------------------------------------- 1 | package JZOffer2; 2 | 3 | public class Main68 { 4 | public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { 5 | while(root!=null){ 6 | if(root.val < p.val && root.val < q.val){ 7 | root = root.right; 8 | } 9 | else if(root.val > p.val && root.val > q.val){ 10 | root = root.left; 11 | } 12 | else{ 13 | break; 14 | } 15 | } 16 | return root; 17 | } 18 | 19 | public TreeNode lowestCommonAncestor1(TreeNode root, TreeNode p, TreeNode q) { 20 | if(root.val < p.val && root.val < q.val) 21 | return lowestCommonAncestor1(root.right, p, q); 22 | if(root.val > p.val && root.val > q.val) 23 | return lowestCommonAncestor1(root.left, p, q); 24 | return root; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/JZOffer2/TreeNode.java: -------------------------------------------------------------------------------- 1 | package JZOffer2; 2 | 3 | class TreeNode { 4 | int val; 5 | TreeNode left; 6 | TreeNode right; 7 | 8 | TreeNode() { 9 | } 10 | 11 | TreeNode(int val) { 12 | this.val = val; 13 | } 14 | 15 | TreeNode(int val, TreeNode left, TreeNode right) { 16 | this.val = val; 17 | this.left = left; 18 | this.right = right; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/JZOfferTuJi/Main11.java: -------------------------------------------------------------------------------- 1 | package JZOfferTuJi; 2 | 3 | import java.util.HashMap; 4 | 5 | // 前缀和 + 哈希表 6 | public class Main11 { 7 | public int findMaxLength(int[] nums) { 8 | HashMap map = new HashMap<>(); // 初始化一个空的哈希表 9 | int pre_sum = 0; // 初始化pre_sum=0的前缀和变量 10 | int max_length = 0; 11 | /* 12 | 规定空的前缀的结束下标为-1，由于空的前缀的元素和为0，因此在遍历之前，首先在哈希表中存入键值对(0, -1). 13 | */ 14 | map.put(0, -1); 15 | for(int i=0; i=0; i--){ 12 | rear[i] = rear[i+1] + nums[i+1]; 13 | } 14 | for(int i=0; i 0){ 9 | int m = matrix[0].length; 10 | sums = new int[n][m+1]; 11 | for(int i=0; i 0){ 14 | ans.append('1'); 15 | } 16 | ans.reverse(); 17 | return ans.toString(); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/JZOfferTuJi/Main20.java: -------------------------------------------------------------------------------- 1 | package JZOfferTuJi; 2 | 3 | public class Main20 { 4 | public int countSubstrings(String s) { 5 | int length = s.length(); 6 | int count = 0, left, right; 7 | int i = 0; 8 | while(i < 2 * length - 1){ 9 | left = i / 2; 10 | right = i / 2 + i % 2; 11 | while (left>=0 && right stack = new Stack<>(); 8 | int index = 0, length = asteroids.length; 9 | while (index < length){ 10 | if(stack.isEmpty() || stack.peek() < 0 || asteroids[index] > 0){ 11 | stack.push(asteroids[index]); 12 | }else if(stack.peek() <= -asteroids[index]){ 13 | if(stack.pop() < -asteroids[index]){ 14 | continue; 15 | } 16 | } 17 | index++; 18 | } 19 | int[] ret = new int[stack.size()]; 20 | for(int i = ret.length - 1; i >= 0; i--){ 21 | ret[i] = stack.pop(); 22 | } 23 | return ret; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/JZOfferTuJi/Main38.java: -------------------------------------------------------------------------------- 1 | package JZOfferTuJi; 2 | 3 | import java.util.Stack; 4 | 5 | public class Main38 { 6 | public int[] dailyTemperatures(int[] temperatures) { 7 | Stack stack = new Stack<>(); 8 | int[] position = new int[temperatures.length]; 9 | int index = 0; 10 | while (index < temperatures.length){ 11 | while (!stack.isEmpty() && temperatures[stack.peek()] < temperatures[index]){ 12 | int res = stack.pop(); 13 | position[res] = index - res; 14 | } 15 | stack.push(index++); 16 | } 17 | return position; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/JZOfferTuJi/Main4.java: -------------------------------------------------------------------------------- 1 | package JZOfferTuJi; 2 | 3 | /* 4 | * 由于数组中的元素都在int(即32位整数)范围内，因此我们可以依次计算答案的每一个二进制位是0还是1. 5 | * 具体地,考虑答案的第i个二进制位(i从0开始编号),它可能为0或1. 6 | * 对于数组中非答案的元素，每一个元素都出现了3次，对应着第i个二进制位的3个0或3个1，无论是哪一种情况， 7 | * 它们的和都是3的倍数(即和为0或3)。 8 | * 因此:答案的第i个二进制位就是数组中所有元素的第i个二进制位之和除以3的余数。 9 | * */ 10 | public class Main4 { 11 | public int singleNumber(int[] nums) { 12 | int ans = 0; 13 | for(int i=0; i<32; ++i){ 14 | int total = 0; 15 | for(int num: nums){ 16 | total += ((num >> i) & 1); 17 | } 18 | if(total % 3 !=0){ 19 | ans |= (1 << i); 20 | } 21 | } 22 | return ans; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/JZOfferTuJi/Main45.java: -------------------------------------------------------------------------------- 1 | package JZOfferTuJi; 2 | 3 | import java.util.LinkedList; 4 | import java.util.Queue; 5 | 6 | public class Main45 { 7 | Queue queue = new LinkedList<>(); 8 | public int findBottomLeftValue(TreeNode root) { 9 | queue.add(root); 10 | int left = 0; 11 | while (!queue.isEmpty()){ 12 | int length = queue.size(); 13 | left = queue.peek().val; 14 | for(int i = 0; i < length; i++){ 15 | TreeNode node = queue.poll(); 16 | if(node.left != null){ 17 | queue.add(node.left); 18 | } 19 | if(node.right != null){ 20 | queue.add(node.right); 21 | } 22 | } 23 | } 24 | return left; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/JZOfferTuJi/Main53.java: -------------------------------------------------------------------------------- 1 | package JZOfferTuJi; 2 | 3 | import java.util.ArrayDeque; 4 | import java.util.Deque; 5 | 6 | public class Main53 { 7 | public TreeNode inorderSuccessor(TreeNode root, TreeNode p) { 8 | Deque stack = new ArrayDeque<>(); 9 | TreeNode prev = null, curr = root; 10 | while(!stack.isEmpty() || curr!=null){ 11 | while(curr != null){ 12 | stack.push(curr); 13 | curr = curr.left; 14 | } 15 | curr = stack.pop(); 16 | if(prev == p){ 17 | return curr; 18 | } 19 | prev = curr; 20 | curr = curr.right; 21 | } 22 | return null; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/JZOfferTuJi/Main57.java: -------------------------------------------------------------------------------- 1 | package JZOfferTuJi; 2 | 3 | import java.util.TreeSet; 4 | 5 | public class Main57 { 6 | public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) { 7 | int n = nums.length; 8 | TreeSet set = new TreeSet<>(); 9 | for(int i = 0; i < n; i++){ 10 | Long ceiling = set.ceiling((long) nums[i] - (long) t); 11 | if (ceiling != null && ceiling <= (long) nums[i] + (long) t) { 12 | return true; 13 | } 14 | set.add((long) nums[i]); 15 | if (i >= k) { 16 | set.remove((long) nums[i - k]); 17 | } 18 | } 19 | return false; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/JZOfferTuJi/Main62.java: -------------------------------------------------------------------------------- 1 | package JZOfferTuJi; 2 | 3 | public class Main62 { 4 | /** Initialize your data structure here. */ 5 | public Main62() { 6 | 7 | } 8 | 9 | /** Inserts a word into the trie. */ 10 | public void insert(String word) { 11 | 12 | } 13 | 14 | /** Returns if the word is in the trie. */ 15 | public boolean search(String word) { 16 | return false; 17 | } 18 | 19 | /** Returns if there is any word in the trie that starts with the given prefix. */ 20 | public boolean startsWith(String prefix) { 21 | return false; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/JZOfferTuJi/Main66.java: -------------------------------------------------------------------------------- 1 | package JZOfferTuJi; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | 6 | public class Main66 { 7 | } 8 | 9 | class MapSum { 10 | Map map; 11 | 12 | /** Initialize your data structure here. */ 13 | public MapSum() { 14 | map = new HashMap<>(); 15 | } 16 | 17 | public void insert(String key, int val) { 18 | map.put(key, val); 19 | } 20 | 21 | public int sum(String prefix) { 22 | int sum = 0; 23 | for (Map.Entry entry : map.entrySet()) { 24 | if(entry.getKey().startsWith(prefix)){ 25 | sum += entry.getValue(); 26 | } 27 | } 28 | return sum; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/JZOfferTuJi/Main70.java: -------------------------------------------------------------------------------- 1 | package JZOfferTuJi; 2 | 3 | public class Main70 { 4 | public int singleNonDuplicate(int[] nums) { 5 | int low = 0, high = nums.length - 1; 6 | while (low < high) { 7 | int mid = (high - low) / 2 + low; 8 | if(nums[mid] == nums[mid ^ 1]) { 9 | low = mid + 1; 10 | } else { 11 | high = mid; 12 | } 13 | } 14 | return nums[low]; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/JZOfferTuJi/Main8.java: -------------------------------------------------------------------------------- 1 | package JZOfferTuJi; 2 | 3 | public class Main8 { 4 | public int minSubArrayLen(int target, int[] nums) { 5 | int n = nums.length; 6 | if (n == 0){ 7 | return 0; 8 | } 9 | int ans = Integer.MAX_VALUE, start = 0, end = 0, sum = 0; 10 | while (end < n){ 11 | sum += nums[end]; 12 | while (sum >= target){ 13 | ans = Math.min(ans, end - start + 1); 14 | sum -= nums[start++]; 15 | } 16 | end++; 17 | } 18 | return ans == Integer.MAX_VALUE ? 0 : ans; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/JZOfferTuJi/Main9.java: -------------------------------------------------------------------------------- 1 | package JZOfferTuJi; 2 | 3 | public class Main9 { 4 | public static int numSubarrayProductLessThanK(int[] nums, int k) { 5 | int left=0, ret=0, total=1; 6 | for(int right = 0; right < nums.length; right++){ 7 | total *= nums[right]; 8 | while (left <= right && total >= k){ 9 | total /= nums[left++]; 10 | } 11 | if(left <= right){ 12 | ret += right - left + 1; 13 | } 14 | } 15 | return ret; 16 | } 17 | 18 | public static void main(String[] args) { 19 | int[] nums = new int[]{10, 5, 2, 6}; 20 | numSubarrayProductLessThanK(nums, 100); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM10.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM10 { 4 | public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) { 5 | ListNode l1 = pHead1, l2 = pHead2; 6 | while(l1 != l2){ 7 | l1 = (l1==null)?pHead2:l1.next; 8 | l2 = (l2==null)?pHead1:l2.next; 9 | } 10 | return l1; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM15.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM15 { 4 | /** 5 | * 6 | * @param head ListNode类 7 | * @return ListNode类 8 | */ 9 | public ListNode deleteDuplicates (ListNode head) { 10 | if(head == null || head.next == null){ 11 | return head; 12 | } 13 | ListNode pre = head; 14 | ListNode cur = head.next; 15 | while (cur != null){ 16 | if(pre.val == cur.val){ 17 | pre.next = cur.next; 18 | }else { 19 | pre = pre.next; 20 | } 21 | cur = cur.next; 22 | } 23 | return head; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM17.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM17 { 4 | public int search (int[] nums, int target) { 5 | int length = nums.length; 6 | int left = 0, right = length - 1, mid; 7 | while (left <= right){ 8 | mid = (left + right) / 2; 9 | if(nums[mid] == target){ 10 | return mid; 11 | }else if(nums[mid] > target){ 12 | right = mid - 1; 13 | }else{ 14 | left = mid + 1; 15 | } 16 | } 17 | return -1; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM18.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM18 { 4 | public boolean Find(int target, int [][] array) { 5 | int m = array.length; 6 | if(m == 0) return false; 7 | int n = array[0].length; 8 | if(n == 0) return false; 9 | int r = 0, c = n-1; // 右上角元素 10 | while (r < m && c >= 0){ 11 | if(target == array[r][c]){ 12 | return true; 13 | }else if(target > array[r][c]){ 14 | ++r; 15 | }else { 16 | --c; 17 | } 18 | } 19 | return false; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM19.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM19 { 4 | /** 5 | * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可 6 | * 7 | * 8 | * @param nums int整型一维数组 9 | * @return int整型 10 | */ 11 | public int findPeakElement (int[] nums) { 12 | int length = nums.length; 13 | int left = 0, right = length - 1, mid = 0; 14 | while (left <= right){ 15 | mid = (left + right) / 2; 16 | if(nums[mid] > nums[mid+1]){ 17 | right = mid; 18 | }else{ 19 | left = mid + 1; 20 | } 21 | } 22 | return right; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM21.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM21 { 4 | public int minNumberInRotateArray(int [] array) { 5 | int left = 0; 6 | int right = array.length - 1; 7 | while(left < right){ 8 | int mid = (left + right) / 2; 9 | //最小的数字在mid右边 10 | if(array[mid] > array[right]) 11 | left = mid + 1; 12 | //无法判断，一个一个试 13 | else if(array[mid] == array[right]) 14 | right--; 15 | //最小数字要么是mid要么在mid左边 16 | else 17 | right = mid; 18 | } 19 | return array[left]; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM31.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM31 { 4 | boolean isSymmetrical(TreeNode pRoot) { 5 | return recursion(pRoot, pRoot); 6 | } 7 | 8 | private boolean recursion(TreeNode root1, TreeNode root2) { 9 | if(root1 == null && root2 == null){ 10 | return true; 11 | } 12 | if(root1 == null || root2 == null){ 13 | return false; 14 | } 15 | if(root1.val != root2.val){ 16 | return false; 17 | } 18 | return recursion(root1.left, root2.right) && recursion(root1.right, root2.left); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM32.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM32 { 4 | /** 5 | * 6 | * @param t1 TreeNode类 7 | * @param t2 TreeNode类 8 | * @return TreeNode类 9 | */ 10 | public TreeNode mergeTrees (TreeNode t1, TreeNode t2) { 11 | if(t1 == null && t2 == null){ 12 | return null; 13 | } 14 | if(t1 == null){ 15 | return t2; 16 | } 17 | if(t2 == null) { 18 | return t1; 19 | } 20 | TreeNode head = new TreeNode(t1.val + t2.val); 21 | head.left = mergeTrees(t1.left, t2.left); 22 | head.right = mergeTrees(t1.right, t2.right); 23 | return head; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM33.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM33 { 4 | /** 5 | * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可 6 | * 7 | * 8 | * @param pRoot TreeNode类 9 | * @return TreeNode类 10 | */ 11 | public TreeNode Mirror (TreeNode pRoot) { 12 | if(pRoot == null){ 13 | return null; 14 | } 15 | TreeNode temp = Mirror(pRoot.left); 16 | pRoot.left = Mirror(pRoot.right); 17 | pRoot.right = temp; 18 | return pRoot; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM38.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | import java.util.ArrayList; 4 | 5 | public class BM38 { 6 | public int lowestCommonAncestor (TreeNode root, int o1, int o2) { 7 | return helper(root, o1, o2).val; 8 | } 9 | 10 | private TreeNode helper(TreeNode root, int o1, int o2) { 11 | if(root == null || root.val == o1 || root.val == o2){ 12 | return root; 13 | } 14 | TreeNode left = helper(root.left, o1, o2); 15 | TreeNode right = helper(root.right, o1, o2); 16 | //如果left为空，说明这两个节点在root结点的右子树上，我们只需要返回右子树查找的结果即可 17 | if (left == null) 18 | return right; 19 | //同上 20 | if (right == null) 21 | return left; 22 | //如果left和right都不为空，说明这两个节点一个在root的左子树上一个在root的右子树上， 23 | //我们只需要返回cur结点即可。 24 | return root; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM42.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | import java.util.Stack; 4 | 5 | public class BM42 { 6 | Stack stack1 = new Stack(); 7 | Stack stack2 = new Stack(); 8 | 9 | public void push(int node) { 10 | stack1.push(node); 11 | } 12 | 13 | public int pop() { 14 | if(stack2.size() != 0){ 15 | return stack2.pop(); 16 | }else{ 17 | while (!stack1.isEmpty()){ 18 | stack2.push(stack1.pop()); 19 | } 20 | return stack2.pop(); 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM43.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | import java.util.Stack; 4 | 5 | public class BM43 { 6 | Stack minStack = new Stack<>(); 7 | Stack stack = new Stack<>(); 8 | 9 | public void push(int node) { 10 | stack.push(node); 11 | if(minStack.size() == 0){ 12 | minStack.push(node); 13 | }else{ 14 | int min = minStack.peek(); 15 | min = Math.min(min, node); 16 | minStack.push(min); 17 | } 18 | } 19 | 20 | public void pop() { 21 | stack.pop(); 22 | minStack.pop(); 23 | } 24 | 25 | public int top() { 26 | return stack.peek(); 27 | } 28 | 29 | public int min() { 30 | return minStack.peek(); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM48.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | import java.util.ArrayList; 4 | 5 | public class BM48 { 6 | ArrayList list = new ArrayList<>(); 7 | 8 | public void Insert(Integer num) { 9 | if(list.size() == 0){ 10 | list.add(num); 11 | }else{ 12 | int left = 0, right = list.size() - 1; 13 | while (left <= right && list.get(left) <= num){ 14 | left ++; 15 | } 16 | list.add(left, num); 17 | } 18 | } 19 | 20 | public Double GetMedian() { 21 | if(list.size() % 2 == 0){ 22 | return (list.get(list.size() / 2) + list.get(list.size() / 2 - 1)) * 1.0 / 2; 23 | }else{ 24 | return list.get(list.size() / 2) * 1.0; 25 | } 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM50.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | import java.util.HashMap; 4 | 5 | public class BM50 { 6 | public int[] twoSum (int[] numbers, int target) { 7 | int[] res = new int[0]; 8 | HashMap map = new HashMap<>(); 9 | for (int i = 0; i < numbers.length; i++) { 10 | int temp = target - numbers[i]; 11 | if(map.containsKey(temp)){ 12 | res = new int[]{map.get(temp) + 1, i + 1}; 13 | break; 14 | }else{ 15 | map.put(numbers[i], i); 16 | } 17 | } 18 | return res; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM51.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | import java.util.Arrays; 4 | 5 | /** 6 | * 候选法 7 | * 具体做法： 8 | * 初始化：候选人cond = -1， 候选人的投票次数cnt = 0 9 | * 遍历数组，如果cnt=0， 表示没有候选人，则选取当前数为候选人，++cnt 10 | * 否则，如果cnt > 0, 表示有候选人，如果当前数=cond，则++cnt，否则--cnt 11 | * 直到数组遍历完毕，最后检查cond是否为众数 12 | */ 13 | public class BM51 { 14 | public int MoreThanHalfNum_Solution(int [] array) { 15 | int cond = -1, cnt = 0; 16 | for (int i = 0; i < array.length; i++) { 17 | if(cnt == 0){ 18 | cond = array[i]; 19 | cnt ++; 20 | }else if(cond == array[i]){ 21 | cnt ++; 22 | } else if (cond != array[i]) { 23 | cnt --; 24 | } 25 | } 26 | return cond; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM53.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM53 { 4 | public int minNumberDisappeared (int[] nums) { 5 | int n = nums.length; 6 | for (int i = 0; i < nums.length; i++) { 7 | if(nums[i] <= 0){ 8 | nums[i] = n + 1; 9 | } 10 | } 11 | for (int i = 0; i < nums.length; i++) { 12 | if(Math.abs(nums[i]) <= n){ 13 | nums[Math.abs(nums[i]) - 1] = - 1 * nums[Math.abs(nums[i]) - 1]; 14 | } 15 | } 16 | for (int i = 0; i < nums.length; i++) { 17 | if(nums[i] > 0){ 18 | return i + 1; 19 | } 20 | } 21 | return n + 1; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM6.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM6 { 4 | public boolean hasCycle(ListNode head) { 5 | ListNode slow = head; 6 | ListNode fast = head; 7 | while (fast != null && fast.next != null){ 8 | slow = slow.next; 9 | fast = fast.next.next; 10 | if(slow == fast){ 11 | return true; 12 | } 13 | } 14 | return false; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM60.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | import java.util.ArrayList; 4 | 5 | public class BM60 { 6 | public void recursion(int left, int right, String temp, ArrayList res, int n){ 7 | //左右括号都用完了，就加入结果 8 | if(left == n && right == n){ 9 | res.add(temp); 10 | return; 11 | } 12 | //使用一次左括号 13 | if(left < n){ 14 | recursion(left + 1, right, temp + "(", res, n); 15 | } 16 | //使用右括号个数必须少于左括号 17 | if(right < n && left > right){ 18 | recursion(left, right + 1, temp + ")", res, n); 19 | } 20 | } 21 | public ArrayList generateParenthesis (int n) { 22 | //记录结果 23 | ArrayList res = new ArrayList(); 24 | //递归 25 | recursion(0, 0, "", res, n); 26 | return res; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM62.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM62 { 4 | public int Fibonacci(int n) { 5 | int[] fib = new int[n+1]; 6 | fib[1] = 1; 7 | fib[2] = 1; 8 | for (int i = 3; i <= n; i++) { 9 | fib[i] = fib[i-1] + fib[i-2]; 10 | } 11 | return fib[n]; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM63.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM63 { 4 | public int jumpFloor(int target) { 5 | int[] jump = new int[target + 1]; 6 | if(target == 1){ 7 | return 1; 8 | } 9 | if(target == 2){ 10 | return 2; 11 | } 12 | jump[0] = 1; 13 | jump[1] = 1; 14 | for (int i = 2; i <= target; i++) { 15 | jump[i] = jump[i-1] + jump[i-2]; 16 | } 17 | return jump[target]; 18 | } 19 | } 20 | 21 | 22 | class BM63_1{ 23 | public int jumpFloor(int target) { 24 | //这里第0项为1，第1项为1 25 | if(target <= 1) 26 | return 1; 27 | else 28 | //递归子问题相加 29 | return jumpFloor(target - 1) + jumpFloor(target - 2); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM64.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM64 { 4 | public int minCostClimbingStairs (int[] cost) { 5 | int n = cost.length; 6 | if(n == 1){ 7 | return 0; 8 | } 9 | if(n == 2){ 10 | return Math.min(cost[0], cost[1]); 11 | } 12 | int[] dp = new int[n+1]; 13 | dp[1] = 0; 14 | dp[2] = Math.min(cost[0], cost[1]); 15 | for (int i = 3; i <= n; i++) { 16 | dp[i] = Math.min(dp[i-1] + cost[i-1], dp[i-2] + cost[i-2]); 17 | } 18 | return dp[n]; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM66.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM66 { 4 | public String LCS (String str1, String str2) { 5 | // dp[i][j]表示到 str1 第 i 个到str2 第 j 个为止的公共子串长度 6 | int n = str1.length(); 7 | int m = str2.length(); 8 | int[][] dp = new int[n + 1][m + 1]; 9 | int max = 0; 10 | int pos = 0; 11 | for (int i = 1; i <= n; i++) { 12 | for (int j = 1; j <= m; j++) { 13 | if(str1.charAt(i-1) == str2.charAt(j-1)){ 14 | dp[i][j] = dp[i-1][j-1] + 1; 15 | }else{ 16 | dp[i][j] = 0; 17 | } 18 | if(dp[i][j] > max){ 19 | max = dp[i][j]; 20 | pos = i - 1; 21 | } 22 | } 23 | } 24 | return str1.substring(pos - max + 1, pos + 1); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM67.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM67 { 4 | public int uniquePaths (int m, int n) { 5 | int[][] dp = new int[m][n]; 6 | for (int i = 0; i < m; i++) { 7 | dp[i][0] = 1; 8 | } 9 | for (int i = 0; i < n; i++) { 10 | dp[0][i] = 1; 11 | } 12 | for (int i = 1; i < m; i++) { 13 | for (int j = 1; j < n; j++) { 14 | dp[i][j] = dp[i-1][j] + dp[i][j-1]; 15 | } 16 | } 17 | return dp[m-1][n-1]; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM68.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM68 { 4 | public int minPathSum (int[][] matrix) { 5 | int n = matrix.length; 6 | int m = matrix[0].length; 7 | int[][] dp = new int[n][m]; 8 | dp[0][0] = matrix[0][0]; 9 | for (int i = 1; i < n; i++) { 10 | dp[i][0] = dp[i-1][0] + matrix[i][0]; 11 | } 12 | for (int i = 1; i < m; i++) { 13 | dp[0][i] = dp[0][i-1] + matrix[0][i]; 14 | } 15 | for (int i = 1; i < n; i++) { 16 | for (int j = 1; j < m; j++) { 17 | dp[i][j] = Math.min(dp[i-1][j], dp[i][j-1]) + matrix[i][j]; 18 | } 19 | } 20 | return dp[n-1][m-1]; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM7.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM7 { 4 | public ListNode EntryNodeOfLoop(ListNode pHead) { 5 | if(pHead == null) return null; 6 | // 定义快慢指针 7 | ListNode slow = pHead; 8 | ListNode fast = pHead; 9 | while(fast != null && fast.next !=null){ 10 | // 快指针是慢指针的两倍速度 11 | fast = fast.next.next; 12 | slow = slow.next; 13 | // 记录快慢指针第一次相遇的结点 14 | if(slow == fast) break; 15 | } 16 | // 若是快指针指向null,则不存在环 17 | if(fast == null || fast.next == null) return null; 18 | // 重新指向链表头部 19 | fast = pHead; 20 | // 与第一次相遇的结点相同速度出发，相遇结点为入口结点。推导可以通过画图得出。 21 | while (fast != slow){ 22 | fast = fast.next; 23 | slow = slow.next; 24 | } 25 | return fast; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM70.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | import java.util.Arrays; 4 | 5 | public class BM70 { 6 | public int minMoney (int[] arr, int aim) { 7 | // 小于 1 都返回 0 8 | if(aim < 1){ 9 | return 0; 10 | } 11 | int[] dp = new int[aim + 1]; 12 | // 一开始设置为最大值 aim + 1，因此货币最小 1 元，即货币数不会超过aim. 13 | Arrays.fill(dp, aim + 1); 14 | dp[0] = 0; 15 | // 遍历 1 - aim 元 16 | for (int i = 1; i <= aim; i++) { 17 | // 每种面值的货币都要枚举 18 | for (int j = 0; j < arr.length; j++) { 19 | // 如果面值不超过要凑的钱才能用 20 | if(arr[j] <= i){ 21 | dp[i] = Math.min(dp[i], dp[i - arr[j]] + 1); 22 | } 23 | } 24 | } 25 | return dp[aim] > aim ? -1 : dp[aim]; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM71.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | import java.util.Arrays; 4 | 5 | public class BM71 { 6 | public int LIS (int[] arr) { 7 | if(arr.length == 0){ 8 | return 0; 9 | } 10 | int[] dp = new int[arr.length]; 11 | Arrays.fill(dp, 1); 12 | int res = 1; 13 | for (int i = 1; i < arr.length; i++) { 14 | for (int j = 0; j < i; j++) { 15 | if(arr[i] > arr[j] && dp[i] < dp[j] + 1){ 16 | dp[i] = dp[j] + 1; 17 | res = Math.max(dp[i], res); 18 | } 19 | } 20 | } 21 | return res; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM72.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM72 { 4 | public int FindGreatestSumOfSubArray(int[] array) { 5 | int n = array.length; 6 | int[] dp = new int[n]; 7 | dp[0] = array[0]; 8 | int max = dp[0]; 9 | for (int i = 1; i < n; i++) { 10 | dp[i] = Math.max(dp[i - 1] + array[i], array[i]); 11 | max = Math.max(max, dp[i]); 12 | } 13 | return max; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM75.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM75 { 4 | public int editDistance (String str1, String str2) { 5 | return 0; 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM78.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM78 { 4 | public int rob (int[] nums) { 5 | if(nums.length == 1){ 6 | return nums[0]; 7 | } 8 | if(nums.length == 2){ 9 | return Math.max(nums[0], nums[1]); 10 | } 11 | int[] dp = new int[nums.length]; 12 | dp[0] = nums[0]; 13 | dp[1] = Math.max(nums[0], nums[1]); 14 | for (int i = 2; i < nums.length; i++) { 15 | dp[i] = Math.max(dp[i-2] + nums[i], dp[i-1]); 16 | } 17 | return dp[nums.length - 1]; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM8.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM8 { 4 | /** 5 | * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可 6 | * 7 | * 8 | * @param pHead ListNode类 9 | * @param k int整型 10 | * @return ListNode类 11 | */ 12 | public ListNode FindKthToTail (ListNode pHead, int k) { 13 | ListNode fast = pHead; 14 | ListNode slow = pHead; 15 | //快指针先行k步 16 | for(int i = 0; i < k; i++){ 17 | if(fast != null) 18 | fast = fast.next; 19 | //达不到k步说明链表过短，没有倒数k 20 | else 21 | return null; 22 | } 23 | //快慢指针同步，快指针先到底，慢指针指向倒数第k个 24 | while(fast != null){ 25 | fast = fast.next; 26 | slow = slow.next; 27 | } 28 | return slow; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM80.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM80 { 4 | public int maxProfit (int[] prices) { 5 | if(prices.length == 0){ 6 | return 0; 7 | } 8 | int min = prices[0]; 9 | int profit = 0; 10 | for (int i = 0; i < prices.length; i++) { 11 | min = Math.min(min, prices[i]); 12 | profit = Math.max(profit, prices[i] - min); 13 | } 14 | return profit; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM81.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM81 { 4 | public int maxProfit (int[] prices) { 5 | int n = prices.length; 6 | int[][] dp = new int[n][2]; 7 | dp[0][0] = 0; 8 | dp[0][1] = -prices[0]; 9 | for (int i = 1; i < n; i++) { 10 | dp[i][0] = Math.max(dp[i-1][0], dp[i-1][1] + prices[i]); 11 | dp[i][1] = Math.max(dp[i-1][1], dp[i-1][0] - prices[i]); 12 | } 13 | return Math.max(0, dp[n-1][0]); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM87.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM87 { 4 | public void merge(int A[], int m, int B[], int n) { 5 | int a = m-1; 6 | int b = n-1; 7 | for (int i = m+n-1; i >=0; i--) { 8 | if(b<0 || (a>=0 && A[a]>=B[b])){ 9 | A[i] = A[a]; 10 | a--; 11 | }else{ 12 | A[i] = B[b]; 13 | b--; 14 | } 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM88.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM88 { 4 | public boolean judge (String str) { 5 | int n = str.length(); 6 | int mid = n / 2, left, right; 7 | left = mid - 1; 8 | if(n % 2 == 1){ 9 | right = mid + 1; 10 | }else{ 11 | right = mid; 12 | } 13 | while (left >= 0 && right < n){ 14 | if(str.charAt(left--) != str.charAt(right++)){ 15 | return false; 16 | } 17 | } 18 | return true; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM91.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM91 { 4 | public String solve (String str) { 5 | StringBuffer sb = new StringBuffer(str); 6 | return sb.reverse().toString(); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM93.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM93 { 4 | public static int maxArea (int[] height) { 5 | if(height.length < 2){ 6 | return 0; 7 | } 8 | int left = 0, right = height.length - 1; 9 | int maxArea = 0; 10 | while (left < right){ 11 | int cur = Math.min(height[left], height[right]) * (right - left); 12 | maxArea = Math.max(maxArea, cur); 13 | if(height[left] < height[right]){ 14 | left ++; 15 | }else{ 16 | right --; 17 | } 18 | } 19 | return maxArea; 20 | } 21 | 22 | public static void main(String[] args) { 23 | int[] height = new int[]{1,7,3,2,4,5,8,2,7}; 24 | maxArea(height); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM94.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM94 { 4 | public long maxWater (int[] arr) { 5 | if(arr.length < 3){ 6 | return 0; 7 | } 8 | int left = 0, right = arr.length - 1; 9 | int leftBoundary = 0, rightBoundary = 0; 10 | int capacity = 0; 11 | while (left < right){ 12 | leftBoundary = Math.max(arr[left], leftBoundary); 13 | rightBoundary = Math.max(arr[right], rightBoundary); 14 | if(leftBoundary > rightBoundary){ 15 | capacity += rightBoundary - arr[right--]; 16 | }else{ 17 | capacity += leftBoundary - arr[left++]; 18 | } 19 | } 20 | return capacity; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM95.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | import java.util.Arrays; 4 | 5 | public class BM95 { 6 | public int candy (int[] arr) { 7 | int n = arr.length; 8 | if(n <= 1){ 9 | return n; 10 | } 11 | int[] num = new int[n]; 12 | Arrays.fill(num, 1); 13 | for (int i = 1; i < n; i++) { 14 | if(arr[i] > arr[i-1]){ 15 | num[i] = num[i-1] + 1; 16 | } 17 | } 18 | int res = num[n-1]; 19 | for (int i = n - 2; i >= 0; i--) { 20 | if(arr[i] > arr[i+1] && num[i] <= num[i+1]){ 21 | num[i] = num[i+1] + 1; 22 | } 23 | res += num[i]; 24 | } 25 | return res; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM97.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM97 { 4 | public int[] solve (int n, int m, int[] a) { 5 | m = m % n; 6 | reverse(0, n-m, a); 7 | reverse(n-m, n, a); 8 | reverse(0, n, a); 9 | return a; 10 | } 11 | 12 | void reverse(int start, int end, int[] arr){ 13 | for (int i = start; i < start + (end - start) / 2; i++) { 14 | int temp = arr[i]; 15 | arr[i] = arr[start+end-i-1]; 16 | arr[start+end-i-1] = temp; 17 | } 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/NiukeTOP101/BM99.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class BM99 { 4 | /** 5 | * step 1：遍历矩阵的下三角矩阵，将其与上三角矩阵对应的位置互换，其实就是数组下标交换后的互换。 6 | * step 2：遍历矩阵每一行，将每一行看成一个数组使用reverse函数翻转。 7 | */ 8 | public int[][] rotateMatrix(int[][] mat, int n) { 9 | // 矩阵转置 10 | for (int i = 0; i < n; i++) { 11 | for (int j = 0; j < n; j++) { 12 | // //交换上三角与下三角对应的元素 13 | int temp = mat[i][j]; 14 | mat[i][j] = mat[j][i]; 15 | mat[j][i] = temp; 16 | } 17 | } 18 | // 每行翻转 19 | for (int i = 0; i < n; i++) { 20 | for (int j = 0; j < n / 2; j++) { 21 | int temp = mat[i][j]; 22 | mat[i][j] = mat[i][n-j-1]; 23 | mat[i][n-j-1] = temp; 24 | } 25 | } 26 | return mat; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/NiukeTOP101/ListNode.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class ListNode { 4 | int val; 5 | ListNode next; 6 | ListNode(int x) { 7 | val = x; 8 | next = null; 9 | } 10 | } -------------------------------------------------------------------------------- /src/NiukeTOP101/TreeNode.java: -------------------------------------------------------------------------------- 1 | package NiukeTOP101; 2 | 3 | public class TreeNode { 4 | int val = 0; 5 | TreeNode left = null; 6 | TreeNode right = null; 7 | public TreeNode(int val) { 8 | this.val = val; 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /src/designPattern/adapter/classAdapter/Client.java: -------------------------------------------------------------------------------- 1 | package designPattern.adapter.classAdapter; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | // 创建计算机对象 6 | Computer computer = new Computer(); 7 | 8 | // 读取SD卡中的数据 9 | String msg = computer.readSD(new SDCardImpl()); 10 | 11 | System.out.println(msg); 12 | 13 | // 使用该电脑读取TF卡中的数据 14 | // 定义适配器类 15 | String s = computer.readSD(new SDAdapterTF()); 16 | System.out.println(s); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/designPattern/adapter/classAdapter/Computer.java: -------------------------------------------------------------------------------- 1 | package designPattern.adapter.classAdapter; 2 | 3 | /** 4 | * 计算机类 5 | */ 6 | public class Computer { 7 | // 从SD卡中读取数据 8 | public String readSD(SDCard sdCard){ 9 | if(sdCard == null){ 10 | throw new NullPointerException("SDCard is null"); 11 | } 12 | return sdCard.readSD(); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/designPattern/adapter/classAdapter/SDAdapterTF.java: -------------------------------------------------------------------------------- 1 | package designPattern.adapter.classAdapter; 2 | 3 | /** 4 | * 适配器类 5 | */ 6 | public class SDAdapterTF extends TFCardImpl implements SDCard{ 7 | @Override 8 | public String readSD() { 9 | System.out.println("Adapter read TFCard"); 10 | return readTF(); 11 | } 12 | 13 | @Override 14 | public void writeSD(String msg) { 15 | System.out.println("Adapter write TFCard"); 16 | writeTF(msg); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/designPattern/adapter/classAdapter/SDCard.java: -------------------------------------------------------------------------------- 1 | package designPattern.adapter.classAdapter; 2 | 3 | /** 4 | * 目标接口 5 | */ 6 | public interface SDCard { 7 | // 从SD卡中读取数据 8 | String readSD(); 9 | 10 | // 往SD卡中写数据 11 | void writeSD(String msg); 12 | } 13 | -------------------------------------------------------------------------------- /src/designPattern/adapter/classAdapter/SDCardImpl.java: -------------------------------------------------------------------------------- 1 | package designPattern.adapter.classAdapter; 2 | 3 | public class SDCardImpl implements SDCard{ 4 | @Override 5 | public String readSD() { 6 | String msg = "SDCard read message: hello world SDCard"; 7 | return msg; 8 | } 9 | 10 | @Override 11 | public void writeSD(String msg) { 12 | System.out.println("SDCard write msg: " + msg); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/designPattern/adapter/classAdapter/TFCard.java: -------------------------------------------------------------------------------- 1 | package designPattern.adapter.classAdapter; 2 | 3 | /** 4 | * 适配者类接口 5 | */ 6 | public interface TFCard { 7 | // 从TF卡中读取数据 8 | String readTF(); 9 | 10 | // 往TF卡中写数据 11 | void writeTF(String msg); 12 | } 13 | -------------------------------------------------------------------------------- /src/designPattern/adapter/classAdapter/TFCardImpl.java: -------------------------------------------------------------------------------- 1 | package designPattern.adapter.classAdapter; 2 | 3 | /** 4 | * 适配者类 5 | */ 6 | public class TFCardImpl implements TFCard{ 7 | @Override 8 | public String readTF() { 9 | String msg = "TFCard read message: hello world TFCard"; 10 | return msg; 11 | } 12 | 13 | @Override 14 | public void writeTF(String msg) { 15 | System.out.println("TFCard write msg: " + msg); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/designPattern/adapter/objectAdapter/Client.java: -------------------------------------------------------------------------------- 1 | package designPattern.adapter.objectAdapter; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | // 创建计算机对象 6 | Computer computer = new Computer(); 7 | 8 | // 读取SD卡中的数据 9 | String msg = computer.readSD(new SDCardImpl()); 10 | 11 | System.out.println(msg); 12 | 13 | // 使用该电脑读取TF卡中的数据 14 | // 创建适配器类对象 15 | SDAdapterTF sdAdapterTF = new SDAdapterTF(new TFCardImpl()); 16 | String str = computer.readSD(sdAdapterTF); 17 | System.out.println(str); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/designPattern/adapter/objectAdapter/Computer.java: -------------------------------------------------------------------------------- 1 | package designPattern.adapter.objectAdapter; 2 | 3 | /** 4 | * 计算机类 5 | */ 6 | public class Computer { 7 | // 从SD卡中读取数据 8 | public String readSD(SDCard sdCard){ 9 | if(sdCard == null){ 10 | throw new NullPointerException("SDCard is null"); 11 | } 12 | return sdCard.readSD(); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/designPattern/adapter/objectAdapter/SDAdapterTF.java: -------------------------------------------------------------------------------- 1 | package designPattern.adapter.objectAdapter; 2 | 3 | /** 4 | * 适配器类 5 | */ 6 | public class SDAdapterTF implements SDCard { 7 | // 声明适配者类 8 | private TFCard tfCard; 9 | 10 | public SDAdapterTF(TFCard tfCard){ 11 | this.tfCard = tfCard; 12 | } 13 | 14 | @Override 15 | public String readSD() { 16 | System.out.println("Adapter read TFCard"); 17 | return tfCard.readTF(); 18 | } 19 | 20 | @Override 21 | public void writeSD(String msg) { 22 | System.out.println("Adapter write TFCard"); 23 | tfCard.writeTF(msg); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/designPattern/adapter/objectAdapter/SDCard.java: -------------------------------------------------------------------------------- 1 | package designPattern.adapter.objectAdapter; 2 | 3 | /** 4 | * 目标接口 5 | */ 6 | public interface SDCard { 7 | // 从SD卡中读取数据 8 | String readSD(); 9 | 10 | // 往SD卡中写数据 11 | void writeSD(String msg); 12 | } 13 | -------------------------------------------------------------------------------- /src/designPattern/adapter/objectAdapter/SDCardImpl.java: -------------------------------------------------------------------------------- 1 | package designPattern.adapter.objectAdapter; 2 | 3 | public class SDCardImpl implements SDCard { 4 | @Override 5 | public String readSD() { 6 | String msg = "SDCard read message: hello world SDCard"; 7 | return msg; 8 | } 9 | 10 | @Override 11 | public void writeSD(String msg) { 12 | System.out.println("SDCard write msg: " + msg); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/designPattern/adapter/objectAdapter/TFCard.java: -------------------------------------------------------------------------------- 1 | package designPattern.adapter.objectAdapter; 2 | 3 | /** 4 | * 适配者类接口 5 | */ 6 | public interface TFCard { 7 | // 从TF卡中读取数据 8 | String readTF(); 9 | 10 | // 往TF卡中写数据 11 | void writeTF(String msg); 12 | } 13 | -------------------------------------------------------------------------------- /src/designPattern/adapter/objectAdapter/TFCardImpl.java: -------------------------------------------------------------------------------- 1 | package designPattern.adapter.objectAdapter; 2 | 3 | /** 4 | * 适配者类 5 | */ 6 | public class TFCardImpl implements TFCard { 7 | @Override 8 | public String readTF() { 9 | String msg = "TFCard read message: hello world TFCard"; 10 | return msg; 11 | } 12 | 13 | @Override 14 | public void writeTF(String msg) { 15 | System.out.println("TFCard write msg: " + msg); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/designPattern/bridge/AviFile.java: -------------------------------------------------------------------------------- 1 | package designPattern.bridge; 2 | 3 | /** 4 | * avi视频文件 (具体的实现化角色) 5 | */ 6 | public class AviFile implements VideoFile{ 7 | @Override 8 | public void decode(String fileName) { 9 | System.out.println("avi视频文件：" + fileName); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/designPattern/bridge/Client.java: -------------------------------------------------------------------------------- 1 | package designPattern.bridge; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | // 创建mac系统对象 6 | OperationSystem system = new Mac(new AviFile()); 7 | // 使用操作系统播放视频文件 8 | system.play("战狼"); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /src/designPattern/bridge/Mac.java: -------------------------------------------------------------------------------- 1 | package designPattern.bridge; 2 | 3 | /** 4 | * 扩展抽象化角色 (Mac操作系统) 5 | */ 6 | public class Mac extends OperationSystem { 7 | 8 | public Mac(VideoFile videoFile) { 9 | super(videoFile); 10 | } 11 | 12 | @Override 13 | public void play(String fileName) { 14 | videoFile.decode(fileName); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/designPattern/bridge/OperationSystem.java: -------------------------------------------------------------------------------- 1 | package designPattern.bridge; 2 | 3 | /** 4 | * 抽象的操作系统类 (抽象化角色) 5 | */ 6 | public abstract class OperationSystem { 7 | // 声明videoFile变量 8 | protected VideoFile videoFile; 9 | 10 | public OperationSystem(VideoFile videoFile){ 11 | this.videoFile = videoFile; 12 | } 13 | 14 | public abstract void play(String fileName); 15 | } 16 | -------------------------------------------------------------------------------- /src/designPattern/bridge/RmvbFile.java: -------------------------------------------------------------------------------- 1 | package designPattern.bridge; 2 | 3 | /** 4 | * rmvb视频文件 (具体的实现化角色) 5 | */ 6 | public class RmvbFile implements VideoFile{ 7 | @Override 8 | public void decode(String fileName) { 9 | System.out.println("rmvb视频文件：" + fileName); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/designPattern/bridge/VideoFile.java: -------------------------------------------------------------------------------- 1 | package designPattern.bridge; 2 | 3 | /** 4 | * 视频文件 (实现化角色) 5 | */ 6 | public interface VideoFile { 7 | // 解码功能 8 | void decode(String fileName); 9 | } 10 | -------------------------------------------------------------------------------- /src/designPattern/bridge/Windows.java: -------------------------------------------------------------------------------- 1 | package designPattern.bridge; 2 | 3 | /** 4 | * 扩展抽象化角色 (Windows操作系统) 5 | */ 6 | public class Windows extends OperationSystem { 7 | 8 | public Windows(VideoFile videoFile) { 9 | super(videoFile); 10 | } 11 | 12 | @Override 13 | public void play(String fileName) { 14 | videoFile.decode(fileName); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/designPattern/builder/demo1/Bike.java: -------------------------------------------------------------------------------- 1 | package designPattern.builder.demo1; 2 | 3 | /** 4 | * 产品对象 5 | */ 6 | public class Bike { 7 | // 车架 8 | private String frame; 9 | 10 | // 车座 11 | private String seat; 12 | 13 | public String getFrame() { 14 | return frame; 15 | } 16 | 17 | public void setFrame(String frame) { 18 | this.frame = frame; 19 | } 20 | 21 | public String getSeat() { 22 | return seat; 23 | } 24 | 25 | public void setSeat(String seat) { 26 | this.seat = seat; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/designPattern/builder/demo1/Builder.java: -------------------------------------------------------------------------------- 1 | package designPattern.builder.demo1; 2 | 3 | public abstract class Builder { 4 | // 声明Bike类型的变量，并进行赋值 5 | protected Bike bike = new Bike(); 6 | 7 | public abstract void buildFrame(); 8 | 9 | public abstract void buildSeat(); 10 | 11 | // 构建自行车的方法 12 | public abstract Bike createBike(); 13 | } 14 | -------------------------------------------------------------------------------- /src/designPattern/builder/demo1/Director.java: -------------------------------------------------------------------------------- 1 | package designPattern.builder.demo1; 2 | 3 | /** 4 | * 指挥者类 5 | */ 6 | public class Director { 7 | // 声明builder类型的变量 8 | private Builder builder; 9 | 10 | public Director(Builder builder){ 11 | this.builder = builder; 12 | } 13 | 14 | // 组装自行车的功能 15 | public Bike construct(){ 16 | builder.buildFrame(); 17 | builder.buildSeat(); 18 | return builder.createBike(); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/designPattern/builder/demo1/MobileBuilder.java: -------------------------------------------------------------------------------- 1 | package designPattern.builder.demo1; 2 | 3 | /** 4 | * 具体构建者，用来构建摩拜单车对象 5 | */ 6 | public class MobileBuilder extends Builder { 7 | @Override 8 | public void buildFrame() { 9 | bike.setFrame("碳纤维车架"); 10 | } 11 | 12 | @Override 13 | public void buildSeat() { 14 | bike.setSeat("真皮车座"); 15 | } 16 | 17 | @Override 18 | public Bike createBike() { 19 | return bike; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/designPattern/builder/demo1/OfoBuilder.java: -------------------------------------------------------------------------------- 1 | package designPattern.builder.demo1; 2 | 3 | /** 4 | * 具体构建者，用来构建ofo单车对象 5 | */ 6 | public class OfoBuilder extends Builder { 7 | @Override 8 | public void buildFrame() { 9 | bike.setFrame("铝合金车架"); 10 | } 11 | 12 | @Override 13 | public void buildSeat() { 14 | bike.setSeat("橡胶车座"); 15 | } 16 | 17 | @Override 18 | public Bike createBike() { 19 | return bike; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/designPattern/builder/demo2/Client.java: -------------------------------------------------------------------------------- 1 | package designPattern.builder.demo2; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | // 创建手机对象，通过构建者对象创建手机对象 6 | Phone phone = new Phone.Builder() 7 | .cpu("intel") 8 | .screen("三星屏幕") 9 | .memory("金士顿内存条") 10 | .mainBoard("华硕主板") 11 | .build(); 12 | 13 | System.out.println(phone); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/designPattern/combination/MenuComponent.java: -------------------------------------------------------------------------------- 1 | package designPattern.combination; 2 | 3 | /** 4 | * 菜单组件：属于抽象根节点 5 | */ 6 | public abstract class MenuComponent { 7 | // 菜单组件的名称 8 | protected String name; 9 | 10 | // 菜单组件的层级 11 | protected int level; 12 | 13 | // 添加子菜单 14 | public void add(MenuComponent menuComponent){ 15 | throw new UnsupportedOperationException(); 16 | } 17 | 18 | // 移除子菜单 19 | public void remove(MenuComponent menuComponent){ 20 | throw new UnsupportedOperationException(); 21 | } 22 | 23 | // 获取指定的子菜单 24 | public MenuComponent getChild(int index){ 25 | throw new UnsupportedOperationException(); 26 | } 27 | 28 | // 获取菜单或者菜单项的名称 29 | public String getName(){ 30 | return name; 31 | } 32 | 33 | // 打印菜单名称的方法 (包含子菜单和子菜单项) 34 | public abstract void print(); 35 | } 36 | -------------------------------------------------------------------------------- /src/designPattern/combination/MenuItem.java: -------------------------------------------------------------------------------- 1 | package designPattern.combination; 2 | 3 | /** 4 | * 菜单项类：属于叶子节点 5 | */ 6 | public class MenuItem extends MenuComponent { 7 | 8 | public MenuItem(String name, int level){ 9 | this.name = name; 10 | this.level = level; 11 | } 12 | 13 | @Override 14 | public void print() { 15 | // 打印菜单项的名称 16 | for (int i = 0; i < level; i++){ 17 | System.out.print("--"); 18 | } 19 | System.out.println(name); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/designPattern/command/Command.java: -------------------------------------------------------------------------------- 1 | package designPattern.command; 2 | 3 | /** 4 | * 抽象命令类 5 | */ 6 | public interface Command { 7 | void execute(); 8 | } 9 | -------------------------------------------------------------------------------- /src/designPattern/command/Order.java: -------------------------------------------------------------------------------- 1 | package designPattern.command; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | 6 | /** 7 | * 订单类 8 | */ 9 | public class Order { 10 | // 餐桌号码 11 | private int OrderingTable; 12 | 13 | // 所下的餐品及份数 14 | private Map foodDir = new HashMap<>(); 15 | 16 | public int getOrderingTable() { 17 | return OrderingTable; 18 | } 19 | 20 | public void setOrderingTable(int orderingTable) { 21 | OrderingTable = orderingTable; 22 | } 23 | 24 | public Map getFoodDir() { 25 | return foodDir; 26 | } 27 | 28 | public void setFood(String name, int num) { 29 | foodDir.put(name, num); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/designPattern/command/SeniorChef.java: -------------------------------------------------------------------------------- 1 | package designPattern.command; 2 | 3 | /** 4 | * 厨师类 5 | */ 6 | public class SeniorChef { 7 | public void makeFood(String name, int num){ 8 | System.out.println(num + "份" + name); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /src/designPattern/command/Waiter.java: -------------------------------------------------------------------------------- 1 | package designPattern.command; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | /** 7 | * 服务员类 (属于请求者角色) 8 | */ 9 | public class Waiter { 10 | // 持有多个命令对象 11 | private List commands = new ArrayList<>(); 12 | 13 | public void setCommand(Command cmd){ 14 | commands.add(cmd); 15 | } 16 | 17 | // 发起命令功能 18 | public void OrderUp(){ 19 | System.out.println("服务员：大厨，新订单来啦"); 20 | for (Command command : commands) { 21 | if(command!=null){ 22 | command.execute(); 23 | } 24 | } 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/designPattern/decorator/Bacon.java: -------------------------------------------------------------------------------- 1 | package designPattern.decorator; 2 | 3 | /** 4 | * 培根类 (具体装饰者角色) 5 | */ 6 | public class Bacon extends Garnish { 7 | 8 | public Bacon(FastFood fastFood){ 9 | super(fastFood, 2, "培根"); 10 | } 11 | 12 | @Override 13 | public float cost() { 14 | // 计算价格 15 | return getPrice() + getFastFood().cost(); 16 | } 17 | 18 | @Override 19 | public String getDesc() { 20 | return super.getDesc() + getFastFood().getDesc(); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/designPattern/decorator/Client.java: -------------------------------------------------------------------------------- 1 | package designPattern.decorator; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | // 点一份炒饭 6 | FastFood food = new FriedRice(); 7 | 8 | System.out.println(food.getDesc() + "->" + food.cost()); 9 | 10 | // 在上面的炒饭中加一个鸡蛋 11 | food = new Egg(food); 12 | System.out.println(food.getDesc() + "->" + food.cost()); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/designPattern/decorator/Egg.java: -------------------------------------------------------------------------------- 1 | package designPattern.decorator; 2 | 3 | /** 4 | * 鸡蛋类 (具体装饰者角色) 5 | */ 6 | public class Egg extends Garnish { 7 | 8 | public Egg(FastFood fastFood){ 9 | super(fastFood, 1, "鸡蛋"); 10 | } 11 | 12 | @Override 13 | public float cost() { 14 | // 计算价格 15 | return super.getPrice() + getFastFood().cost(); 16 | } 17 | 18 | @Override 19 | public String getDesc() { 20 | return super.getDesc() + getFastFood().getDesc(); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/designPattern/decorator/FastFood.java: -------------------------------------------------------------------------------- 1 | package designPattern.decorator; 2 | 3 | /** 4 | * 快餐类 (抽象构件角色) 5 | */ 6 | public abstract class FastFood { 7 | 8 | private float price; 9 | 10 | private String desc; 11 | 12 | public FastFood() { 13 | } 14 | 15 | public FastFood(float price, String desc) { 16 | this.price = price; 17 | this.desc = desc; 18 | } 19 | 20 | public float getPrice() { 21 | return price; 22 | } 23 | 24 | public void setPrice(float price) { 25 | this.price = price; 26 | } 27 | 28 | public String getDesc() { 29 | return desc; 30 | } 31 | 32 | public void setDesc(String desc) { 33 | this.desc = desc; 34 | } 35 | 36 | public abstract float cost(); 37 | } 38 | -------------------------------------------------------------------------------- /src/designPattern/decorator/FriedNoddles.java: -------------------------------------------------------------------------------- 1 | package designPattern.decorator; 2 | 3 | /** 4 | * 炒面 (具体构件角色) 5 | */ 6 | public class FriedNoddles extends FastFood{ 7 | 8 | public FriedNoddles(){ 9 | super(12, "炒面"); 10 | } 11 | 12 | @Override 13 | public float cost() { 14 | return getPrice(); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/designPattern/decorator/FriedRice.java: -------------------------------------------------------------------------------- 1 | package designPattern.decorator; 2 | 3 | /** 4 | * 炒饭 (具体构件角色) 5 | */ 6 | public class FriedRice extends FastFood{ 7 | 8 | public FriedRice(){ 9 | super(10, "炒饭"); 10 | } 11 | 12 | @Override 13 | public float cost() { 14 | return getPrice(); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/designPattern/decorator/Garnish.java: -------------------------------------------------------------------------------- 1 | package designPattern.decorator; 2 | 3 | /** 4 | * 装饰者类 (抽象装饰者角色) 5 | */ 6 | public abstract class Garnish extends FastFood{ 7 | 8 | // 声明快餐类的变量 9 | private FastFood fastFood; 10 | 11 | public Garnish(FastFood fastFood, float price, String desc) { 12 | super(price, desc); 13 | this.fastFood = fastFood; 14 | } 15 | 16 | public FastFood getFastFood() { 17 | return fastFood; 18 | } 19 | 20 | public void setFastFood(FastFood fastFood) { 21 | this.fastFood = fastFood; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/designPattern/facade/AirCondition.java: -------------------------------------------------------------------------------- 1 | package designPattern.facade; 2 | 3 | /** 4 | * 电视机类 5 | */ 6 | public class AirCondition { 7 | public void on(){ 8 | System.out.println("打开空调"); 9 | } 10 | 11 | public void off(){ 12 | System.out.println("关闭空调"); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/designPattern/facade/Client.java: -------------------------------------------------------------------------------- 1 | package designPattern.facade; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | // 创建智能音箱对象 6 | SmartAppliancesFacade facade = new SmartAppliancesFacade(); 7 | facade.say("打开家电"); 8 | 9 | facade.say("关闭家电"); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/designPattern/facade/Light.java: -------------------------------------------------------------------------------- 1 | package designPattern.facade; 2 | 3 | /** 4 | * 点灯类 5 | */ 6 | public class Light { 7 | public void on(){ 8 | System.out.println("打开点灯"); 9 | } 10 | 11 | public void off(){ 12 | System.out.println("关闭点灯"); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/designPattern/facade/TV.java: -------------------------------------------------------------------------------- 1 | package designPattern.facade; 2 | 3 | /** 4 | * 电视机类 5 | */ 6 | public class TV { 7 | public void on(){ 8 | System.out.println("打开电视机"); 9 | } 10 | 11 | public void off(){ 12 | System.out.println("关闭电视机"); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/designPattern/factory/abstractFactory/AmericanCoffee.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.abstractFactory; 2 | 3 | /** 4 | * 美式咖啡 5 | */ 6 | public class AmericanCoffee extends Coffee { 7 | @Override 8 | public String getName() { 9 | return "美式咖啡"; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/designPattern/factory/abstractFactory/AmericanDessertFactory.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.abstractFactory; 2 | 3 | /** 4 | * 美式风味甜品工厂类 5 | */ 6 | public class AmericanDessertFactory implements DessertFactory { 7 | @Override 8 | public Coffee createCoffee() { 9 | return new AmericanCoffee(); 10 | } 11 | 12 | @Override 13 | public Dessert createDessert() { 14 | return new MatchaMousse(); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/designPattern/factory/abstractFactory/Coffee.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.abstractFactory; 2 | 3 | /** 4 | * 咖啡类 5 | */ 6 | public abstract class Coffee { 7 | 8 | public abstract String getName(); 9 | 10 | public void addSugar(){ 11 | System.out.println("加糖"); 12 | } 13 | 14 | public void addMike(){ 15 | System.out.println("加奶"); 16 | } 17 | 18 | 19 | } 20 | -------------------------------------------------------------------------------- /src/designPattern/factory/abstractFactory/Dessert.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.abstractFactory; 2 | 3 | /** 4 | * 甜品抽象类 5 | */ 6 | public abstract class Dessert { 7 | public abstract void show(); 8 | } 9 | -------------------------------------------------------------------------------- /src/designPattern/factory/abstractFactory/DessertFactory.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.abstractFactory; 2 | 3 | /** 4 | * 甜品工厂类 5 | */ 6 | public interface DessertFactory { 7 | // 生产咖啡的功能 8 | Coffee createCoffee(); 9 | 10 | // 生产甜品的功能 11 | Dessert createDessert(); 12 | } 13 | -------------------------------------------------------------------------------- /src/designPattern/factory/abstractFactory/ItalyDessertFactory.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.abstractFactory; 2 | 3 | /** 4 | * 意大利风味甜品工厂 5 | */ 6 | public class ItalyDessertFactory implements DessertFactory{ 7 | @Override 8 | public Coffee createCoffee() { 9 | return new LatteCoffee(); 10 | } 11 | 12 | @Override 13 | public Dessert createDessert() { 14 | return new Tiramisu(); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/designPattern/factory/abstractFactory/LatteCoffee.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.abstractFactory; 2 | 3 | /** 4 | * 拿铁咖啡 5 | */ 6 | public class LatteCoffee extends Coffee { 7 | @Override 8 | public String getName() { 9 | return "拿铁咖啡"; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/designPattern/factory/abstractFactory/MatchaMousse.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.abstractFactory; 2 | 3 | /** 4 | * 抹茶慕斯类 5 | */ 6 | public class MatchaMousse extends Dessert{ 7 | @Override 8 | public void show() { 9 | System.out.println("抹茶慕斯"); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/designPattern/factory/abstractFactory/Tiramisu.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.abstractFactory; 2 | 3 | /** 4 | * 提拉米苏类 5 | */ 6 | public class Tiramisu extends Dessert{ 7 | @Override 8 | public void show() { 9 | System.out.println("提拉米苏"); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/designPattern/factory/before/AmericanCoffee.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.before; 2 | 3 | /** 4 | * 美式咖啡 5 | */ 6 | public class AmericanCoffee extends Coffee { 7 | @Override 8 | public String getName() { 9 | return "美式咖啡"; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/designPattern/factory/before/Client.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.before; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | // 1.创建咖啡店类 6 | CoffeeStore store = new CoffeeStore(); 7 | // 2.点咖啡 8 | Coffee coffee = store.orderCoffee("latte"); 9 | 10 | System.out.println(coffee.getName()); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/designPattern/factory/before/Coffee.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.before; 2 | 3 | /** 4 | * 咖啡类 5 | */ 6 | public abstract class Coffee { 7 | 8 | public abstract String getName(); 9 | 10 | public void addSugar(){ 11 | System.out.println("加糖"); 12 | } 13 | 14 | public void addMike(){ 15 | System.out.println("加奶"); 16 | } 17 | 18 | 19 | } 20 | -------------------------------------------------------------------------------- /src/designPattern/factory/before/CoffeeStore.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.before; 2 | 3 | /** 4 | * 咖啡店 5 | */ 6 | public class CoffeeStore { 7 | public Coffee orderCoffee(String type){ 8 | // 声明Coffee类型的变量，根据不同类型创建不同的coffee子类对象 9 | Coffee coffee = null; 10 | if("american".equals(type)){ 11 | coffee = new AmericanCoffee(); 12 | }else if("latte".equals(type)){ 13 | coffee = new LatteCoffee(); 14 | } else{ 15 | throw new RuntimeException("对不起，您所点的咖啡没有"); 16 | } 17 | // 加配料 18 | coffee.addMike(); 19 | coffee.addSugar(); 20 | 21 | return coffee; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/designPattern/factory/before/LatteCoffee.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.before; 2 | 3 | /** 4 | * 拿铁咖啡 5 | */ 6 | public class LatteCoffee extends Coffee { 7 | @Override 8 | public String getName() { 9 | return "拿铁咖啡"; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/designPattern/factory/configFactory/AmericanCoffee.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.configFactory; 2 | 3 | /** 4 | * 美式咖啡 5 | */ 6 | public class AmericanCoffee extends Coffee { 7 | @Override 8 | public String getName() { 9 | return "美式咖啡"; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/designPattern/factory/configFactory/Client.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.configFactory; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | Coffee coffee = CoffeeFactory.createCoffee("american"); 6 | System.out.println(coffee.getName()); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /src/designPattern/factory/configFactory/Coffee.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.configFactory; 2 | 3 | /** 4 | * 咖啡类 5 | */ 6 | public abstract class Coffee { 7 | 8 | public abstract String getName(); 9 | 10 | public void addSugar(){ 11 | System.out.println("加糖"); 12 | } 13 | 14 | public void addMike(){ 15 | System.out.println("加奶"); 16 | } 17 | 18 | 19 | } 20 | -------------------------------------------------------------------------------- /src/designPattern/factory/configFactory/LatteCoffee.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.configFactory; 2 | 3 | /** 4 | * 拿铁咖啡 5 | */ 6 | public class LatteCoffee extends Coffee { 7 | @Override 8 | public String getName() { 9 | return "拿铁咖啡"; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/designPattern/factory/configFactory/bean.properties: -------------------------------------------------------------------------------- 1 | american = designPattern.factory.configFactory.AmericanCoffee 2 | latte = designPattern.factory.configFactory.LatteCoffee -------------------------------------------------------------------------------- /src/designPattern/factory/factoryMethod/AmericanCoffee.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.factoryMethod; 2 | 3 | /** 4 | * 美式咖啡 5 | */ 6 | public class AmericanCoffee extends Coffee { 7 | @Override 8 | public String getName() { 9 | return "美式咖啡"; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/designPattern/factory/factoryMethod/AmericanCoffeeFactory.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.factoryMethod; 2 | 3 | /** 4 | * 美式咖啡工厂对象，专门用来生产美式咖啡 5 | */ 6 | public class AmericanCoffeeFactory implements CoffeeFactory { 7 | @Override 8 | public Coffee createCoffee() { 9 | return new AmericanCoffee(); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/designPattern/factory/factoryMethod/Client.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.factoryMethod; 2 | 3 | /** 4 | * 定义一个用于创建对象的接口，让子类决定实例化哪个产品类对象。工厂方法使一个产品类的实例化延迟到其工厂的子类。 5 | * 工厂方法模式的主要角色： 6 | * 7 | * * 抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建产品。 8 | * * 具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。 9 | * * 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。 10 | * * 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。 11 | */ 12 | public class Client { 13 | public static void main(String[] args) { 14 | // 创建咖啡店对象 15 | CoffeeStore store = new CoffeeStore(); 16 | CoffeeFactory factory = new AmericanCoffeeFactory(); 17 | store.setFactory(factory); 18 | 19 | Coffee coffee = store.orderCoffee(); 20 | System.out.println(coffee.getName()); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/designPattern/factory/factoryMethod/Coffee.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.factoryMethod; 2 | 3 | public abstract class Coffee { 4 | 5 | public abstract String getName(); 6 | 7 | public void addSugar(){ 8 | System.out.println("加糖"); 9 | } 10 | 11 | public void addMike(){ 12 | System.out.println("加奶"); 13 | } 14 | 15 | } -------------------------------------------------------------------------------- /src/designPattern/factory/factoryMethod/CoffeeFactory.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.factoryMethod; 2 | 3 | /** 4 | * 抽象工厂类 5 | */ 6 | public interface CoffeeFactory { 7 | // 创建咖啡对象的方法 8 | Coffee createCoffee(); 9 | } 10 | -------------------------------------------------------------------------------- /src/designPattern/factory/factoryMethod/CoffeeStore.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.factoryMethod; 2 | 3 | /** 4 | * 咖啡店 5 | */ 6 | public class CoffeeStore { 7 | private CoffeeFactory factory; 8 | 9 | public void setFactory(CoffeeFactory factory) { 10 | this.factory = factory; 11 | } 12 | 13 | // 点咖啡功能 14 | public Coffee orderCoffee(){ 15 | Coffee coffee = factory.createCoffee(); 16 | coffee.addMike(); 17 | coffee.addSugar(); 18 | return coffee; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/designPattern/factory/factoryMethod/LatteCoffee.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.factoryMethod; 2 | 3 | /** 4 | * 拿铁咖啡 5 | */ 6 | public class LatteCoffee extends Coffee { 7 | @Override 8 | public String getName() { 9 | return "拿铁咖啡"; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/designPattern/factory/factoryMethod/LatteCoffeeFactory.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.factoryMethod; 2 | 3 | /** 4 | * 拿铁咖啡工厂类 5 | */ 6 | public class LatteCoffeeFactory implements CoffeeFactory { 7 | @Override 8 | public Coffee createCoffee() { 9 | return new LatteCoffee(); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/designPattern/factory/simpleFactory/AmericanCoffee.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.simpleFactory; 2 | 3 | /** 4 | * 美式咖啡 5 | */ 6 | public class AmericanCoffee extends Coffee { 7 | @Override 8 | public String getName() { 9 | return "美式咖啡"; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/designPattern/factory/simpleFactory/Client.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.simpleFactory; 2 | 3 | /** 4 | * 简单工厂包含如下角色： 5 | * 6 | * * 抽象产品 ：定义了产品的规范，描述了产品的主要特性和功能。 7 | * * 具体产品 ：实现或者继承抽象产品的子类 8 | * * 具体工厂 ：提供了创建产品的方法，调用者通过该方法来获取产品。 9 | */ 10 | public class Client { 11 | public static void main(String[] args) { 12 | CoffeeStore store = new CoffeeStore(); 13 | Coffee coffee = store.orderCoffee("latte"); 14 | System.out.println(coffee.getName()); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/designPattern/factory/simpleFactory/Coffee.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.simpleFactory; 2 | 3 | public abstract class Coffee { 4 | 5 | public abstract String getName(); 6 | 7 | public void addSugar(){ 8 | System.out.println("加糖"); 9 | } 10 | 11 | public void addMike(){ 12 | System.out.println("加奶"); 13 | } 14 | 15 | 16 | } -------------------------------------------------------------------------------- /src/designPattern/factory/simpleFactory/CoffeeStore.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.simpleFactory; 2 | 3 | /** 4 | * 咖啡店 5 | */ 6 | public class CoffeeStore { 7 | public Coffee orderCoffee(String type){ 8 | SimpleCoffeeFactory factory = new SimpleCoffeeFactory(); 9 | 10 | Coffee coffee = factory.createCoffee(type); 11 | 12 | coffee.addMike(); 13 | coffee.addSugar(); 14 | 15 | return coffee; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/designPattern/factory/simpleFactory/LatteCoffee.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.simpleFactory; 2 | 3 | /** 4 | * 拿铁咖啡 5 | */ 6 | public class LatteCoffee extends Coffee { 7 | @Override 8 | public String getName() { 9 | return "拿铁咖啡"; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/designPattern/factory/simpleFactory/SimpleCoffeeFactory.java: -------------------------------------------------------------------------------- 1 | package designPattern.factory.simpleFactory; 2 | 3 | /** 4 | * 简单咖啡工厂类：生产咖啡 5 | */ 6 | public class SimpleCoffeeFactory { 7 | public Coffee createCoffee(String type){ 8 | // 声明Coffee类型的变量，根据不同类型创建不同的coffee子类对象 9 | Coffee coffee = null; 10 | if("american".equals(type)){ 11 | coffee = new AmericanCoffee(); 12 | }else if("latte".equals(type)){ 13 | coffee = new LatteCoffee(); 14 | } else{ 15 | throw new RuntimeException("对不起，您所点的咖啡没有"); 16 | } 17 | return coffee; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/designPattern/flyWeight/AbstractBox.java: -------------------------------------------------------------------------------- 1 | package designPattern.flyWeight; 2 | 3 | /** 4 | * 抽象享元角色 5 | */ 6 | public abstract class AbstractBox { 7 | // 获取图像的方法 8 | public abstract String getShape(); 9 | 10 | //显示图形及颜色 11 | public void display(String color){ 12 | System.out.println("方块形状:" + getShape() 13 | + ", 颜色:" + color); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/designPattern/flyWeight/BoxFactory.java: -------------------------------------------------------------------------------- 1 | package designPattern.flyWeight; 2 | 3 | import java.util.HashMap; 4 | 5 | /** 6 | * 工厂类：将该类设计为单例 7 | */ 8 | public class BoxFactory { 9 | private HashMap map; 10 | 11 | // 在构造方法中进行初始化操作 12 | private BoxFactory(){ 13 | map = new HashMap(); 14 | map.put("I", new IBox()); 15 | map.put("L", new LBox()); 16 | map.put("O", new OBox()); 17 | } 18 | 19 | // 根据一个方法获取该工厂类的对象 20 | public static BoxFactory getInstance(){ 21 | return factory; 22 | } 23 | 24 | private static BoxFactory factory = new BoxFactory(); 25 | 26 | // 根据名称获取图形对象 27 | public AbstractBox getShape(String name){ 28 | return map.get(name); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/designPattern/flyWeight/Client.java: -------------------------------------------------------------------------------- 1 | package designPattern.flyWeight; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | // 获取I图形对象 6 | AbstractBox box1 = BoxFactory.getInstance().getShape("I"); 7 | box1.display("灰色"); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /src/designPattern/flyWeight/IBox.java: -------------------------------------------------------------------------------- 1 | package designPattern.flyWeight; 2 | 3 | /** 4 | * I图形类 (具体享元角色) 5 | */ 6 | public class IBox extends AbstractBox { 7 | 8 | @Override 9 | public String getShape() { 10 | return "I"; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/designPattern/flyWeight/LBox.java: -------------------------------------------------------------------------------- 1 | package designPattern.flyWeight; 2 | 3 | /** 4 | * L图形类 (具体享元角色) 5 | */ 6 | public class LBox extends AbstractBox { 7 | 8 | @Override 9 | public String getShape() { 10 | return "L"; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/designPattern/flyWeight/OBox.java: -------------------------------------------------------------------------------- 1 | package designPattern.flyWeight; 2 | 3 | /** 4 | * O图形类 (具体享元角色) 5 | */ 6 | public class OBox extends AbstractBox { 7 | 8 | @Override 9 | public String getShape() { 10 | return "O"; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/designPattern/interpreter/AbstractExpression.java: -------------------------------------------------------------------------------- 1 | package designPattern.interpreter; 2 | 3 | /** 4 | * 抽象表达式类 5 | */ 6 | public abstract class AbstractExpression { 7 | public abstract int interpret(Context context); 8 | } 9 | -------------------------------------------------------------------------------- /src/designPattern/interpreter/Client.java: -------------------------------------------------------------------------------- 1 | package designPattern.interpreter; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | // 创建环境对象 6 | Context context = new Context(); 7 | 8 | // 创建多个变量对象 9 | Variable a = new Variable("a"); 10 | Variable b = new Variable("b"); 11 | Variable c = new Variable("c"); 12 | Variable d = new Variable("d"); 13 | 14 | // 将变量存储到环境变量中 15 | context.assign(a,1); 16 | context.assign(b,2); 17 | context.assign(c,3); 18 | context.assign(d,4); 19 | 20 | // 获取抽象语法树 21 | AbstractExpression expression = new Minus(a, new Plus(new Minus(b, c), d)); 22 | 23 | // 解释 24 | int result = expression.interpret(context); 25 | 26 | System.out.println(expression + "=" + result); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/designPattern/interpreter/Context.java: -------------------------------------------------------------------------------- 1 | package designPattern.interpreter; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | 6 | /** 7 | * 环境角色类 8 | */ 9 | public class Context { 10 | // 定义一个map集合，用于存储变量及对应的值 11 | private Map map = new HashMap<>(); 12 | 13 | // 添加变量的功能 14 | public void assign(Variable var, Integer value){ 15 | map.put(var, value); 16 | } 17 | 18 | // 根据变量获取对应的值 19 | public int getValue(Variable var){ 20 | return map.get(var); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/designPattern/interpreter/Minus.java: -------------------------------------------------------------------------------- 1 | package designPattern.interpreter; 2 | 3 | /** 4 | * 减法表达式类 5 | */ 6 | public class Minus extends AbstractExpression{ 7 | // 减号左边的表达式 8 | private AbstractExpression left; 9 | 10 | // 减号右边的表达式 11 | private AbstractExpression right; 12 | 13 | public Minus(AbstractExpression left, AbstractExpression right) { 14 | this.left = left; 15 | this.right = right; 16 | } 17 | 18 | @Override 19 | public int interpret(Context context) { 20 | // 将左边表达式的结果和右边表达式的结果相减 21 | return left.interpret(context) - right.interpret(context); 22 | } 23 | 24 | @Override 25 | public String toString() { 26 | return "(" + left.toString() + "-" + right.toString() + ")"; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/designPattern/interpreter/Plus.java: -------------------------------------------------------------------------------- 1 | package designPattern.interpreter; 2 | 3 | /** 4 | * 加法表达式类 5 | */ 6 | public class Plus extends AbstractExpression{ 7 | // 加号左边的表达式 8 | private AbstractExpression left; 9 | 10 | // 加号右边的表达式 11 | private AbstractExpression right; 12 | 13 | public Plus(AbstractExpression left, AbstractExpression right) { 14 | this.left = left; 15 | this.right = right; 16 | } 17 | 18 | @Override 19 | public int interpret(Context context) { 20 | // 将左边表达式的结果和右边表达式的结果相加 21 | return left.interpret(context) + right.interpret(context); 22 | } 23 | 24 | @Override 25 | public String toString() { 26 | return "(" + left.toString() + "+" + right.toString() + ")"; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/designPattern/interpreter/Variable.java: -------------------------------------------------------------------------------- 1 | package designPattern.interpreter; 2 | 3 | /** 4 | * 封装变量的类 5 | */ 6 | public class Variable extends AbstractExpression { 7 | // 声明存储变量名的成员变量 8 | private String name; 9 | 10 | public Variable(String name) { 11 | this.name = name; 12 | } 13 | 14 | @Override 15 | public int interpret(Context context) { 16 | // 返回变量的值 17 | return context.getValue(this); 18 | } 19 | 20 | @Override 21 | public String toString() { 22 | return name; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/designPattern/iterator/Client.java: -------------------------------------------------------------------------------- 1 | package designPattern.iterator; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | StudentAggregateImpl aggregate = new StudentAggregateImpl(); 6 | 7 | aggregate.addStudent(new Student("张三", "001")); 8 | aggregate.addStudent(new Student("李四", "002")); 9 | aggregate.addStudent(new Student("王五", "003")); 10 | 11 | // 获取迭代器对象 12 | StudentIterator iterator = aggregate.getStudentIterator(); 13 | while (iterator.hasNext()){ 14 | Student student = iterator.next(); 15 | System.out.println(student.toString()); 16 | } 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/designPattern/iterator/StudentAggregate.java: -------------------------------------------------------------------------------- 1 | package designPattern.iterator; 2 | 3 | /** 4 | * 抽象聚合角色接口 5 | */ 6 | public interface StudentAggregate { 7 | // 添加学生功能 8 | void addStudent(Student stu); 9 | 10 | // 删除学生功能 11 | void removeStudent(Student stu); 12 | 13 | // 获取迭代器对象功能 14 | StudentIterator getStudentIterator(); 15 | } 16 | -------------------------------------------------------------------------------- /src/designPattern/iterator/StudentAggregateImpl.java: -------------------------------------------------------------------------------- 1 | package designPattern.iterator; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | public class StudentAggregateImpl implements StudentAggregate{ 7 | private List list = new ArrayList<>(); 8 | 9 | @Override 10 | public void addStudent(Student stu) { 11 | list.add(stu); 12 | } 13 | 14 | @Override 15 | public void removeStudent(Student stu) { 16 | list.remove(stu); 17 | } 18 | 19 | // 获取迭代器对象 20 | @Override 21 | public StudentIterator getStudentIterator() { 22 | return new StudentIteratorImpl(list); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/designPattern/iterator/StudentIterator.java: -------------------------------------------------------------------------------- 1 | package designPattern.iterator; 2 | 3 | /** 4 | * 抽象迭代器角色接口 5 | */ 6 | public interface StudentIterator { 7 | // 判断是否还有元素 8 | boolean hasNext(); 9 | 10 | // 获取下一个元素 11 | Student next(); 12 | } 13 | -------------------------------------------------------------------------------- /src/designPattern/iterator/StudentIteratorImpl.java: -------------------------------------------------------------------------------- 1 | package designPattern.iterator; 2 | 3 | import java.util.List; 4 | 5 | /** 6 | * 具体迭代角色类对象 7 | */ 8 | public class StudentIteratorImpl implements StudentIterator{ 9 | private List list; 10 | 11 | private int position = 0; 12 | 13 | public StudentIteratorImpl(List list) { 14 | this.list = list; 15 | } 16 | 17 | @Override 18 | public boolean hasNext() { 19 | return position < list.size(); 20 | } 21 | 22 | @Override 23 | public Student next() { 24 | Student currentStudent = list.get(position++); 25 | return currentStudent; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/designPattern/mediator/Client.java: -------------------------------------------------------------------------------- 1 | package designPattern.mediator; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | // 创建中介者对象 6 | MediatorStructure mediator = new MediatorStructure(); 7 | 8 | // 创建租房者对象 9 | Tenant tenant = new Tenant("张三", mediator); 10 | 11 | // 创建房主对象 12 | HouseOwner houseOwner = new HouseOwner("李四", mediator); 13 | 14 | // 中介者要知道具体房主和租房者 15 | mediator.setTenant(tenant); 16 | mediator.setHouseOwner(houseOwner); 17 | 18 | tenant.contact("我要租三室的房子"); 19 | houseOwner.contact("我这里有三室的房子，你要租吗？"); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/designPattern/mediator/HouseOwner.java: -------------------------------------------------------------------------------- 1 | package designPattern.mediator; 2 | 3 | /** 4 | * 具体的同事角色类 5 | */ 6 | public class HouseOwner extends Person { 7 | public HouseOwner(String name, Mediator mediator) { 8 | super(name, mediator); 9 | } 10 | 11 | // 和中介联系 (沟通) 12 | public void contact(String message){ 13 | mediator.contact(message, this); 14 | } 15 | 16 | // 获取信息 17 | public void getMessage(String message){ 18 | System.out.println("房主:" + name + "获取到的信息是:" + message); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/designPattern/mediator/Mediator.java: -------------------------------------------------------------------------------- 1 | package designPattern.mediator; 2 | 3 | /** 4 | * 抽象中介者类 5 | */ 6 | public abstract class Mediator { 7 | public abstract void contact(String message, Person person); 8 | } 9 | -------------------------------------------------------------------------------- /src/designPattern/mediator/Person.java: -------------------------------------------------------------------------------- 1 | package designPattern.mediator; 2 | 3 | /** 4 | * 抽象同事类 5 | */ 6 | public abstract class Person { 7 | protected String name; 8 | protected Mediator mediator; 9 | 10 | public Person(String name, Mediator mediator) { 11 | this.name = name; 12 | this.mediator = mediator; 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/designPattern/mediator/Tenant.java: -------------------------------------------------------------------------------- 1 | package designPattern.mediator; 2 | 3 | /** 4 | * 具体的同事角色类 5 | */ 6 | public class Tenant extends Person { 7 | public Tenant(String name, Mediator mediator) { 8 | super(name, mediator); 9 | } 10 | 11 | // 和中介联系 (沟通) 12 | public void contact(String message){ 13 | mediator.contact(message, this); 14 | } 15 | 16 | // 获取信息 17 | public void getMessage(String message){ 18 | System.out.println("租房者:" + name + "获取到的信息是:" + message); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/designPattern/memento/blackBox/Client.java: -------------------------------------------------------------------------------- 1 | package designPattern.memento.blackBox; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | System.out.println("------大战BOSS前------"); 6 | 7 | // 创建游戏角色对象 8 | GameRole gameRole = new GameRole(); 9 | gameRole.initState(); 10 | gameRole.stateDisplay(); 11 | 12 | // 将该游戏角色内部状态进行备份 13 | // 创建管理者对象 14 | RoleStateCaretaker roleStateCaretaker = new RoleStateCaretaker(); 15 | roleStateCaretaker.setMemento(gameRole.saveState()); 16 | 17 | System.out.println("------大战BOSS后------"); 18 | // 损耗严重 19 | gameRole.fight(); 20 | gameRole.stateDisplay(); 21 | 22 | System.out.println("------恢复之前的状态------"); 23 | gameRole.recoverState(roleStateCaretaker.getMemento()); 24 | gameRole.stateDisplay(); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/designPattern/memento/blackBox/Memento.java: -------------------------------------------------------------------------------- 1 | package designPattern.memento.blackBox; 2 | 3 | /** 4 | * 备忘录接口，对外提供窄接口 5 | */ 6 | public interface Memento { 7 | 8 | } 9 | -------------------------------------------------------------------------------- /src/designPattern/memento/blackBox/RoleStateCaretaker.java: -------------------------------------------------------------------------------- 1 | package designPattern.memento.blackBox; 2 | 3 | /** 4 | * 备忘录对象管理对象 5 | */ 6 | public class RoleStateCaretaker { 7 | private Memento memento; 8 | 9 | public Memento getMemento() { 10 | return memento; 11 | } 12 | 13 | public void setMemento(Memento memento) { 14 | this.memento = memento; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/designPattern/memento/whiteBox/RoleStateCaretaker.java: -------------------------------------------------------------------------------- 1 | package designPattern.memento.whiteBox; 2 | 3 | /** 4 | * 备忘录对象管理对象 5 | */ 6 | public class RoleStateCaretaker { 7 | // 声明RoleStateMemento类型的变量 8 | private RoleStateMemento roleStateMemento; 9 | 10 | public RoleStateMemento getRoleStateMemento() { 11 | return roleStateMemento; 12 | } 13 | 14 | public void setRoleStateMemento(RoleStateMemento roleStateMemento) { 15 | this.roleStateMemento = roleStateMemento; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/designPattern/observer/Client.java: -------------------------------------------------------------------------------- 1 | package designPattern.observer; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | // 创建公众号对象 6 | SubscriptionSubject subject = new SubscriptionSubject(); 7 | 8 | // 订阅公众号 9 | subject.attach(new WeChatUser("小明")); 10 | subject.attach(new WeChatUser("小方")); 11 | 12 | // 公众号更新，发出消息给订阅者 13 | subject.notify("专栏更新啦!"); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/designPattern/observer/Observer.java: -------------------------------------------------------------------------------- 1 | package designPattern.observer; 2 | 3 | /** 4 | * 抽象观察者类 5 | */ 6 | public interface Observer { 7 | void update(String message); 8 | } 9 | -------------------------------------------------------------------------------- /src/designPattern/observer/Subject.java: -------------------------------------------------------------------------------- 1 | package designPattern.observer; 2 | 3 | /** 4 | * 抽象主题角色类 5 | */ 6 | public interface Subject { 7 | // 添加订阅者 (观察者对象) 8 | void attach(Observer observer); 9 | 10 | // 删除订阅者 11 | void detach(Observer observer); 12 | 13 | // 通知订阅者更新消息 14 | void notify(String message); 15 | } 16 | -------------------------------------------------------------------------------- /src/designPattern/observer/SubscriptionSubject.java: -------------------------------------------------------------------------------- 1 | package designPattern.observer; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | /** 7 | * 具体主题角色类 8 | */ 9 | public class SubscriptionSubject implements Subject { 10 | // 定义一个集合，用来存储多个观察者对象 11 | private List weChatUserList = new ArrayList<>(); 12 | 13 | @Override 14 | public void attach(Observer observer) { 15 | weChatUserList.add(observer); 16 | } 17 | 18 | @Override 19 | public void detach(Observer observer) { 20 | weChatUserList.remove(observer); 21 | } 22 | 23 | @Override 24 | public void notify(String message) { 25 | for (Observer observer : weChatUserList) { 26 | // 调用观察者对象中的update方法 27 | observer.update(message); 28 | } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/designPattern/observer/WeChatUser.java: -------------------------------------------------------------------------------- 1 | package designPattern.observer; 2 | 3 | /** 4 | * 具体观察者角色类 5 | */ 6 | public class WeChatUser implements Observer { 7 | private String name; 8 | 9 | public WeChatUser(String name) { 10 | this.name = name; 11 | } 12 | 13 | @Override 14 | public void update(String message) { 15 | System.out.println(name + "-" + message); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/designPattern/prototype/demo/Client.java: -------------------------------------------------------------------------------- 1 | package designPattern.prototype.demo; 2 | 3 | /** 4 | * 原型模式的克隆分为浅克隆和深克隆。 5 | * 6 | * > 浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。 7 | * > 8 | * > 深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。 9 | */ 10 | public class Client { 11 | public static void main(String[] args) throws CloneNotSupportedException { 12 | // 创建一个原型类对象 13 | RealizeType realizeType = new RealizeType(); 14 | 15 | // 调用RealizeType类中的clone方法进行对象的克隆 16 | RealizeType clone = realizeType.clone(); 17 | 18 | System.out.println(realizeType == clone); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/designPattern/prototype/demo/RealizeType.java: -------------------------------------------------------------------------------- 1 | package designPattern.prototype.demo; 2 | 3 | public class RealizeType implements Cloneable { 4 | public RealizeType(){ 5 | System.out.println("具体的原型对象创建完成！"); 6 | } 7 | 8 | @Override 9 | protected RealizeType clone() throws CloneNotSupportedException { 10 | System.out.println("具体原型复制成功！"); 11 | return (RealizeType) super.clone(); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/designPattern/prototype/test/Citation.java: -------------------------------------------------------------------------------- 1 | package designPattern.prototype.test; 2 | 3 | public class Citation implements Cloneable { 4 | 5 | private Student stu; 6 | 7 | public Student getStu() { 8 | return stu; 9 | } 10 | 11 | public void setStu(Student stu) { 12 | this.stu = stu; 13 | } 14 | 15 | public void show(){ 16 | System.out.println(stu.getName() + "同学被评为三好学生！"); 17 | } 18 | 19 | @Override 20 | public Citation clone() throws CloneNotSupportedException { 21 | return (Citation) super.clone(); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/designPattern/prototype/test/CitationTest.java: -------------------------------------------------------------------------------- 1 | package designPattern.prototype.test; 2 | 3 | public class CitationTest { 4 | public static void main(String[] args) throws CloneNotSupportedException { 5 | // 1.创建原型对象 6 | Citation citation1 = new Citation(); 7 | // 2.克隆奖状对象 8 | Student stu = new Student(); 9 | stu.setName("张三"); 10 | citation1.setStu(stu); 11 | 12 | // 2.克隆奖状对象 13 | Citation citation2 = citation1.clone(); 14 | citation2.getStu().setName("李四"); 15 | 16 | // citation1.setName("张三"); 17 | // 18 | // citation2.setName("李四"); 19 | 20 | 21 | 22 | // 3.调用show方法展示 23 | citation1.show(); 24 | citation2.show(); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/designPattern/prototype/test/Student.java: -------------------------------------------------------------------------------- 1 | package designPattern.prototype.test; 2 | 3 | public class Student { 4 | // 学生的姓名 5 | private String name; 6 | 7 | public String getName() { 8 | return name; 9 | } 10 | 11 | public void setName(String name) { 12 | this.name = name; 13 | } 14 | 15 | @Override 16 | public String toString() { 17 | return "Student{" + 18 | "name='" + name + '\'' + 19 | '}'; 20 | } 21 | 22 | public void show(){ 23 | System.out.println(name + "同学被评为三好学生！"); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/designPattern/prototype/test1/Citation.java: -------------------------------------------------------------------------------- 1 | package designPattern.prototype.test1; 2 | 3 | import java.io.Serializable; 4 | 5 | public class Citation implements Cloneable, Serializable { 6 | 7 | private Student stu; 8 | 9 | public Student getStu() { 10 | return stu; 11 | } 12 | 13 | public void setStu(Student stu) { 14 | this.stu = stu; 15 | } 16 | 17 | public void show(){ 18 | System.out.println(stu.getName() + "同学被评为三好学生！"); 19 | } 20 | 21 | @Override 22 | public Citation clone() throws CloneNotSupportedException { 23 | return (Citation) super.clone(); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/designPattern/prototype/test1/Student.java: -------------------------------------------------------------------------------- 1 | package designPattern.prototype.test1; 2 | 3 | import java.io.Serializable; 4 | 5 | public class Student implements Serializable { 6 | // 学生的姓名 7 | private String name; 8 | 9 | public String getName() { 10 | return name; 11 | } 12 | 13 | public void setName(String name) { 14 | this.name = name; 15 | } 16 | 17 | @Override 18 | public String toString() { 19 | return "Student{" + 20 | "name='" + name + '\'' + 21 | '}'; 22 | } 23 | 24 | public void show(){ 25 | System.out.println(name + "同学被评为三好学生！"); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/designPattern/proxy/jdkProxy/Client.java: -------------------------------------------------------------------------------- 1 | package designPattern.proxy.jdkProxy; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | // 获取代理对象 6 | // 1.创建代理工厂对象 7 | ProxyFactory factory = new ProxyFactory(); 8 | // 2.使用factory对象的方法获取代理对象 9 | SellTickets proxyObject = factory.getProxyObject(); 10 | // 3.调用卖票的方法 11 | proxyObject.sell(); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/designPattern/proxy/jdkProxy/SellTickets.java: -------------------------------------------------------------------------------- 1 | package designPattern.proxy.jdkProxy; 2 | 3 | /** 4 | * 卖火车票的接口 5 | */ 6 | public interface SellTickets { 7 | void sell(); 8 | } 9 | -------------------------------------------------------------------------------- /src/designPattern/proxy/jdkProxy/TrainStation.java: -------------------------------------------------------------------------------- 1 | package designPattern.proxy.jdkProxy; 2 | 3 | /** 4 | * 火车站类 5 | */ 6 | public class TrainStation implements SellTickets { 7 | @Override 8 | public void sell() { 9 | System.out.println("火车站卖票"); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/designPattern/proxy/staticProxy/Client.java: -------------------------------------------------------------------------------- 1 | package designPattern.proxy.staticProxy; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | // 创建代售点类对象 6 | ProxyPoint proxyPoint = new ProxyPoint(); 7 | 8 | // 调用方法进行买票 9 | proxyPoint.sell(); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/designPattern/proxy/staticProxy/ProxyPoint.java: -------------------------------------------------------------------------------- 1 | package designPattern.proxy.staticProxy; 2 | 3 | /** 4 | * 代售点类 5 | */ 6 | public class ProxyPoint implements SellTickets{ 7 | // 声明火车站类对象 8 | private TrainStation trainStation = new TrainStation(); 9 | 10 | @Override 11 | public void sell() { 12 | System.out.println("代理点收取一些服务费"); 13 | trainStation.sell(); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/designPattern/proxy/staticProxy/SellTickets.java: -------------------------------------------------------------------------------- 1 | package designPattern.proxy.staticProxy; 2 | 3 | /** 4 | * 卖火车票的接口 5 | */ 6 | public interface SellTickets { 7 | void sell(); 8 | } 9 | -------------------------------------------------------------------------------- /src/designPattern/proxy/staticProxy/TrainStation.java: -------------------------------------------------------------------------------- 1 | package designPattern.proxy.staticProxy; 2 | 3 | /** 4 | * 火车站类 5 | */ 6 | public class TrainStation implements SellTickets { 7 | @Override 8 | public void sell() { 9 | System.out.println("火车站卖票"); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/designPattern/responsibility/Client.java: -------------------------------------------------------------------------------- 1 | package designPattern.responsibility; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | // 创建一个请假条对象 6 | LeaveRequest leave = new LeaveRequest("小明", 1, "身体不适"); 7 | 8 | // 创建各级领导对象 9 | GroupLeader groupLeader = new GroupLeader(); 10 | Manager manager = new Manager(); 11 | GeneralManager generalManager = new GeneralManager(); 12 | 13 | // 设置处理者链 14 | groupLeader.setNextHandler(manager); 15 | manager.setNextHandler(generalManager); 16 | 17 | // 提交请假申请 18 | groupLeader.submit(leave); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/designPattern/responsibility/GeneralManager.java: -------------------------------------------------------------------------------- 1 | package designPattern.responsibility; 2 | 3 | /** 4 | * 总经理类 (具体的处理者) 5 | */ 6 | public class GeneralManager extends Handler { 7 | 8 | public GeneralManager(){ 9 | super(Handler.NUM_THREE, Handler.NUM_SEVEN); 10 | } 11 | 12 | @Override 13 | protected void handleLeave(LeaveRequest leave) { 14 | System.out.println(leave.getName() + "请假" + 15 | leave.getNum() + "天" + leave.getContent()); 16 | System.out.println("总经理审批: 同意"); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/designPattern/responsibility/GroupLeader.java: -------------------------------------------------------------------------------- 1 | package designPattern.responsibility; 2 | 3 | /** 4 | * 小组长类 (具体的处理者) 5 | */ 6 | public class GroupLeader extends Handler { 7 | 8 | public GroupLeader(){ 9 | super(0, Handler.NUM_ONE); 10 | } 11 | 12 | @Override 13 | protected void handleLeave(LeaveRequest leave) { 14 | System.out.println(leave.getName() + "请假" + 15 | leave.getNum() + "天" + leave.getContent()); 16 | System.out.println("小组长审批: 同意"); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/designPattern/responsibility/LeaveRequest.java: -------------------------------------------------------------------------------- 1 | package designPattern.responsibility; 2 | 3 | /** 4 | * 请假条类 5 | */ 6 | public class LeaveRequest { 7 | // 姓名 8 | private String name; 9 | 10 | // 请假天数 11 | private int num; 12 | 13 | // 请假内容 14 | private String content; 15 | 16 | public LeaveRequest(String name, int num, String content) { 17 | this.name = name; 18 | this.num = num; 19 | this.content = content; 20 | } 21 | 22 | public String getName() { 23 | return name; 24 | } 25 | 26 | public int getNum() { 27 | return num; 28 | } 29 | 30 | public String getContent() { 31 | return content; 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/designPattern/responsibility/Manager.java: -------------------------------------------------------------------------------- 1 | package designPattern.responsibility; 2 | 3 | /** 4 | * 部门经理类 (具体的处理者) 5 | */ 6 | public class Manager extends Handler { 7 | 8 | public Manager(){ 9 | super(Handler.NUM_ONE, Handler.NUM_THREE); 10 | } 11 | 12 | @Override 13 | protected void handleLeave(LeaveRequest leave) { 14 | System.out.println(leave.getName() + "请假" + 15 | leave.getNum() + "天" + leave.getContent()); 16 | System.out.println("部门经理审批: 同意"); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/designPattern/singleton/demo1/Singleton.java: -------------------------------------------------------------------------------- 1 | package designPattern.singleton.demo1; 2 | 3 | /** 4 | * 饿汉式：静态成员变量 5 | * 该方式在成员位置声明Singleton类型的静态变量，并创建Singleton类的对象instance。instance对象是随着类的加载而创建的。如果该对象足够大的话，而一直没有使用就会造成内存的浪费。 6 | */ 7 | public class Singleton { 8 | // 1.私有构造方法 9 | private Singleton(){} 10 | 11 | // 2.在分类中创建本类对象 12 | private static Singleton instance = new Singleton(); 13 | 14 | // 3.提供一个公共的访问方式，让外界获取该对象 15 | public static Singleton getInstance(){ 16 | return instance; 17 | } 18 | } 19 | 20 | class Client{ 21 | public static void main(String[] args) { 22 | // 创建Singleton类的对象 23 | Singleton instance1 = Singleton.getInstance(); 24 | 25 | Singleton instance2 = Singleton.getInstance(); 26 | 27 | // 判断获取到的两个是否是同一个对象 28 | System.out.println(instance1 == instance2); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/designPattern/singleton/demo3/Singleton.java: -------------------------------------------------------------------------------- 1 | package designPattern.singleton.demo3; 2 | 3 | /** 4 | * 懒汉式：synchronized实现 5 | * 该方式也实现了懒加载效果，同时又解决了线程安全问题。但是在getInstance()方法上添加了synchronized关键字，导致该方法的执行效果特别低。从上面代码我们可以看出，其实就是在初始化instance的时候才会出现线程安全问题，一旦初始化完成就不存在了。 6 | */ 7 | public class Singleton { 8 | // 1.私有构造方法 9 | private Singleton(){} 10 | 11 | // 2.声明Singleton类型的变量instance 12 | private static Singleton instance; 13 | 14 | // 3.对外提供访问方式 15 | public static synchronized Singleton getInstance(){ 16 | // 如果没有，创建一个并返回，如果有，直接返回 17 | if(instance == null){ 18 | instance = new Singleton(); 19 | } 20 | return instance; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/designPattern/singleton/demo5/Singleton.java: -------------------------------------------------------------------------------- 1 | package designPattern.singleton.demo5; 2 | 3 | /** 4 | * 饿汉式：静态内部类方式 5 | * 静态内部类单例模式是一种优秀的单例模式，是开源项目中比较常用的一种单例模式。在没有加任何锁的情况下，保证了多线程下的安全，并且没有任何性能影响和空间的浪费。 6 | */ 7 | public class Singleton { 8 | // 1.私有构造方法 9 | private Singleton(){} 10 | 11 | // 2.定义一个静态内部类 12 | private static class SingletonHolder{ 13 | // 在内部类中声明并初始化外部类的对象 14 | private static final Singleton INSTANCE = new Singleton(); 15 | } 16 | 17 | // 3.提供公共的访问方式 18 | public static Singleton getInstance(){ 19 | return SingletonHolder.INSTANCE; 20 | } 21 | 22 | } 23 | -------------------------------------------------------------------------------- /src/designPattern/singleton/demo6/Singleton.java: -------------------------------------------------------------------------------- 1 | package designPattern.singleton.demo6; 2 | 3 | /** 4 | * 单例设计模式分类两种： 5 | * 饿汉式：类加载就会导致该单实例对象被创建。 6 | * 懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建。 7 | */ 8 | 9 | /** 10 | * 恶汉式：枚举实现方式 11 | * 枚举类实现单例模式是极力推荐的单例实现模式，因为枚举类型是线程安全的，并且只会装载一次，设计者充分的利用了枚举的这个特性来实现单例模式，枚举的写法非常简单，而且枚举类型是所用单例实现中唯一一种不会被破坏的单例实现模式。 12 | */ 13 | public enum Singleton { 14 | INSTANCE; 15 | } 16 | 17 | class Client{ 18 | public static void main(String[] args) { 19 | Singleton instance1 = Singleton.INSTANCE; 20 | Singleton instance2 = Singleton.INSTANCE; 21 | System.out.println(instance1 == instance2); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/designPattern/singleton/demo8/RuntimeDemo.java: -------------------------------------------------------------------------------- 1 | package designPattern.singleton.demo8; 2 | 3 | import java.io.IOException; 4 | import java.io.InputStream; 5 | 6 | public class RuntimeDemo { 7 | public static void main(String[] args) throws IOException { 8 | // 获取Runtime类的对象 9 | Runtime runtime = Runtime.getRuntime(); 10 | 11 | // 调用runtime的方法 12 | Process process = runtime.exec("ipconfig"); 13 | 14 | // 调用process对象的获取输入流的方法 15 | InputStream is = process.getInputStream(); 16 | byte[] arr = new byte[1024 * 1024 * 100]; 17 | 18 | // 读取数据 19 | int len = is.read(arr); 20 | 21 | // 将字节数组转换为字符串输出到控制台 22 | System.out.println(new String(arr, 0, len, "GBK")); 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /src/designPattern/state/after/Client.java: -------------------------------------------------------------------------------- 1 | package designPattern.state.after; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | // 创建环境角色对象 6 | Context context = new Context(); 7 | 8 | // 设置当前电梯装填 9 | context.setLiftState(new StoppingState()); 10 | 11 | context.open(); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/designPattern/state/after/ClosingState.java: -------------------------------------------------------------------------------- 1 | package designPattern.state.after; 2 | 3 | /** 4 | * 电梯关闭状态类 5 | */ 6 | public class ClosingState extends LiftState { 7 | @Override 8 | public void open() { 9 | 10 | } 11 | 12 | @Override 13 | public void close() { 14 | 15 | } 16 | 17 | @Override 18 | public void run() { 19 | 20 | } 21 | 22 | @Override 23 | public void stop() { 24 | 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/designPattern/state/after/LiftState.java: -------------------------------------------------------------------------------- 1 | package designPattern.state.after; 2 | 3 | /** 4 | * 抽象状态类 5 | */ 6 | public abstract class LiftState { 7 | // 声明环境角色类变量 8 | protected Context context; 9 | 10 | public void setContext(Context context) { 11 | this.context = context; 12 | } 13 | 14 | // 电梯开启操作 15 | public abstract void open(); 16 | 17 | // 电梯关闭操作 18 | public abstract void close(); 19 | 20 | // 电梯运行操作 21 | public abstract void run(); 22 | 23 | // 电梯停止操作 24 | public abstract void stop(); 25 | } 26 | -------------------------------------------------------------------------------- /src/designPattern/state/after/OpeningState.java: -------------------------------------------------------------------------------- 1 | package designPattern.state.after; 2 | 3 | /** 4 | * 电梯开启状态类 5 | */ 6 | public class OpeningState extends LiftState { 7 | // 当前状态要执行的方法 8 | @Override 9 | public void open() { 10 | System.out.println("电梯开启..."); 11 | } 12 | 13 | @Override 14 | public void close() { 15 | // 修改状态 16 | super.context.setLiftState(Context.CLOSING_STATE); 17 | // 调用当前状态Context中的close方法 18 | super.context.close(); 19 | } 20 | 21 | @Override 22 | public void run() { 23 | // 什么都不做 24 | } 25 | 26 | @Override 27 | public void stop() { 28 | // 什么都不做 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/designPattern/state/after/RunningState.java: -------------------------------------------------------------------------------- 1 | package designPattern.state.after; 2 | 3 | /** 4 | * 电梯运行状态类 5 | */ 6 | public class RunningState extends LiftState { 7 | @Override 8 | public void open() { 9 | 10 | } 11 | 12 | @Override 13 | public void close() { 14 | 15 | } 16 | 17 | @Override 18 | public void run() { 19 | 20 | } 21 | 22 | @Override 23 | public void stop() { 24 | 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/designPattern/state/after/StoppingState.java: -------------------------------------------------------------------------------- 1 | package designPattern.state.after; 2 | 3 | /** 4 | * 电梯停止状态类 5 | */ 6 | public class StoppingState extends LiftState { 7 | @Override 8 | public void open() { 9 | 10 | } 11 | 12 | @Override 13 | public void close() { 14 | 15 | } 16 | 17 | @Override 18 | public void run() { 19 | 20 | } 21 | 22 | @Override 23 | public void stop() { 24 | 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/designPattern/state/before/Client.java: -------------------------------------------------------------------------------- 1 | package designPattern.state.before; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | // 创建电梯对象 6 | Lift lift = new Lift(); 7 | 8 | // 设置当前电梯的状态 9 | lift.setState(ILift.OPENING_STATE); 10 | 11 | // 开门 12 | lift.open(); 13 | 14 | lift.close(); 15 | 16 | lift.run(); 17 | 18 | lift.stop(); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/designPattern/state/before/ILift.java: -------------------------------------------------------------------------------- 1 | package designPattern.state.before; 2 | 3 | /** 4 | * 电梯接口 5 | */ 6 | public interface ILift { 7 | // 定义四个电梯状态的常量 8 | int OPENING_STATE = 1; 9 | int CLOSING_STATE = 2; 10 | int RUNNING_STATE = 3; 11 | int STOPPING_STATE = 4; 12 | 13 | // 设置电梯状态的功能 14 | void setState(int state); 15 | 16 | // 电梯操作功能 17 | void open(); 18 | 19 | void close(); 20 | 21 | void run(); 22 | 23 | void stop(); 24 | } 25 | -------------------------------------------------------------------------------- /src/designPattern/strategy/Client.java: -------------------------------------------------------------------------------- 1 | package designPattern.strategy; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | SalesMan salesMan = new SalesMan(new StrategyA()); 6 | salesMan.salesManShow(); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /src/designPattern/strategy/SalesMan.java: -------------------------------------------------------------------------------- 1 | package designPattern.strategy; 2 | 3 | /** 4 | * 促销员 (环境类) 5 | */ 6 | public class SalesMan { 7 | // 聚合策略类对象 8 | private Strategy strategy; 9 | 10 | public SalesMan(Strategy strategy){ 11 | this.strategy = strategy; 12 | } 13 | 14 | // 由促销员展示促销活动给用户 15 | public void salesManShow(){ 16 | strategy.show(); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/designPattern/strategy/Strategy.java: -------------------------------------------------------------------------------- 1 | package designPattern.strategy; 2 | 3 | /** 4 | * 抽象策略类 5 | */ 6 | public interface Strategy { 7 | void show(); 8 | } 9 | -------------------------------------------------------------------------------- /src/designPattern/strategy/StrategyA.java: -------------------------------------------------------------------------------- 1 | package designPattern.strategy; 2 | 3 | /** 4 | * 具体策略类，封装算法 5 | */ 6 | public class StrategyA implements Strategy{ 7 | @Override 8 | public void show() { 9 | System.out.println("买一送一"); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/designPattern/strategy/StrategyB.java: -------------------------------------------------------------------------------- 1 | package designPattern.strategy; 2 | 3 | /** 4 | * 具体策略类，封装算法 5 | */ 6 | public class StrategyB implements Strategy{ 7 | @Override 8 | public void show() { 9 | System.out.println("买200减50"); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/designPattern/strategy/StrategyC.java: -------------------------------------------------------------------------------- 1 | package designPattern.strategy; 2 | 3 | /** 4 | * 具体策略类，封装算法 5 | */ 6 | public class StrategyC implements Strategy{ 7 | @Override 8 | public void show() { 9 | System.out.println("满1000元加1元换购任意200元以下商品"); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/designPattern/template/AbstractClass.java: -------------------------------------------------------------------------------- 1 | package designPattern.template; 2 | 3 | /** 4 | * 抽象类 (定义模板方法和基本方法) 5 | */ 6 | public abstract class AbstractClass { 7 | 8 | // 模板方法定义 9 | public final void cookProcess(){ 10 | pourOil(); 11 | heatOil(); 12 | pourVegetable(); 13 | pourSauce(); 14 | fry(); 15 | } 16 | 17 | public void pourOil(){ 18 | System.out.println("倒油"); 19 | } 20 | 21 | public void heatOil(){ 22 | System.out.println("热油"); 23 | } 24 | 25 | public abstract void pourVegetable(); 26 | 27 | public abstract void pourSauce(); 28 | 29 | public void fry(){ 30 | System.out.println("炒菜"); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/designPattern/template/Client.java: -------------------------------------------------------------------------------- 1 | package designPattern.template; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | // 炒包菜, 创建对象 6 | ConcreteClassCabbage cabbage = new ConcreteClassCabbage(); 7 | cabbage.cookProcess(); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /src/designPattern/template/ConcreteClassCabbage.java: -------------------------------------------------------------------------------- 1 | package designPattern.template; 2 | 3 | /** 4 | * 炒包菜类 5 | */ 6 | public class ConcreteClassCabbage extends AbstractClass{ 7 | @Override 8 | public void pourVegetable() { 9 | System.out.println("下锅的蔬菜是包菜"); 10 | } 11 | 12 | @Override 13 | public void pourSauce() { 14 | System.out.println("下锅的酱料是辣椒"); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/designPattern/template/ConcreteClassChoySum.java: -------------------------------------------------------------------------------- 1 | package designPattern.template; 2 | 3 | /** 4 | * 炒菜心类 5 | */ 6 | public class ConcreteClassChoySum extends AbstractClass{ 7 | @Override 8 | public void pourVegetable() { 9 | System.out.println("下锅的蔬菜是菜心"); 10 | } 11 | 12 | @Override 13 | public void pourSauce() { 14 | System.out.println("下锅的酱料是蒜蓉"); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/designPattern/visitor/Animal.java: -------------------------------------------------------------------------------- 1 | package designPattern.visitor; 2 | 3 | /** 4 | * 抽象元素角色类 5 | */ 6 | public interface Animal { 7 | // 接受访问者访问的功能 8 | void accept(Person person); 9 | } 10 | -------------------------------------------------------------------------------- /src/designPattern/visitor/Cat.java: -------------------------------------------------------------------------------- 1 | package designPattern.visitor; 2 | 3 | /** 4 | * 具体元素角色类 5 | */ 6 | public class Cat implements Animal { 7 | @Override 8 | public void accept(Person person) { 9 | person.feed(this); 10 | System.out.println("好好吃, 喵!"); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/designPattern/visitor/Client.java: -------------------------------------------------------------------------------- 1 | package designPattern.visitor; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | // 创建Home对象 6 | Home home = new Home(); 7 | 8 | home.add(new Dog()); 9 | home.add(new Cat()); 10 | 11 | // 创建主人对象 12 | Owner owner = new Owner(); 13 | 14 | // 让主人喂食所有的宠物 15 | home.action(owner); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/designPattern/visitor/Dog.java: -------------------------------------------------------------------------------- 1 | package designPattern.visitor; 2 | 3 | /** 4 | * 具体元素角色类 5 | */ 6 | public class Dog implements Animal { 7 | @Override 8 | public void accept(Person person) { 9 | person.feed(this); 10 | System.out.println("好好吃, 汪!"); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/designPattern/visitor/Home.java: -------------------------------------------------------------------------------- 1 | package designPattern.visitor; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | /** 7 | * 对象结构类 8 | */ 9 | public class Home { 10 | // 声明一个集合对象，用来存储元素对象 11 | private List nodeList = new ArrayList<>(); 12 | 13 | public void add(Animal animal){ 14 | nodeList.add(animal); 15 | } 16 | 17 | public void action(Person person){ 18 | // 遍历集合，获取每一个元素，让访问者访问每一个元素 19 | for (Animal animal : nodeList) { 20 | animal.accept(person); 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/designPattern/visitor/Owner.java: -------------------------------------------------------------------------------- 1 | package designPattern.visitor; 2 | 3 | /** 4 | * 具体访问者角色类 (自己) 5 | */ 6 | public class Owner implements Person{ 7 | @Override 8 | public void feed(Cat cat) { 9 | System.out.println("主人喂食猫"); 10 | } 11 | 12 | @Override 13 | public void feed(Dog dog) { 14 | System.out.println("主人喂食狗"); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/designPattern/visitor/Person.java: -------------------------------------------------------------------------------- 1 | package designPattern.visitor; 2 | 3 | /** 4 | * 抽象访问者角色类 5 | */ 6 | public interface Person { 7 | // 喂食宠物猫 8 | void feed(Cat cat); 9 | 10 | // 喂食宠物狗 11 | void feed(Dog dog); 12 | } 13 | -------------------------------------------------------------------------------- /src/designPattern/visitor/Someone.java: -------------------------------------------------------------------------------- 1 | package designPattern.visitor; 2 | 3 | /** 4 | * 具体访问者角色类 (其他人) 5 | */ 6 | public class Someone implements Person{ 7 | @Override 8 | public void feed(Cat cat) { 9 | System.out.println("其他人喂食猫"); 10 | } 11 | 12 | @Override 13 | public void feed(Dog dog) { 14 | System.out.println("其他人喂食狗"); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/designPrinciples/demo1/AbstractSkin.java: -------------------------------------------------------------------------------- 1 | package designPrinciples.demo1; 2 | 3 | /** 4 | * 抽象皮肤类 5 | */ 6 | public abstract class AbstractSkin { 7 | 8 | // 显示方法 9 | public abstract void display(); 10 | } 11 | -------------------------------------------------------------------------------- /src/designPrinciples/demo1/Client.java: -------------------------------------------------------------------------------- 1 | package designPrinciples.demo1; 2 | 3 | public class Client { 4 | public static void main(String[] args) { 5 | // 1.创建搜狗输入对象 6 | SougouInput input = new SougouInput(); 7 | // 2.创建皮肤对象 8 | DefaultSkin skin = new DefaultSkin(); 9 | // 3.将皮肤设置到输入法中 10 | input.setSkin(skin); 11 | // 4.显示皮肤 12 | input.display(); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/designPrinciples/demo1/DefaultSkin.java: -------------------------------------------------------------------------------- 1 | package designPrinciples.demo1; 2 | 3 | public class DefaultSkin extends AbstractSkin{ 4 | @Override 5 | public void display() { 6 | System.out.println("默认皮肤"); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /src/designPrinciples/demo1/KingSkin.java: -------------------------------------------------------------------------------- 1 | package designPrinciples.demo1; 2 | 3 | public class KingSkin extends AbstractSkin { 4 | @Override 5 | public void display() { 6 | System.out.println("王者皮肤"); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /src/designPrinciples/demo1/SougouInput.java: -------------------------------------------------------------------------------- 1 | package designPrinciples.demo1; 2 | 3 | public class SougouInput { 4 | private AbstractSkin skin; 5 | 6 | public void setSkin(AbstractSkin skin) { 7 | this.skin = skin; 8 | } 9 | 10 | public void display(){ 11 | skin.display(); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/designPrinciples/demo2/after/Quadrilateral.java: -------------------------------------------------------------------------------- 1 | package designPrinciples.demo2.after; 2 | 3 | /** 4 | * 四边形接口 5 | */ 6 | public interface Quadrilateral { 7 | 8 | double getLength(); 9 | 10 | double getWidth(); 11 | } 12 | -------------------------------------------------------------------------------- /src/designPrinciples/demo2/after/Rectangle.java: -------------------------------------------------------------------------------- 1 | package designPrinciples.demo2.after; 2 | 3 | public class Rectangle implements Quadrilateral { 4 | private double length; 5 | private double width; 6 | 7 | public void setLength(double length) { 8 | this.length = length; 9 | } 10 | 11 | public void setWidth(double width) { 12 | this.width = width; 13 | } 14 | 15 | @Override 16 | public double getLength() { 17 | return length; 18 | } 19 | 20 | @Override 21 | public double getWidth() { 22 | return width; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/designPrinciples/demo2/after/RectangleDemo.java: -------------------------------------------------------------------------------- 1 | package designPrinciples.demo2.after; 2 | 3 | public class RectangleDemo { 4 | public static void main(String[] args) { 5 | Rectangle r = new Rectangle(); 6 | r.setLength(20); 7 | r.setWidth(10); 8 | resize(r); 9 | printLengthAndWidth(r); 10 | } 11 | 12 | public static void resize(Rectangle rectangle){ 13 | while (rectangle.getWidth() <= rectangle.getLength()){ 14 | rectangle.setWidth(rectangle.getWidth() + 1); 15 | } 16 | } 17 | 18 | private static void printLengthAndWidth(Quadrilateral quadrilateral){ 19 | System.out.println(quadrilateral.getLength()); 20 | System.out.println(quadrilateral.getWidth()); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/designPrinciples/demo2/after/Square.java: -------------------------------------------------------------------------------- 1 | package designPrinciples.demo2.after; 2 | 3 | /** 4 | * 正方形 5 | */ 6 | public class Square implements Quadrilateral{ 7 | 8 | private double side; 9 | 10 | public double getSide() { 11 | return side; 12 | } 13 | 14 | public void setSide(double side) { 15 | this.side = side; 16 | } 17 | 18 | @Override 19 | public double getLength() { 20 | return side; 21 | } 22 | 23 | @Override 24 | public double getWidth() { 25 | return side; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/designPrinciples/demo2/before/Rectangle.java: -------------------------------------------------------------------------------- 1 | package designPrinciples.demo2.before; 2 | 3 | /** 4 | * 长方形类 5 | */ 6 | public class Rectangle { 7 | private double length; 8 | private double width; 9 | 10 | public double getLength() { 11 | return length; 12 | } 13 | 14 | public void setLength(double length) { 15 | this.length = length; 16 | } 17 | 18 | public double getWidth() { 19 | return width; 20 | } 21 | 22 | public void setWidth(double width) { 23 | this.width = width; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/designPrinciples/demo2/before/RectangleDemo.java: -------------------------------------------------------------------------------- 1 | package designPrinciples.demo2.before; 2 | 3 | public class RectangleDemo { 4 | public static void main(String[] args) { 5 | // 创建长方形对象 6 | Rectangle r = new Rectangle(); 7 | r.setLength(20); 8 | r.setWidth(10); 9 | resize(r); 10 | printLengthAndWidth(r); 11 | } 12 | 13 | public static void resize(Rectangle rectangle){ 14 | // 判断宽如果比长小，进行扩宽的操作 15 | while (rectangle.getWidth() <= rectangle.getLength()){ 16 | rectangle.setWidth(rectangle.getWidth() + 1); 17 | } 18 | } 19 | 20 | public static void printLengthAndWidth(Rectangle rectangle){ 21 | System.out.println(rectangle.getLength()); 22 | System.out.println(rectangle.getWidth()); 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /src/designPrinciples/demo2/before/Square.java: -------------------------------------------------------------------------------- 1 | package designPrinciples.demo2.before; 2 | 3 | /** 4 | * 正方形类 5 | */ 6 | public class Square extends Rectangle { 7 | @Override 8 | public void setLength(double length) { 9 | super.setLength(length); 10 | super.setWidth(length); 11 | } 12 | 13 | @Override 14 | public void setWidth(double width) { 15 | super.setWidth(width); 16 | super.setLength(width); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/designPrinciples/demo3/ComputerDemo.java: -------------------------------------------------------------------------------- 1 | package designPrinciples.demo3; 2 | 3 | public class ComputerDemo { 4 | public static void main(String[] args) { 5 | HardDisk hardDisk = new XiJieHardDisk(); 6 | Cpu cpu = new IntelCpu(); 7 | Memory memory = new KingstonMemory(); 8 | 9 | Computer c = new Computer(); 10 | c.setCpu(cpu); 11 | c.setHardDisk(hardDisk); 12 | c.setMemory(memory); 13 | c.run(); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/designPrinciples/demo3/Cpu.java: -------------------------------------------------------------------------------- 1 | package designPrinciples.demo3; 2 | 3 | /** 4 | * cpu接口 5 | */ 6 | public interface Cpu { 7 | void run(); 8 | } 9 | -------------------------------------------------------------------------------- /src/designPrinciples/demo3/HardDisk.java: -------------------------------------------------------------------------------- 1 | package designPrinciples.demo3; 2 | 3 | /** 4 | * 硬盘接口 5 | */ 6 | public interface HardDisk { 7 | void save(String data); 8 | 9 | String get(); 10 | } 11 | -------------------------------------------------------------------------------- /src/designPrinciples/demo3/IntelCpu.java: -------------------------------------------------------------------------------- 1 | package designPrinciples.demo3; 2 | 3 | public class IntelCpu implements Cpu{ 4 | @Override 5 | public void run() { 6 | System.out.println("使用Intel处理器"); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /src/designPrinciples/demo3/KingstonMemory.java: -------------------------------------------------------------------------------- 1 | package designPrinciples.demo3; 2 | 3 | public class KingstonMemory implements Memory { 4 | @Override 5 | public void save() { 6 | System.out.println("使用金士顿内存条"); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /src/designPrinciples/demo3/Memory.java: -------------------------------------------------------------------------------- 1 | package designPrinciples.demo3; 2 | 3 | /** 4 | * 内存条接口 5 | */ 6 | public interface Memory { 7 | void save(); 8 | } 9 | -------------------------------------------------------------------------------- /src/designPrinciples/demo3/XiJieHardDisk.java: -------------------------------------------------------------------------------- 1 | package designPrinciples.demo3; 2 | 3 | public class XiJieHardDisk implements HardDisk{ 4 | @Override 5 | public void save(String data) { 6 | System.out.println("使用希捷硬盘存储数据为：" + data); 7 | } 8 | 9 | @Override 10 | public String get() { 11 | System.out.println("使用希捷硬盘读取数据"); 12 | return "数据"; 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/featuredTop/LeetCode7.java: -------------------------------------------------------------------------------- 1 | package featuredTop; 2 | 3 | public class LeetCode7 { 4 | public int reverse(int x) { 5 | int res = 0; 6 | while (x != 0){ 7 | int temp = x % 10; 8 | //判断是否 大于 最大32位整数 9 | if (res>214748364 || (res==214748364 && temp>7)) { 10 | return 0; 11 | } 12 | //判断是否 小于 最小32位整数 13 | if (res<-214748364 || (res==-214748364 && temp<-8)) { 14 | return 0; 15 | } 16 | res = res * 10 + temp; 17 | x = x / 10; 18 | } 19 | return res; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/image/img.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codinglin/leetcode/cadb24e87acc2c8f985b5ff724c4cacbefe2777e/src/image/img.png -------------------------------------------------------------------------------- /src/image/img1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codinglin/leetcode/cadb24e87acc2c8f985b5ff724c4cacbefe2777e/src/image/img1.png -------------------------------------------------------------------------------- /src/problems/LeetCode1.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | 6 | public class LeetCode1 { 7 | public int[] twoSum(int[] nums, int target) { 8 | Map hashtable = new HashMap(); 9 | for (int i = 0; i < nums.length; ++i) { 10 | if (hashtable.containsKey(target - nums[i])) { 11 | return new int[]{hashtable.get(target - nums[i]), i}; 12 | } 13 | hashtable.put(nums[i], i); 14 | } 15 | return new int[0]; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/problems/LeetCode1005.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | import java.util.Arrays; 4 | import java.util.Comparator; 5 | 6 | public class LeetCode1005 { 7 | public int largestSumAfterKNegations(int[] nums, int k) { 8 | // 排序，把可能有的负数排到前面 9 | Arrays.sort(nums); 10 | int sum = 0; 11 | for (int i = 0; i < nums.length; i++) { 12 | // 贪心：如果是负数，而 k 还有盈余，就把负数反过来 13 | if (nums[i] < 0 && k > 0) { 14 | nums[i] = -1 * nums[i]; 15 | k--; 16 | } 17 | sum += nums[i]; 18 | } 19 | Arrays.sort(nums); 20 | // 如果 k 没剩，那说明能转的负数都转正了，已经是最大和，返回 sum 21 | // 如果 k 有剩，说明负数已经全部转正，所以如果 k 还剩偶数个就自己抵消掉，不用删减，如果 k 还剩奇数个就减掉 2 倍最小正数 22 | return sum - (k % 2 == 0 ? 0 : 2 * nums[0]); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/problems/LeetCode104.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode104 { 4 | public int maxDepth(TreeNode root) { 5 | if(root == null) { 6 | return 0; 7 | } 8 | return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1; 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /src/problems/LeetCode1049.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode1049 { 4 | public int lastStoneWeightII(int[] stones) { 5 | int sum = 0; 6 | for (int weight : stones) { 7 | sum += weight; 8 | } 9 | int n = stones.length, m = sum / 2; 10 | boolean[][] dp = new boolean[n + 1][m + 1]; 11 | dp[0][0] = true; 12 | for (int i = 0; i < n; i++) { 13 | for (int j = 0; j <= m; j++) { 14 | if(j < stones[i]) { 15 | dp[i + 1][j] = dp[i][j]; 16 | } else { 17 | dp[i + 1][j] = dp[i][j] || dp[i][j - stones[i]]; 18 | } 19 | } 20 | } 21 | for (int j = m;; --j) { 22 | if (dp[n][j]) { 23 | return sum - 2 * j; 24 | } 25 | } 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/problems/LeetCode110.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode110 { 4 | public boolean isBalanced(TreeNode root) { 5 | return depth(root) >= 0; 6 | } 7 | 8 | private int depth(TreeNode root) { 9 | if(root == null) { 10 | return 0; 11 | } 12 | int left = depth(root.left); 13 | int right = depth(root.right); 14 | if(left == -1 || right == -1 || Math.abs(left - right) > 1) { 15 | return -1; 16 | } 17 | return Math.max(left, right) + 1; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/problems/LeetCode1143.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | /** 4 | * 最长公共子序列 5 | */ 6 | public class LeetCode1143 { 7 | public int longestCommonSubsequence(String text1, String text2) { 8 | char[] char1 = text1.toCharArray(); 9 | char[] char2 = text2.toCharArray(); 10 | int[][] dp = new int[char1.length + 1][char2.length + 1]; 11 | for (int i = 1; i <= char1.length; i++) { 12 | for (int j = 1; j <= char2.length; j++) { 13 | if(char1[i - 1] == char2[j - 1]) { 14 | dp[i][j] = dp[i - 1] [j - 1] + 1; 15 | } else { 16 | dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]); 17 | } 18 | } 19 | } 20 | return dp[char1.length][char2.length]; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/problems/LeetCode1155.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode1155 { 4 | } 5 | -------------------------------------------------------------------------------- /src/problems/LeetCode123.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | /** 4 | * 我们最多可以完成两笔交易，因此在任意一天结束之后，我们会处于一下五种状态中的一种： 5 | * 1.未进行任何操作 6 | * 2.只进行过一次买操作 7 | * 3.进行了一次买操作和一次卖操作，即完成了一笔交易 8 | * 4.在完成了一笔交易的前提下，进行第二次买操作 9 | * 5.完成了全部两笔交易 10 | * 由于第一个状态的利润显然为 0，因此我们可以不用将其记录。对于剩下的四个状态，我们分别将它们的最大利润记为 buy1,sell1,by2,sell2 11 | * 12 | */ 13 | public class LeetCode123 { 14 | public int maxProfit(int[] prices) { 15 | int n = prices.length; 16 | int buy1 = -prices[0], sell1 = 0; 17 | int buy2 = -prices[0], sell2 = 0; 18 | for (int i = 1; i < n; ++i) { 19 | buy1 = Math.max(buy1, -prices[i]); 20 | sell1 = Math.max(sell1, buy1 + prices[i]); 21 | buy2 = Math.max(buy2, sell1 - prices[i]); 22 | sell2 = Math.max(sell2, buy2 + prices[i]); 23 | } 24 | return sell2; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/problems/LeetCode124.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode124 { 4 | int maxValue = Integer.MIN_VALUE; 5 | 6 | public int maxPathSum(TreeNode root) { 7 | dfs(root); 8 | return maxValue; 9 | } 10 | 11 | private int dfs(TreeNode node) { 12 | if(node == null) { 13 | return 0; 14 | } 15 | // 递归计算左右子节点的最大贡献值 16 | // 只有在最大贡献值大于 0 时，才会选取对应子节点 17 | int leftGain = Math.max(dfs(node.left), 0); 18 | int rightGain = Math.max(dfs(node.right), 0); 19 | 20 | // 节点的最大路径和取决于该节点的值与该节点的左右子节点的最大贡献值 21 | int priceNewpath = node.val + leftGain + rightGain; 22 | 23 | // 更新答案 24 | maxValue = Math.max(maxValue, priceNewpath); 25 | 26 | // 返回节点的最大贡献值 27 | return node.val + Math.max(leftGain, rightGain); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/problems/LeetCode129.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode129 { 4 | public int sumNumbers(TreeNode root) { 5 | return 0; 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /src/problems/LeetCode141.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode141 { 4 | public boolean hasCycle(ListNode head) { 5 | ListNode slow = head, fast = head; 6 | while (fast != null && fast.next != null) { 7 | slow = slow.next; 8 | fast = fast.next.next; 9 | if(slow == fast) { 10 | return true; 11 | } 12 | } 13 | return false; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/problems/LeetCode142.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode142 { 4 | public ListNode detectCycle(ListNode head) { 5 | ListNode fast = head, slow = head; 6 | while (true) { 7 | if(fast == null || fast.next == null) { 8 | return null; 9 | } 10 | fast = fast.next.next; 11 | slow = slow.next; 12 | if(fast == slow) break; 13 | } 14 | fast = head; 15 | while (slow != fast) { 16 | slow = slow.next; 17 | fast = fast.next; 18 | } 19 | return fast; 20 | } 21 | } 22 | 23 | class LeetCode142_1{ 24 | public ListNode detectCycle(ListNode head) { 25 | return null; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/problems/LeetCode1480.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode1480 { 4 | public int[] runningSum(int[] nums) { 5 | int n = nums.length; 6 | int[] result = new int[n]; 7 | int sum = 0; 8 | for (int i = 0; i stack1; 8 | Deque stack2; 9 | public LeetCode155() { 10 | stack1 = new ArrayDeque<>(); 11 | stack2 = new ArrayDeque<>(); 12 | } 13 | 14 | public void push(int val) { 15 | stack1.push(val); 16 | if(!stack2.isEmpty()) { 17 | stack2.push(Math.min(stack2.peek(), val)); 18 | } else { 19 | stack2.push(val); 20 | } 21 | } 22 | 23 | public void pop() { 24 | stack1.pop(); 25 | stack2.pop(); 26 | } 27 | 28 | public int top() { 29 | return stack1.peek(); 30 | } 31 | 32 | public int getMin() { 33 | return stack2.peek(); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/problems/LeetCode160.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode160 { 4 | public ListNode getIntersectionNode(ListNode headA, ListNode headB) { 5 | if (headA == null || headB == null) return null; 6 | ListNode pA = headA, pB = headB; 7 | while (pA != pB) { 8 | pA = pA == null ? headB : pA.next; 9 | pB = pB == null ? headA : pB.next; 10 | } 11 | return pA; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/problems/LeetCode1755.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode1755 { 4 | public int minAbsDifference(int[] nums, int goal) { 5 | return 0; 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /src/problems/LeetCode198.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode198 { 4 | public int rob(int[] nums) { 5 | if (nums == null || nums.length == 0) { 6 | return 0; 7 | } 8 | int length = nums.length; 9 | if (length == 1) { 10 | return nums[0]; 11 | } 12 | int[] dp = new int[length]; 13 | dp[0] = nums[0]; 14 | dp[1] = Math.max(nums[0], nums[1]); 15 | for (int i = 2; i < length; i++) { 16 | dp[i] = Math.max(dp[i - 2] + nums[i], dp[i - 1]); 17 | } 18 | return dp[length - 1]; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/problems/LeetCode206.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode206 { 4 | public ListNode reverseList(ListNode head) { 5 | ListNode dummyNode = new ListNode(0); 6 | ListNode p = dummyNode, cur = head; 7 | while (cur != null) { 8 | ListNode t = cur; 9 | cur = cur.next; 10 | t.next = p.next; 11 | p.next = t; 12 | } 13 | return dummyNode.next; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/problems/LeetCode213.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode213 { 4 | public int rob(int[] nums) { 5 | if (nums == null || nums.length == 0) { 6 | return 0; 7 | } 8 | if(nums.length == 1) { 9 | return nums[0]; 10 | } else if (nums.length == 2) { 11 | return Math.max(nums[0], nums[1]); 12 | } 13 | return Math.max(robRange(nums, 1, nums.length - 1), robRange(nums, 0, nums.length - 2)); 14 | } 15 | 16 | public int robRange(int[] nums, int start, int end) { 17 | int[] dp = new int[nums.length]; 18 | dp[start] = nums[start]; 19 | dp[start + 1] = Math.max(nums[start], nums[start + 1]); 20 | for (int i = start + 2; i <= end; i++) { 21 | dp[i] = Math.max(dp[i - 2] + nums[i], dp[i - 1]); 22 | } 23 | return dp[end]; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/problems/LeetCode225.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | import java.util.ArrayList; 4 | import java.util.LinkedList; 5 | import java.util.Queue; 6 | 7 | public class LeetCode225 { 8 | Queue queue1; 9 | Queue queue2; 10 | 11 | public LeetCode225() { 12 | queue1 = new LinkedList<>(); 13 | queue2 = new LinkedList<>(); 14 | } 15 | 16 | public void push(int x) { 17 | queue2.add(x); 18 | while (!queue1.isEmpty()) { 19 | queue2.add(queue1.poll()); 20 | } 21 | Queue temp = queue1; 22 | queue1 = queue2; 23 | queue2 = temp; 24 | } 25 | 26 | public int pop() { 27 | return queue1.poll(); 28 | } 29 | 30 | public int top() { 31 | return queue1.peek(); 32 | } 33 | 34 | public boolean empty() { 35 | return queue1.isEmpty(); 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/problems/LeetCode264.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | import java.util.Comparator; 4 | import java.util.HashSet; 5 | import java.util.PriorityQueue; 6 | import java.util.Set; 7 | 8 | public class LeetCode264 { 9 | public int nthUglyNumber(int n) { 10 | int[] factors = {2, 3, 5}; 11 | Set set = new HashSet<>(); 12 | PriorityQueue heap= new PriorityQueue<>(); 13 | set.add(1L); 14 | heap.add(1L); 15 | int ugly = 0; 16 | for (int i = 0; i < n; i++) { 17 | long curr = heap.poll(); 18 | ugly = (int) curr; 19 | for (int factor : factors) { 20 | long next = curr * factor; 21 | if (set.add(next)) { 22 | heap.offer(next); 23 | } 24 | } 25 | } 26 | return ugly; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/problems/LeetCode27.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode27 { 4 | public int removeElement(int[] nums, int val) { 5 | int length = nums.length; 6 | int k = 0; 7 | for (int i = 0; i < length; i++) { 8 | if(nums[i] == val){ 9 | continue; 10 | } 11 | nums[k++] = nums[i]; 12 | } 13 | return k; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/problems/LeetCode279.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode279 { 4 | } 5 | -------------------------------------------------------------------------------- /src/problems/LeetCode3.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | 6 | public class LeetCode3 { 7 | public int lengthOfLongestSubstring(String s) { 8 | int start = 0, end = 0; 9 | int n = s.length(), ans = 0; 10 | Map map = new HashMap<>(); 11 | while (end < n) { 12 | char c = s.charAt(end); 13 | if(map.containsKey(c)) { 14 | start = Math.max(map.get(c), start); 15 | } 16 | map.put(c, end + 1); 17 | ans = Math.max(ans, end - start + 1); 18 | end ++; 19 | } 20 | return ans; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/problems/LeetCode303.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode303 { 4 | int[] sums; 5 | public LeetCode303(int[] nums) { 6 | sums = new int[nums.length+1]; 7 | sums[0] = 0; 8 | for(int i=0; i< nums.length; i++){ 9 | sums[i+1]=nums[i]+sums[i]; 10 | } 11 | } 12 | 13 | public int sumRange(int left, int right) { 14 | return sums[right+1]-sums[left]; 15 | } 16 | 17 | public static void main(String[] args) { 18 | int[] nums = {-2,0,3,-5,2,-1}; 19 | LeetCode303 a = new LeetCode303(nums); 20 | for(int i=0;i>1]+i/2; 9 | } 10 | return v; 11 | } 12 | 13 | public static void main(String[] args) { 14 | 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/problems/LeetCode343.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode343 { 4 | public int integerBreak(int n) { 5 | int[] dp = new int[n + 1]; 6 | for (int i = 2; i <= n; i++) { 7 | int curMax = 0; 8 | /** 9 | * 当 i >= 2 时，假设对正整数 i 拆分出的第一个正整数是 j (1 <= j < i），则有以下两种方案： 10 | * 1. 将 i 拆分成 j 和 i - j 的和，且 i - j 不再拆分成多个正整数，此时的乘积是 j * (i - j) 11 | * 2. 将 i 拆分成 j 和 i - j 的和，且 i - j 继续拆分成多个正整数，此时的乘积是 j * dp[i - j] 12 | */ 13 | for (int j = 1; j < i; j++) { 14 | curMax = Math.max(curMax, Math.max(j * (i - j), j * dp[i - j])); 15 | } 16 | dp[i] = curMax; 17 | } 18 | return dp[n]; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/problems/LeetCode377.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode377 { 4 | public int combinationSum4(int[] nums, int target) { 5 | return 0; 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /src/problems/LeetCode385.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode385 { 4 | int index = 0; 5 | public NestedInteger deserialize(String s) { 6 | return null; 7 | } 8 | } -------------------------------------------------------------------------------- /src/problems/LeetCode406.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode406 { 4 | public int[][] reconstructQueue(int[][] people) { 5 | return null; 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /src/problems/LeetCode455.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | import java.util.Arrays; 4 | 5 | public class LeetCode455 { 6 | public int findContentChildren(int[] g, int[] s) { 7 | int j = 0; 8 | int count = 0; 9 | Arrays.sort(g); 10 | Arrays.sort(s); 11 | for (int i = 0; i < g.length; i++) { 12 | while (j < s.length) { 13 | if(s[j] >= g[i]) { 14 | count++; 15 | j++; 16 | break; 17 | } 18 | j++; 19 | } 20 | } 21 | return count; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/problems/LeetCode494.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode494 { 4 | int count = 0; 5 | public int findTargetSumWays(int[] nums, int target) { 6 | backtrace(nums, target, 0, 0); 7 | return count; 8 | } 9 | 10 | private void backtrace(int[] nums, int target, int index, int sum) { 11 | if(index == nums.length) { // 题目要求将全部整数联合起来，因此条件必须是 index == nums.length 12 | if(sum == target) count++; 13 | return; 14 | } 15 | backtrace(nums, target, index + 1, sum + nums[index]); 16 | backtrace(nums, target, index + 1, sum - nums[index]); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/problems/LeetCode516.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode516 { 4 | public int longestPalindromeSubseq(String s) { 5 | int n = s.length(); 6 | int[][] dp = new int[n][n]; 7 | for (int i = n - 1; i >= 0; i--) { 8 | dp[i][i] = 1; 9 | char c1 = s.charAt(i); 10 | for (int j = i + 1; j < n; j++) { 11 | char c2 = s.charAt(j); 12 | if(c1 == c2) { 13 | dp[i][j] = dp[i + 1][j - 1] + 2; 14 | } else { 15 | dp[i][j] = Math.max(dp[i + 1][j] , dp[i][j - 1]); 16 | } 17 | } 18 | } 19 | return dp[0][n - 1]; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/problems/LeetCode518.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode518 { 4 | public int change(int amount, int[] coins) { 5 | int[] dp = new int[amount + 1]; 6 | dp[0] = 1; 7 | for (int i = 0; i < coins.length; i++) { 8 | for (int j = coins[i]; j <= amount; j++) { 9 | dp[j] += dp[j - coins[i]]; 10 | } 11 | } 12 | return dp[amount]; 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/problems/LeetCode530.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode530 { 4 | int pre; 5 | int ans; 6 | 7 | public int getMinimumDifference(TreeNode root) { 8 | ans = Integer.MAX_VALUE; 9 | pre = -1; 10 | dfs(root); 11 | return ans; 12 | } 13 | 14 | public void dfs(TreeNode root) { 15 | if (root == null) { 16 | return; 17 | } 18 | dfs(root.left); 19 | if (pre == -1) { 20 | pre = root.val; 21 | } else { 22 | ans = Math.min(ans, root.val - pre); 23 | pre = root.val; 24 | } 25 | dfs(root.right); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/problems/LeetCode543.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode543 { 4 | int maxd=0; 5 | public int diameterOfBinaryTree(TreeNode root) { 6 | depth(root); 7 | return maxd; 8 | } 9 | public int depth(TreeNode node){ 10 | if(node==null){ 11 | return 0; 12 | } 13 | int Left = depth(node.left); 14 | int Right = depth(node.right); 15 | maxd=Math.max(Left+Right,maxd);//将每个节点最大直径(左子树深度+右子树深度)当前最大值比较并取大者 16 | return Math.max(Left,Right)+1;//返回节点深度 17 | } 18 | } 19 | 20 | -------------------------------------------------------------------------------- /src/problems/LeetCode567.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | import java.util.*; 4 | 5 | public class LeetCode567 { 6 | public boolean checkInclusion(String s1, String s2) { 7 | int n = s1.length(), m = s2.length(); 8 | if (n > m) { 9 | return false; 10 | } 11 | int[] cnt1 = new int[26]; 12 | int[] cnt2 = new int[26]; 13 | for (int i = 0; i < n; i++) { 14 | ++cnt1[s1.charAt(i) - 'a']; 15 | ++cnt2[s2.charAt(i) - 'a']; 16 | } 17 | if(Arrays.equals(cnt1, cnt2)) { 18 | return true; 19 | } 20 | for (int i = n; i < m; i++) { 21 | ++cnt2[s2.charAt(i) - 'a']; 22 | --cnt2[s2.charAt(i - n) - 'a']; 23 | if (Arrays.equals(cnt1, cnt2)) { 24 | return true; 25 | } 26 | } 27 | return false; 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/problems/LeetCode58.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode58 { 4 | public static int lengthOfLastWord(String s) { 5 | String[] c = s.trim().split(" +"); 6 | return c[c.length-1].length(); 7 | } 8 | 9 | public static void main(String[] args) { 10 | String s = " fly me to the moon "; 11 | lengthOfLastWord(s); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/problems/LeetCode62.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | import java.util.Arrays; 4 | 5 | public class LeetCode62 { 6 | public int uniquePaths(int m, int n) { 7 | int dp[][]=new int[m+1][n+1]; 8 | // Arrays.fill(dp[1],1); 9 | // for(int i=1;i<=n;i++){ 10 | // dp[1][i]=1; 11 | // } 12 | for(int i=1;i<=m;i++){ 13 | for(int j=1;j<=n;j++){ 14 | if(i==1||j==1){ 15 | dp[i][j]=1; 16 | }else{ 17 | dp[i][j]=dp[i-1][j]+dp[i][j-1]; 18 | } 19 | } 20 | } 21 | return dp[m][n]; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/problems/LeetCode64.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode64 { 4 | public int minPathSum(int[][] grid) { 5 | int n=grid.length; 6 | int m=grid[0].length; 7 | int dp[][]=new int[n+1][m+1]; 8 | for(int i=1;i<=n;i++){ 9 | for(int j=1;j<=m;j++){ 10 | if(i==1){ 11 | dp[i][j]=dp[i][j-1]+grid[i-1][j-1]; 12 | } 13 | else if(j==1){ 14 | dp[i][j]=dp[i-1][j]+grid[i-1][j-1]; 15 | }else{ 16 | dp[i][j]=Math.min(dp[i-1][j]+grid[i-1][j-1],dp[i][j-1]+grid[i-1][j-1]); 17 | } 18 | } 19 | } 20 | return dp[n][m]; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/problems/LeetCode647.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode647 { 4 | public int countSubstrings(String s) { 5 | if(s.length() == 0) { 6 | return 0; 7 | } 8 | boolean[][] dp = new boolean[s.length()][s.length()]; 9 | int count = 0; 10 | for (int i = 0; i < s.length(); i++) { 11 | for (int j = 0; j <= i; j++) { 12 | if (s.charAt(i) == s.charAt(j) && (i - j < 2 || dp[j + 1][i - 1])) { 13 | dp[j][i] = true; 14 | count++; 15 | } 16 | } 17 | } 18 | return count; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/problems/LeetCode654.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode654 { 4 | public TreeNode constructMaximumBinaryTree(int[] nums) { 5 | return construct(nums, 0, nums.length - 1); 6 | } 7 | 8 | private TreeNode construct(int[] nums, int left, int right) { 9 | if(left > right) { 10 | return null; 11 | } 12 | int best = left; 13 | for (int i = left; i <= right; i++) { 14 | if(nums[i] > nums[best]) { 15 | best = i; 16 | } 17 | } 18 | TreeNode node = new TreeNode(nums[best]); 19 | node.left = construct(nums, left, best - 1); 20 | node.right = construct(nums, best + 1, right); 21 | return node; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/problems/LeetCode700.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode700 { 4 | public TreeNode searchBST(TreeNode root, int val) { 5 | if(root == null) { 6 | return null; 7 | } 8 | if(root.val == val) { 9 | return root; 10 | } 11 | else if(root.val > val) { 12 | return searchBST(root.left, val); 13 | } else { 14 | return searchBST(root.right, val); 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/problems/LeetCode701.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode701 { 4 | public TreeNode insertIntoBST(TreeNode root, int val) { 5 | if (root == null) { 6 | return new TreeNode(val); 7 | } 8 | TreeNode pos = root; 9 | while (pos != null) { 10 | if(val < pos.val) { 11 | if(pos.left == null) { 12 | pos.left = new TreeNode(val); 13 | break; 14 | } else { 15 | pos = pos.left; 16 | } 17 | } else { 18 | if(pos.right == null) { 19 | pos.right = new TreeNode(val); 20 | break; 21 | } else { 22 | pos = pos.right; 23 | } 24 | } 25 | } 26 | return root; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/problems/LeetCode71.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode71 { 4 | public String simplifyPath(String path) { 5 | return null; 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /src/problems/LeetCode724.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode724 { 4 | 5 | } 6 | -------------------------------------------------------------------------------- /src/problems/LeetCode739.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | public class LeetCode739 { 7 | public int[] dailyTemperatures(int[] temperatures) { 8 | List path = new ArrayList<>(); 9 | int n = temperatures.length; 10 | if(n == 0) { 11 | return new int[]{}; 12 | } 13 | int[] ans = new int[n]; 14 | int end = 0; 15 | while (end < n) { 16 | while(path.size() > 0 && temperatures[end] > temperatures[path.get(path.size() - 1)]) { 17 | int prevIndex = path.remove(path.size() - 1); 18 | ans[prevIndex] = end - prevIndex; 19 | } 20 | path.add(end); 21 | end ++; 22 | } 23 | return ans; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/problems/LeetCode746.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode746 { 4 | public int minCostClimbingStairs(int[] cost) { 5 | int n = cost.length; 6 | int[] dp = new int[n + 1]; 7 | for (int i = 2; i <= n; i++) { 8 | dp[i] = Math.min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]); 9 | } 10 | return dp[n]; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/problems/LeetCode80.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode80 { 4 | public static int removeDuplicates(int[] nums) { 5 | int n = nums.length; 6 | int k = 0, ans = nums[0], repeat=0; 7 | for(int i=0;i2){ 14 | k++; 15 | } 16 | nums[i-k] = nums[i]; 17 | ans = nums[i]; 18 | } 19 | System.out.println(n-k); 20 | return n-k; 21 | } 22 | 23 | public static void main(String[] args) { 24 | int[] nums = {0,0,1,1,1,1,2,3,3}; 25 | removeDuplicates(nums); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/problems/LeetCode83.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode83 { 4 | public ListNode deleteDuplicates(ListNode head) { 5 | ListNode cur = head; 6 | while (cur != null && cur.next != null) { 7 | if(cur.val == cur.next.val) { 8 | cur.next = cur.next.next; 9 | } else { 10 | cur = cur.next; 11 | } 12 | } 13 | return head; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/problems/LeetCode860.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode860 { 4 | // 维护两个变量 five 和 ten 表示当前手中拥有 5 美元 和 10 美元钞票的张数 5 | public boolean lemonadeChange(int[] bills) { 6 | int five = 0, ten = 0; 7 | for (int bill : bills) { 8 | if(bill == 5) { 9 | five++; 10 | } else if (bill == 10) { 11 | if(five == 0){ 12 | return false; 13 | } 14 | five --; 15 | ten ++; 16 | } else { 17 | if(five > 0 && ten > 0){ 18 | five --; 19 | ten --; 20 | } else if (five >= 3) { 21 | five -= 3; 22 | } else { 23 | return false; 24 | } 25 | } 26 | } 27 | return true; 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/problems/LeetCode879.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode879 { 4 | } 5 | -------------------------------------------------------------------------------- /src/problems/LeetCode89.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | /** 7 | * 设n阶格雷码集合为G(n)，则G(n+1)阶格雷码为： 8 | * 给G(n)阶格雷码每个元素二进制形式前面添加0，得到G'(n); 9 | * 设G(n)集合倒序（镜像）为R(n),给R(n)每个元素二进制形式前面添加1，得到R'(n); 10 | * G(n+1) = G'(n) U R'(n)拼接两个集合即可得到下一阶格雷码 11 | * 根据以上规律，可从0阶格雷码推导到任何阶格雷码。 12 | */ 13 | public class LeetCode89 { 14 | public List grayCode(int n) { 15 | List res = new ArrayList() {{ add(0); }}; 16 | int head = 1; 17 | for (int i = 0; i < n; i++) { 18 | for (int j = res.size() - 1; j >= 0; j--) 19 | res.add(head + res.get(j)); 20 | head <<= 1; 21 | } 22 | return res; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/problems/LeetCode922.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode922 { 4 | public int[] sortArrayByParityII(int[] nums) { 5 | int n = nums.length; 6 | int j = 1; 7 | for (int i = 0; i < n; i += 2) { 8 | if(nums[i] % 2 == 1) { 9 | while (nums[j] % 2 == 1) { 10 | j += 2; 11 | } 12 | swap(nums, i, j); 13 | } 14 | } 15 | return nums; 16 | } 17 | 18 | private void swap(int[] nums, int i, int j) { 19 | int temp = nums[i]; 20 | nums[i] = nums[j]; 21 | nums[j] = temp; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/problems/LeetCode96.java: -------------------------------------------------------------------------------- 1 | package problems; 2 | 3 | public class LeetCode96 { 4 | /** 5 | * 我们可以定义两个函数： 6 | * 1. G(n): 长度为 n 的序列能构成的不同二叉搜索树的个数 7 | * 2. F(i, n): 以 i 为根、序列长度为 n 的不同二叉搜索树个数（1 <= i <= n) 8 | */ 9 | public int numTrees(int n) { 10 | int[] G = new int[n + 1]; 11 | G[0] = 1; 12 | G[1] = 1; 13 | for (int i = 2; i <= n; i++) { 14 | for (int j = 1; j <= i; j++) { 15 | G[i] += G[j - 1] * G[i - j]; 16 | } 17 | } 18 | return G[n]; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/summarize/head-stack-hash.md: -------------------------------------------------------------------------------- 1 | # 堆、栈、队列、哈希表类 2 | 3 | ## Queue题目： 4 | [225. 用队列实现栈](../problems/LeetCode225.java) 5 | 6 | [54. 螺旋矩阵](../problems/LeetCode54.java) 7 | 8 | ## Stack题目： 9 | [155. 最小栈](../problems/LeetCode155.java) 10 | 11 | [232. 用栈实现队列](../problems/LeetCode232.java) 12 | 13 | [150. 逆波兰表达式求值](../problems/LeetCode150.java) 14 | 15 | ## Heap／Priority Queue题目： 16 | [973. 最接近原点的K个点](../problems/LeetCode973.java) 17 | 18 | [347. 前K个高频元素](../problems/LeetCode347.java) 19 | 20 | [23. 合并K个升序链表](../problems/LeetCode23.java) 21 | 22 | [264. 丑数II](../problems/LeetCode264.java) 23 | 24 | [378. 有序矩阵中第 K 小的元素](../problems/LeetCode378.java) -------------------------------------------------------------------------------- /src/summarize/sort.md: -------------------------------------------------------------------------------- 1 | 基础知识：快速排序（Quick Sort）， 归并排序（Merge Sort）的原理与代码实现。需要能讲明白代码中每一行的目的。快速排序时间复杂度平均状态下O（NlogN），空间复杂度O（1），归并排序最坏情况下时间复杂度O（NlogN），空间复杂度O（N） 2 | 3 | 例题整理： 4 | 5 | [148. 排序链表](../problems/LeetCode148.java) (入门) 6 | 7 | [56. 合并区间](../problems/LeetCode56.java) (入门) 8 | 9 | [27. 移除元素](../problems/LeetCode27.java) (入门) 10 | 11 | [179. 最大数](../problems/LeetCode179.java) (进阶) 12 | 13 | [75. 颜色分类](../problems/LeetCode75.java) (进阶) 14 | 15 | [215. 数组中的第K个最大元素](../problems/LeetCode215.java) (进阶，快速排序) 16 | 17 | [4. 寻找两个正序数组的中位数](../problems/LeetCode4.java) (进阶，二分) -------------------------------------------------------------------------------- /src/test/RedBook22Test.java: -------------------------------------------------------------------------------- 1 | package test; 2 | 3 | public class RedBook22Test { 4 | public static void main(String[] args) { 5 | 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /src/test/TestMain.java: -------------------------------------------------------------------------------- 1 | package test; 2 | 3 | public class TestMain { 4 | public static void main(String[] args) { 5 | 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /src/tree/TreeNode.java: -------------------------------------------------------------------------------- 1 | package tree; 2 | 3 | public class TreeNode { 4 | E val; 5 | TreeNode left = null; 6 | TreeNode right = null; 7 | TreeNode(){}; 8 | TreeNode(E x){ 9 | val = x; 10 | } 11 | @Override 12 | public String toString() { 13 | return "TreeNode{" + 14 | "val=" + val + 15 | ", left=" + left + 16 | ", right=" + right + 17 | '}'; 18 | } 19 | } 20 | --------------------------------------------------------------------------------