├── .gitignore ├── README.md ├── c ├── array │ ├── 3sum-closest.c │ ├── 3sum.c │ ├── 4sum.c │ ├── best-time-to-buy-and-sell-stock-ii.c │ ├── best-time-to-buy-and-sell-stock-iii.c │ ├── best-time-to-buy-and-sell-stock.c │ ├── best-time-to-buy-and-sell-stock[2].c │ ├── combination-sum-ii.c │ ├── combination-sum-iii.c │ ├── combination-sum.c │ ├── combination-sum.cpp │ ├── construct-binary-tree-from-inorder-and-postorder-traversal.c │ ├── construct-binary-tree-from-preorder-and-inorder-traversal.c │ ├── container-with-most-water.c │ ├── contains-duplicate-ii.c │ ├── contains-duplicate.c │ ├── find-minimum-in-rotated-sorted-array-ii.c │ ├── find-minimum-in-rotated-sorted-array.c │ ├── find-minimum-in-rotated-sorted-array[1].c │ ├── find-peak-element.c │ ├── find-peak-element[1].c │ ├── first-missing-positive.c │ ├── insert-interval.c │ ├── jump-game-ii.c │ ├── jump-game.c │ ├── largest-rectangle-in-histogram.c │ ├── longest-consecutive-sequence.cpp │ ├── majority-element-ii.c │ ├── majority-element.c │ ├── maximal-rectangle.c │ ├── maximum-product-subarray.c │ ├── maximum-subarray.c │ ├── median-of-two-sorted-arrays.c │ ├── median-of-two-sorted-arrays[1].c │ ├── merge-sorted-array.c │ ├── minimum-path-sum.c │ ├── minimum-size-subarray-sum.c │ ├── minimum-size-subarray-sum[1].c │ ├── pascals-triangle-ii.c │ ├── pascals-triangle.c │ ├── plus-one.c │ ├── product-of-array-except-self.c │ ├── remove-duplicates-from-sorted-array-ii.c │ ├── remove-duplicates-from-sorted-array.c │ ├── remove-element.c │ ├── rotate-array.c │ ├── rotate-image.c │ ├── search-a-2d-matrix.c │ ├── search-for-a-range.c │ ├── search-in-rotated-sorted-array-ii.c │ ├── search-in-rotated-sorted-array.c │ ├── search-insert-position.c │ ├── set-matrix-zeroes.c │ ├── set-matrix-zeroes[1].c │ ├── sort-colors.c │ ├── sort-colors[1].c │ ├── spiral-matrix-ii.c │ ├── spiral-matrix-ii[1].c │ ├── spiral-matrix.c │ ├── spiral-matrix[1].c │ ├── subsets-ii.c │ ├── subsets.c │ ├── subsets[1].c │ ├── subsets[2].c │ ├── summary-ranges.c │ ├── trapping-rain-water.c │ ├── triangle.c │ ├── triangle[1].c │ ├── two-sum.c │ ├── two-sum[1].c │ ├── unique-paths-ii.c │ ├── unique-paths.c │ └── word-search.c ├── backtracking │ ├── regular-expression-matching.c │ └── regular-expression-matching[2].c ├── binary-search │ ├── count-complete-tree-nodes.c │ ├── divide-two-integers.c │ ├── dungeon-game.c │ ├── find-minimum-in-rotated-sorted-array-ii.c │ ├── find-minimum-in-rotated-sorted-array.c │ ├── find-peak-element.c │ ├── find-peak-element[1].c │ ├── find-the-duplicate-number.c │ ├── first-bad-version.c │ ├── kth-smallest-element-in-a-bst.c │ ├── kth-smallest-element-in-a-bst[1].c │ ├── longest-increasing-subsequence.c │ ├── median-of-two-sorted-arrays.c │ ├── minimum-size-subarray-sum.c │ ├── powx-n.c │ ├── search-a-2d-matrix-ii.c │ ├── search-a-2d-matrix.c │ ├── search-a-2d-matrix[2].c │ ├── search-for-a-range.c │ ├── search-in-rotated-sorted-array-ii.c │ ├── search-in-rotated-sorted-array.c │ ├── search-insert-position.c │ └── sqrtx.c ├── divide-and-conquer │ ├── kth-largest-element-in-an-array.c │ ├── majority-element.c │ ├── maximum-subarray.c │ ├── median-of-two-sorted-arrays.c │ ├── merge-k-sorted-lists.c │ └── search-a-2d-matrix-ii.c ├── dynamic-programming │ ├── Mem-Limit-Exceeded_wildcard-matching.c │ ├── best-time-to-buy-and-sell-stock-iii.c │ ├── best-time-to-buy-and-sell-stock-iv.c │ ├── best-time-to-buy-and-sell-stock-iv[2].c │ ├── best-time-to-buy-and-sell-stock-with-cooldown.c │ ├── best-time-to-buy-and-sell-stock.c │ ├── best-time-to-buy-and-sell-stock[2].c │ ├── burst-balloons.c │ ├── climbing-stairs.c │ ├── climbing-stairs[2].c │ ├── coin-change.c │ ├── counting-bits.c │ ├── counting-bits[2].c │ ├── decode-ways.c │ ├── distinct-subsequences.c │ ├── dungeon-game.c │ ├── edit-distance.c │ ├── house-robber-ii.c │ ├── house-robber-ii[2].c │ ├── house-robber.c │ ├── house-robber[2].c │ ├── interleaving-string.c │ ├── longest-increasing-subsequence.c │ ├── longest-increasing-subsequence[2].c │ ├── longest-valid-parentheses.c │ ├── longest-valid-parentheses[2].c │ ├── maximal-rectangle.c │ ├── maximal-square.c │ ├── maximum-product-subarray.c │ ├── maximum-subarray.c │ ├── maximum-subarray[2].c │ ├── maximum-subarray[3].c │ ├── minimum-path-sum.c │ ├── palindrome-partitioning-ii.c │ ├── perfect-squares.c │ ├── range-sum-query-2d-immutable.c │ ├── range-sum-query-immutable.c │ ├── regular-expression-matching.c │ ├── regular-expression-matching[2].c │ ├── triangle.c │ ├── ugly-number-ii.c │ ├── unique-binary-search-trees.c │ ├── unique-paths-ii.c │ ├── unique-paths-ii[2].c │ ├── unique-paths.c │ ├── unique-paths[2].c │ └── wildcard-matching.c ├── greedy │ └── assign-cookies.c ├── hash-table │ ├── 4sum-ii.c │ ├── 4sum.c │ ├── binary-tree-inorder-traversal.c │ ├── binary-tree-inorder-traversal[1].c │ ├── bulls-and-cows.c │ ├── contains-duplicate-ii.c │ ├── contains-duplicate.c │ ├── copy-list-with-random-pointer.c │ ├── count-primes.c │ ├── find-all-anagrams-in-a-string.c │ ├── find-the-difference.c │ ├── happy-number.c │ ├── happy-number[1].c │ ├── island-perimeter.c │ ├── isomorphic-strings.c │ ├── isomorphic-strings[1].c │ ├── keyboard-row.c │ ├── longest-palindrome.c │ ├── longest-substring-without-repeating-characters.c │ ├── maximal-rectangle.c │ ├── minimum-window-substring.c │ ├── number-of-boomerangs.c │ ├── single-number.c │ ├── two-sum.c │ ├── valid-anagram.c │ └── word-pattern.c ├── linked-list │ ├── add-two-numbers.c │ ├── convert-sorted-list-to-binary-search-tree.c │ ├── copy-list-with-random-pointer.c │ ├── delete-node-in-a-linked-list.c │ ├── insertion-sort-list.c │ ├── intersection-of-two-linked-lists.c │ ├── linked-list-cycle-ii.c │ ├── linked-list-cycle.c │ ├── merge-k-sorted-lists.c │ ├── merge-two-sorted-lists.c │ ├── palindrome-linked-list.c │ ├── palindrome-linked-list[2].c │ ├── partition-list.c │ ├── remove-duplicates-from-sorted-list-ii.c │ ├── remove-duplicates-from-sorted-list.c │ ├── remove-linked-list-elements.c │ ├── remove-nth-node-from-end-of-list.c │ ├── reorder-list.c │ ├── reorder-list[2].c │ ├── reverse-linked-list-ii.c │ ├── reverse-linked-list.c │ ├── reverse-nodes-in-k-group.c │ ├── rotate-list.c │ ├── rotate-list[2].c │ ├── sort-list.c │ └── swap-nodes-in-pairs.c ├── math │ ├── add-binary.c │ ├── add-digits.c │ ├── add-digits[1].c │ ├── add-two-numbers.c │ ├── basic-calculator.c │ ├── basic-calculator[1].c │ ├── count-primes.c │ ├── divide-two-integers.c │ ├── excel-sheet-column-number.c │ ├── excel-sheet-column-title.c │ ├── factorial-trailing-zeroes.c │ ├── happy-number.c │ ├── integer-to-roman.c │ ├── missing-number.c │ ├── missing-number[1].c │ ├── number-of-digit-one.c │ ├── palindrome-number.c │ ├── perfect-squares.c │ ├── perfect-squares[1].c │ ├── plus-one.c │ ├── power-of-two.c │ ├── power-of-two[1].c │ ├── powx-n.c │ ├── reverse-integer.c │ ├── sqrtx.c │ ├── string-to-integer-atoi.c │ ├── ugly-number-ii.c │ ├── ugly-number.c │ └── valid-number.c ├── stack │ ├── basic-calculator.c │ ├── basic-calculator[2].c │ ├── binary-search-tree-iterator.c │ ├── binary-tree-inorder-traversal.c │ ├── binary-tree-postorder-traversal.c │ ├── binary-tree-preorder-traversal.c │ ├── binary-tree-zigzag-level-order-traversal.c │ ├── evaluate-reverse-polish-notation.c │ ├── implement-queue-using-stacks.c │ ├── implement-stack-using-queues.c │ ├── largest-rectangle-in-histogram.c │ ├── maximal-rectangle.c │ ├── min-stack.c │ ├── min-stack.cpp │ ├── remove-duplicate-letters.c │ ├── simplify-path.c │ ├── trapping-rain-water.c │ ├── valid-parentheses.c │ ├── valid-parentheses[2].c │ └── verify-preorder-serialization-of-a-binary-tree.c ├── string │ ├── add-binary.c │ ├── compare-version-numbers.c │ ├── count-and-say.c │ ├── decode-ways.c │ ├── decode-ways[1].c │ ├── distinct-subsequences.c │ ├── edit-distance.c │ ├── implement-strstr.c │ ├── integer-to-roman.c │ ├── interleaving-string.c │ ├── length-of-last-word.c │ ├── length-of-last-word[1].c │ ├── longest-common-prefix.c │ ├── longest-common-prefix[1].c │ ├── longest-palindromic-substring.c │ ├── longest-substring-without-repeating-characters.c │ ├── roman-to-integer.c │ ├── string-to-integer-atoi.c │ ├── valid-palindrome.c │ └── valid-parentheses.c ├── tree │ ├── balanced-binary-tree.c │ ├── binary-search-tree-iterator.c │ ├── binary-tree-inorder-traversal.c │ ├── binary-tree-level-order-traversal-ii.c │ ├── binary-tree-level-order-traversal.c │ ├── binary-tree-maximum-path-sum.c │ ├── binary-tree-postorder-traversal.c │ ├── binary-tree-postorder-traversal[1].c │ ├── binary-tree-preorder-traversal.c │ ├── binary-tree-preorder-traversal[1].c │ ├── binary-tree-right-side-view.c │ ├── binary-tree-right-side-view[1].c │ ├── binary-tree-zigzag-level-order-traversal.c │ ├── construct-binary-tree-from-inorder-and-postorder-traversal.c │ ├── construct-binary-tree-from-preorder-and-inorder-traversal.c │ ├── convert-sorted-array-to-binary-search-tree.c │ ├── count-complete-tree-nodes.c │ ├── flatten-binary-tree-to-linked-list.c │ ├── flatten-binary-tree-to-linked-list[2].c │ ├── house-robber-iii.c │ ├── house-robber-iii[1].c │ ├── invert-binary-tree.c │ ├── kth-smallest-element-in-a-bst.c │ ├── lowest-common-ancestor-of-a-binary-search-tree.c │ ├── lowest-common-ancestor-of-a-binary-search-tree[1].c │ ├── lowest-common-ancestor-of-a-binary-search-tree[2].c │ ├── lowest-common-ancestor-of-a-binary-tree.c │ ├── maximum-depth-of-binary-tree.c │ ├── maximum-depth-of-binary-tree[1].c │ ├── minimum-depth-of-binary-tree.c │ ├── path-sum.c │ ├── populating-next-right-pointers-in-each-node-ii.c │ ├── populating-next-right-pointers-in-each-node-ii[1].c │ ├── populating-next-right-pointers-in-each-node.c │ ├── populating-next-right-pointers-in-each-node[1].c │ ├── recover-binary-search-tree.c │ ├── same-tree.c │ ├── sum-root-to-leaf-numbers.c │ ├── symmetric-tree.c │ ├── unique-binary-search-trees.c │ ├── validate-binary-search-tree.c │ └── validate-binary-search-tree[1].c └── two-pointers │ ├── 3sum-closest.c │ ├── 3sum.c │ ├── 4sum.c │ ├── container-with-most-water.c │ ├── implement-strstr.c │ ├── linked-list-cycle-ii.c │ ├── linked-list-cycle.c │ ├── longest-substring-without-repeating-characters.c │ ├── longest-substring-without-repeating-characters[1].c │ ├── merge-sorted-array.c │ ├── minimum-size-subarray-sum.c │ ├── palindrome-linked-list.c │ ├── remove-duplicates-from-sorted-array-ii.c │ ├── remove-duplicates-from-sorted-array.c │ ├── remove-element.c │ ├── remove-nth-node-from-end-of-list.c │ ├── rotate-list.c │ ├── sort-colors.c │ ├── trapping-rain-water.c │ └── valid-palindrome.c ├── go.mod ├── go ├── alg │ ├── 3sum │ │ └── code.go │ ├── best_time_to_buy_and_sell_stock │ │ └── code.go │ ├── binary_search │ │ └── code.go │ ├── bit │ │ ├── hamming_distance │ │ │ ├── code.go │ │ │ └── code_test.go │ │ ├── integer_replacement │ │ │ └── code.go │ │ └── power_of_four │ │ │ ├── code.go │ │ │ └── code_test.go │ ├── climbing_stairs │ │ └── code.go │ ├── contains_duplicate_ii │ │ └── code.go │ ├── contains_duplicate_iii │ │ ├── code.go │ │ └── code_test.go │ ├── daily_temperatures │ │ └── code.go │ ├── edit_distance │ │ └── code.go │ ├── generate_parentheses │ │ └── code.go │ ├── kth_largest_element_in_an_array │ │ ├── code.go │ │ ├── code_test.go │ │ ├── kth_largest_element_in_an_array.exe │ │ └── main.go │ ├── largest_number │ │ ├── code.go │ │ ├── code_test.go │ │ └── next_permutation │ │ │ ├── code.go │ │ │ └── code_test.go │ ├── lfu_cache │ │ ├── code.go │ │ └── code_test.go │ ├── longest_increasing_subsequence │ │ └── code.go │ ├── longest_substring_least_k_repeating_characters │ │ └── code.go │ ├── longest_substring_without_repeating_characters │ │ ├── code.go │ │ ├── code1.go │ │ └── code1_test.go │ ├── lru_cache │ │ ├── code.go │ │ └── code_test.go │ ├── maximum_length_of_repeated_subarray │ │ ├── code.go │ │ └── code1.go │ ├── maximum_subarray │ │ ├── code.go │ │ └── code_test.go │ ├── merge_intervals │ │ └── code.go │ ├── minimum_size_subarray_sum │ │ ├── code.go │ │ └── code_test.go │ ├── next_greater_element_i │ │ └── code.go │ ├── palindrome_number │ │ └── code.go │ ├── permutation_in_string │ │ ├── code.go │ │ └── code_test.go │ ├── permutations │ │ ├── code.go │ │ └── code_test.go │ ├── permutations_ii │ │ ├── code.go │ │ └── code_test.go │ ├── regular_expression_matching │ │ ├── code.go │ │ └── code_test.go │ ├── remove_k_digits │ │ ├── code.go │ │ └── code_test.go │ ├── search_in_rotated_sorted_array │ │ ├── code.go │ │ └── code_test.go │ ├── shortest_unsorted_continuous_subarray │ │ └── code.go │ ├── sliding_window_maximum │ │ └── code.go │ ├── sort_an_array │ │ ├── code.go │ │ └── code_test.go │ ├── spiral_matrix │ │ └── code.go │ └── wildcard_matching │ │ ├── code.go │ │ └── code_test.go ├── array │ ├── 3sum-closest │ ├── 3sum-closest[1].go │ ├── array-partition-i.go │ ├── best-time-to-buy-and-sell-stock-ii.go │ ├── best-time-to-buy-and-sell-stock.go │ ├── contains-duplicate-ii.go │ ├── contains-duplicate-ii[1].go │ ├── contains-duplicate.go │ ├── majority-element.go │ ├── maximum-subarray.go │ ├── merge-sorted-array.go │ ├── missing-number.go │ ├── plus-one.go │ ├── remove-duplicates-from-sorted-array.go │ ├── remove-element.go │ ├── remove-element[1].go │ ├── rotate-array.go │ ├── rotate-array[1].go │ ├── rotate-array[2].go │ ├── search-insert-position.go │ ├── two-sum-ii-input-array-is-sorted.go │ ├── two-sum-ii-input-array-is-sorted[1].go │ ├── two-sum.go │ └── two-sum[1].go ├── dp │ ├── longest-palindromic-substring │ │ ├── code.go │ │ └── code_test.go │ └── unique_binary_search_trees │ │ ├── code.go │ │ └── code_test.go ├── kmp │ ├── code.go │ ├── code1.go │ └── code1_test.go ├── list │ ├── add_two_numbers │ │ ├── code.go │ │ └── code_test.go │ ├── add_two_numbers_ii │ │ ├── code.go │ │ └── code_test.go │ ├── all_oone_data_structure │ │ ├── code.go │ │ ├── code1.go │ │ └── code_test.go │ ├── copy_random │ │ └── code.go │ ├── detect_cycle │ │ ├── code.go │ │ └── code_test.go │ ├── get_kth_from_end │ │ └── code.go │ ├── linked_list_cycle │ │ └── code.go │ ├── merge │ │ └── code.go │ ├── odd_even_linked_list │ │ └── code.go │ ├── palindrome │ │ └── code.go │ ├── remove_duplicates_from_sorted_list_ii │ │ └── code.go │ ├── remove_nth_node_from_end_list │ │ └── code.go │ ├── reorder │ │ └── code.go │ ├── reorder_list │ │ ├── code.go │ │ └── code_test.go │ ├── reverse │ │ └── code.go │ ├── reverse_nodes_in_k_group │ │ ├── code.go │ │ └── code_test.go │ ├── rotate_list │ │ └── code.go │ ├── shan_chu_lian_biao │ │ └── code.go │ ├── sort │ │ └── code.go │ └── sort_list │ │ └── code.go ├── misc │ ├── joseph │ │ ├── code.go │ │ └── code_test.go │ ├── longest-palindromic-substring │ │ ├── code.go │ │ └── code_test.go │ ├── sliding-window-maximum │ │ ├── code.go │ │ └── code_test.go │ ├── sum-of-subarray-minimums │ │ ├── code.go │ │ └── code_test.go │ └── yuan-quan-zhong-zui-hou-sheng-xia-de-shu-zi-lcof │ │ ├── code.go │ │ └── code_test.go ├── sort │ ├── heap │ │ ├── code.go │ │ ├── code_test.go │ │ ├── heap.go │ │ └── heap_test.go │ ├── merge │ │ ├── code.go │ │ └── code_test.go │ └── quick │ │ ├── code.go │ │ └── code_test.go ├── stack │ ├── 132-pattern.go │ ├── 132-pattern_test.go │ ├── backspace-string-compare.go │ ├── backspace-string-compare_test.go │ ├── baseball-game.go │ ├── baseball-game_test.go │ ├── basic-calculator-ii │ │ ├── basic-calculator-ii.go │ │ └── basic-calculator-ii_test.go │ ├── basic-calculator.go │ ├── basic-calculator_test.go │ ├── binary-tree-postorder-traversal.go │ ├── binary-tree-postorder-traversal[2].go │ ├── binary-tree-postorder-traversal_test.go │ ├── check-if-word-is-valid-after-substitutions.go │ ├── check-if-word-is-valid-after-substitutions_test.go │ ├── exclusive-time-of-functions.go │ ├── exclusive-time-of-functions_test.go │ ├── find-the-most-competitive-subsequence.go │ ├── find-the-most-competitive-subsequence_test.go │ ├── implement-queue-using-stacks-lcci.go │ ├── implement-queue-using-stacks-lcci_test.go │ ├── longest-well-performing-interval.go │ ├── longest-well-performing-interval_test.go │ ├── minimum-remove-to-make-valid-parentheses.go │ ├── minimum-remove-to-make-valid-parentheses_test.go │ ├── next-greater-node-in-linked-list.go │ ├── next-greater-node-in-linked-list_test.go │ ├── reverse-substrings-between-each-pair-of-parentheses.go │ ├── reverse-substrings-between-each-pair-of-parentheses_test.go │ ├── score-of-parentheses.go │ ├── score-of-parentheses_test.go │ ├── stack.go │ ├── valid-parentheses.go │ ├── valid-parentheses_test.go │ ├── verify-preorder-serialization-of-a-binary-tree.go │ └── verify-preorder-serialization-of-a-binary-tree_test.go └── tree │ ├── balanced_binary_tree │ └── code.go │ ├── binary_tree_level_order_traversal │ ├── code.go │ ├── code1.go │ └── code_test.go │ ├── binary_tree_pruning │ └── code.go │ ├── binary_tree_right_side_view │ └── code.go │ ├── binary_tree_zigzag_level_order_traversal │ └── code.go │ ├── construct-binary-search-tree-from-preorder-traversal │ └── code.go │ ├── inorder │ └── code.go │ ├── invert_binary_tree │ └── code.go │ ├── lowest_common_ancestor │ └── code.go │ ├── postorder │ └── code.go │ ├── preorder │ └── code.go │ └── symmetric_tree │ └── code.go ├── misc ├── 3sum-closest.c ├── 3sum-closest[2].c ├── 3sum.c ├── 3sum.cpp ├── 4sum.cpp ├── README.md ├── add-and-search-word-data-structure-design.c ├── add-binary.c ├── add-two-numbers.cpp ├── anagrams.cpp ├── balanced-binary-tree.c ├── basic-calculator-ii.c ├── basic-calculator.c ├── best-time-to-buy-and-sell-stock-ii.c ├── best-time-to-buy-and-sell-stock-iii.c ├── best-time-to-buy-and-sell-stock-iv.c ├── best-time-to-buy-and-sell-stock.c ├── binary-search-tree-iterator.c ├── binary-tree-inorder-traversal.c ├── binary-tree-level-order-traversal-ii.cpp ├── binary-tree-level-order-traversal.cpp ├── binary-tree-maximum-path-sum.c ├── binary-tree-postorder-traversal.c ├── binary-tree-preorder-traversal.cpp ├── binary-tree-right-side-view.c ├── binary-tree-zigzag-level-order-traversal.cpp ├── bitwise-and-of-numbers-range.c ├── bitwise-and-of-numbers-range[2].c ├── candy.c ├── climbing-stairs.c ├── combination-sum-ii.cpp ├── combination-sum-ii[1].cpp ├── combination-sum-iii.c ├── combination-sum-iii.cpp ├── combination-sum.cpp ├── combination-sum[1].cpp ├── combinations.c ├── combinations.cpp ├── compare-version-numbers.c ├── construct-binary-tree-from-inorder-and-postorder-traversal.c ├── construct-binary-tree-from-preorder-and-inorder-traversal.c ├── container-with-most-water.c ├── contains-duplicate-ii.c ├── contains-duplicate-ii.cpp ├── contains-duplicate-iii.c ├── contains-duplicate.c ├── convert-sorted-array-to-binary-search-tree.c ├── convert-sorted-list-to-binary-search-tree.c ├── copy-list-with-random-pointer.c ├── copy-list-with-random-pointer.cpp ├── count-and-say.c ├── count-primes.c ├── count-primes.cpp ├── decode-ways.c ├── delete-node-in-a-linked-list.c ├── distinct-subsequences.c ├── distinct-subsequences[1].c ├── divide-two-integers.c ├── dungeon-game.c ├── edit-distance.c ├── evaluate-reverse-polish-notation.c ├── excel-sheet-column-number.c ├── excel-sheet-column-title.c ├── factorial-trailing-zeroes.c ├── find-minimum-in-rotated-sorted-array-ii.c ├── find-minimum-in-rotated-sorted-array.c ├── find-peak-element.c ├── find-peak-element[2].c ├── first-missing-positive.c ├── flatten-binary-tree-to-linked-list.c ├── flatten-nested-list-iterator.cpp ├── gas-station.c ├── generate-parentheses.cpp ├── gray-code.c ├── happy-number.c ├── happy-number[2].c ├── happy-number[3].c ├── house-robber-ii.c ├── house-robber.c ├── implement-queue-using-stacks.c ├── implement-stack-using-queues.c ├── implement-strstr.c ├── implement-trie-prefix-tree.c ├── insert-interval.cpp ├── insertion-sort-list.c ├── integer-to-roman.c ├── interleaving-string.c ├── intersection-of-two-linked-lists.c ├── invert-binary-tree.c ├── isomorphic-strings.c ├── jump-game-ii.c ├── jump-game.c ├── jump-game[2].c ├── kth-largest-element-in-an-array.c ├── kth-largest-element-in-an-array[1].c ├── kth-smallest-element-in-a-bst.c ├── largest-number.c ├── largest-number.cpp ├── largest-rectangle-in-histogram.c ├── length-of-last-word.c ├── letter-combinations-of-a-phone-number.c ├── linked-list-cycle-ii.c ├── linked-list-cycle-ii[2].c ├── linked-list-cycle.c ├── longest-common-prefix.c ├── longest-common-prefix.cpp ├── longest-consecutive-sequence.c ├── longest-consecutive-sequence.cpp ├── longest-palindromic-substring.c ├── longest-palindromic-substring[1].c ├── longest-substring-without-repeating-characters.c ├── longest-substring-without-repeating-characters[2].c ├── longest-valid-parentheses.c ├── lowest-common-ancestor-of-a-binary-search-tree.c ├── lowest-common-ancestor-of-a-binary-search-tree[1].c ├── lowest-common-ancestor-of-a-binary-search-tree[2].c ├── lowest-common-ancestor-of-a-binary-tree.c ├── majority-element-ii.c ├── majority-element-ii[1].c ├── majority-element.c ├── majority-element[2].c ├── maximal-square.c ├── maximum-depth-of-binary-tree.c ├── maximum-gap.c ├── maximum-product-subarray.c ├── maximum-product-subarray[1].c ├── maximum-subarray.c ├── median-of-two-sorted-arrays.c ├── merge-intervals.c ├── merge-k-sorted-lists.c ├── merge-sorted-array.c ├── merge-sorted-array[2].c ├── merge-two-sorted-lists.c ├── min-stack.c ├── min-stack.cpp ├── minimum-depth-of-binary-tree.c ├── minimum-path-sum.c ├── minimum-size-subarray-sum.c ├── minimum-window-substring.c ├── n-queens-ii.c ├── n-queens-ii[1].c ├── n-queens.cpp ├── next-permutation.c ├── number-of-1-bits.c ├── number-of-digit-one.c ├── number-of-islands.c ├── palindrome-linked-list.c ├── palindrome-number.c ├── palindrome-partitioning-ii.c ├── palindrome-partitioning.cpp ├── partition-list.c ├── pascals-triangle-ii.cpp ├── pascals-triangle.cpp ├── path-sum-ii.cpp ├── path-sum.c ├── permutation-sequence.c ├── permutation-sequence[1].c ├── permutations-ii.cpp ├── permutations.c ├── permutations.cpp ├── plus-one.cpp ├── populating-next-right-pointers-in-each-node-ii.c ├── populating-next-right-pointers-in-each-node.c ├── power-of-two.c ├── powx-n.c ├── powx-n[2].c ├── product-of-array-except-self.c ├── recover-binary-search-tree.c ├── rectangle-area.c ├── regular-expression-matching.c ├── remove-duplicates-from-sorted-array-ii.c ├── remove-duplicates-from-sorted-array.c ├── remove-duplicates-from-sorted-array[2].c ├── remove-duplicates-from-sorted-list-ii.c ├── remove-duplicates-from-sorted-list.c ├── remove-element.c ├── remove-element[2].c ├── remove-linked-list-elements.c ├── remove-nth-node-from-end-of-list.c ├── reorder-list.c ├── restore-ip-addresses.c ├── reverse-bits.c ├── reverse-integer.c ├── reverse-integer[2].c ├── reverse-linked-list-ii.c ├── reverse-linked-list.c ├── reverse-nodes-in-k-group.c ├── reverse-words-in-a-string.c ├── reverse-words-in-a-string.cpp ├── roman-to-integer.c ├── rotate-array.c ├── rotate-array[2].c ├── rotate-array[3].c ├── rotate-image.c ├── rotate-list.c ├── same-tree.c ├── search-a-2d-matrix.c ├── search-for-a-range.c ├── search-in-rotated-sorted-array-ii.c ├── search-in-rotated-sorted-array.c ├── search-insert-position.c ├── set-matrix-zeroes.c ├── simplify-path.c ├── single-number-ii.c ├── single-number-ii[2].c ├── single-number.c ├── sort-colors.c ├── sort-colors[2].c ├── sort-list.c ├── sort-list[2].c ├── spiral-matrix-ii.c ├── spiral-matrix.c ├── sqrtx.c ├── string-to-integer-atoi.c ├── subset.c ├── subsets-ii.cpp ├── subsets-ii[2].cpp ├── subsets-ii[3].cpp ├── subsets.cpp ├── substring-with-concatenation-of-all-words.cpp ├── sum-root-to-leaf-numbers.c ├── summary-ranges.c ├── swap-nodes-in-pairs.c ├── symmetric-tree.c ├── trapping-rain-water.c ├── triangle.c ├── triangle[1].c ├── two-sum.c ├── unique-binary-search-trees-ii.cpp ├── unique-binary-search-trees.c ├── unique-paths-ii.c ├── unique-paths.c ├── valid-number.c ├── valid-palindrome.c ├── valid-parentheses.c ├── valid-sudoku.c ├── validate-binary-search-tree.c ├── validate-binary-search-tree.cpp ├── validate-binary-search-tree[2].c ├── word-break-ii.cpp ├── word-break-ii[1].cpp ├── word-break.cpp ├── word-break[1].cpp ├── word-search.cpp └── zigzag-conversion.c └── python ├── greedy └── assign-cookies.py ├── hash-table ├── 4sum-ii.py ├── 4sum.py ├── anagrams.py ├── binary-tree-inorder-traversal.py ├── binary-tree-inorder-traversal[1].py ├── bulls-and-cows.py ├── contains-duplicate-ii.py ├── contains-duplicate.py ├── contains-duplicate[1].py ├── contiguous-array.py ├── copy-list-with-random-pointer.py ├── copy-list-with-random-pointer[1].py ├── count-primes.py ├── encode-and-decode-tinyurl.py ├── find-all-anagrams-in-a-string.py ├── find-all-anagrams-in-a-string[1].py ├── find-the-difference.py ├── happy-number.py ├── happy-number[1].py ├── insert-delete-getrandom-o1-duplicates-allowed.py ├── insert-delete-getrandom-o1.py ├── intersection-of-two-arrays-ii.py ├── intersection-of-two-arrays.py ├── island-perimeter.py ├── isomorphic-strings.py ├── isomorphic-strings[1].py ├── keyboard-row.py ├── keyboard-row[1].py ├── longest-palindrome.py ├── longest-substring-without-repeating-characters.py ├── maximal-rectangle.py ├── minimum-window-substring.py ├── most-frequent-subtree-sum.py ├── most-frequent-subtree-sum[1].py ├── number-of-boomerangs.py ├── palindrome-pairs.py ├── palindrome-pairs[1].py ├── repeated-dna-sequences.py ├── single-number.py ├── single-number[1].py ├── sort-characters-by-frequency.py ├── sort-characters-by-frequency[1].py ├── sudoku-solver.py ├── top-k-frequent-elements.py ├── top-k-frequent-elements[1].py ├── two-sum.py ├── valid-anagram.py ├── valid-sudoku.py ├── word-pattern.py └── word-pattern[1].py ├── stack ├── binary-tree-inorder-traversal.py ├── binary-tree-inorder-traversal[2].py ├── binary-tree-postorder-traversal.py ├── binary-tree-postorder-traversal[2].py ├── binary-tree-preorder-traversal.py ├── binary-tree-preorder-traversal[2].py ├── binary-tree-zigzag-level-order-traversal.py ├── evaluate-reverse-polish-notation.py ├── flatten-nested-list-iterator.py ├── implement-queue-using-stacks.py ├── implement-stack-using-queues.py ├── largest-rectangle-in-histogram.py ├── maximal-rectangle.py ├── min-stack.py ├── remove-duplicate-letters.py ├── remove-duplicate-letters[2].py ├── simplify-path.py ├── simplify-path[2].py ├── trapping-rain-water.py ├── valid-parentheses.py └── verify-preorder-serialization-of-a-binary-tree.py ├── string └── add-binary.py └── tree ├── balanced-binary-tree.py ├── binary-search-tree-iterator.py ├── binary-tree-inorder-traversal.py ├── binary-tree-level-order-traversal-ii.py ├── binary-tree-level-order-traversal-ii[1].py ├── binary-tree-level-order-traversal.py ├── binary-tree-maximum-path-sum.py ├── binary-tree-paths.py ├── binary-tree-postorder-traversal.py ├── binary-tree-postorder-traversal[1].py ├── binary-tree-preorder-traversal.py ├── binary-tree-preorder-traversal[1].py ├── binary-tree-right-side-view.py ├── binary-tree-right-side-view[1].py ├── binary-tree-zigzag-level-order-traversal.py ├── construct-binary-tree-from-inorder-and-postorder-traversal.py ├── construct-binary-tree-from-preorder-and-inorder-traversal.py ├── convert-sorted-array-to-binary-search-tree.py ├── count-complete-tree-nodes.py ├── flatten-binary-tree-to-linked-list.py ├── flatten-binary-tree-to-linked-list[2].py ├── house-robber-iii.py ├── invert-binary-tree.py ├── kth-smallest-element-in-a-bst.py ├── lowest-common-ancestor-of-a-binary-search-tree.py ├── lowest-common-ancestor-of-a-binary-search-tree[1].py ├── lowest-common-ancestor-of-a-binary-search-tree[2].py ├── maximum-depth-of-binary-tree.py ├── maximum-depth-of-binary-tree[1].py ├── minimum-depth-of-binary-tree.py ├── path-sum-ii.py ├── path-sum.py ├── populating-next-right-pointers-in-each-node-ii.py ├── populating-next-right-pointers-in-each-node-ii[1].py ├── populating-next-right-pointers-in-each-node.py ├── populating-next-right-pointers-in-each-node[1].py ├── recover-binary-search-tree.py ├── same-tree.py ├── serialize-and-deserialize-binary-tree.py ├── sum-root-to-leaf-numbers.py ├── symmetric-tree.py ├── unique-binary-search-trees-ii.py ├── unique-binary-search-trees.py ├── validate-binary-search-tree.py └── validate-binary-search-tree[1].py /.gitignore: -------------------------------------------------------------------------------- 1 | .idea/ 2 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # leetcode 2 | The solutions of [LeetCode Algorithms](https://leetcode.com/problemset/algorithms/) 3 | 4 | Those codes are implemented by C, C++, Python and Go. 5 | 6 | # Star History 7 | 8 | [![Star History Chart](https://api.star-history.com/svg?repos=lightmen/leetcode&type=Date)](https://star-history.com/#lightmen/leetcode&Date) 9 | -------------------------------------------------------------------------------- /c/array/best-time-to-buy-and-sell-stock-ii.c: -------------------------------------------------------------------------------- 1 | int maxProfit(int* prices, int pricesSize) { 2 | int ret = 0; 3 | int i; 4 | 5 | for(i = 1; i < pricesSize; ++i) 6 | if(prices[i] > prices[i-1]) 7 | ret += prices[i] - prices[i-1]; 8 | 9 | return ret; 10 | } 11 | -------------------------------------------------------------------------------- /c/array/best-time-to-buy-and-sell-stock[2].c: -------------------------------------------------------------------------------- 1 | int maxProfit(int* prices, int pricesSize) { 2 | int min = INT_MAX; 3 | int i; 4 | int ret = 0; 5 | 6 | for(i = 0; i < pricesSize; ++i){ 7 | min = prices[i] < min ? prices[i] : min; 8 | ret = prices[i] - min > ret ? prices[i] - min : ret; 9 | } 10 | 11 | return ret; 12 | } 13 | -------------------------------------------------------------------------------- /c/array/container-with-most-water.c: -------------------------------------------------------------------------------- 1 | int maxArea(int* height, int heightSize) { 2 | int ret = 0; 3 | int start,end; 4 | int mul; 5 | 6 | start = 0; 7 | end = heightSize-1; 8 | while(start < end){ 9 | if(height[start] < height[end]){ 10 | mul = height[start] * (end - start); 11 | ++start; 12 | }else{ 13 | mul = height[end] * (end - start); 14 | --end; 15 | } 16 | 17 | ret = mul > ret ? mul : ret; 18 | } 19 | 20 | return ret; 21 | } 22 | -------------------------------------------------------------------------------- /c/array/contains-duplicate-ii.c: -------------------------------------------------------------------------------- 1 | bool containsNearbyDuplicate(int* nums, int numsSize, int k) { 2 | int i,j; 3 | 4 | for(i = 0; i < numsSize; ++i){ 5 | for(j = i+1; j <= i+k && j < numsSize; ++j) 6 | if(nums[j] == nums[i]) 7 | return true; 8 | } 9 | 10 | return false; 11 | } 12 | -------------------------------------------------------------------------------- /c/array/contains-duplicate.c: -------------------------------------------------------------------------------- 1 | static int cmp(const void *a, const void *b) 2 | { 3 | return *(const int *)a - *(const int *)b; 4 | } 5 | 6 | bool containsDuplicate(int* nums, int numsSize) { 7 | qsort(nums,numsSize,sizeof(int),cmp); 8 | 9 | for(int i = 1; i < numsSize; ++i) 10 | if(nums[i] == nums[i-1]) 11 | return true; 12 | 13 | return false; 14 | } 15 | -------------------------------------------------------------------------------- /c/array/find-minimum-in-rotated-sorted-array-ii.c: -------------------------------------------------------------------------------- 1 | int findMin(int* nums, int numsSize) { 2 | int start,end,mid; 3 | start = 0; 4 | end = numsSize - 1; 5 | 6 | while(start < end){ 7 | mid = start + (end - start) / 2; 8 | if(nums[mid] > nums[end]) 9 | start = mid + 1; 10 | else if(nums[mid] < nums[end]) 11 | end = mid; 12 | else 13 | --end; 14 | } 15 | 16 | return nums[start]; 17 | } 18 | -------------------------------------------------------------------------------- /c/array/find-minimum-in-rotated-sorted-array.c: -------------------------------------------------------------------------------- 1 | int findMin(int* nums, int numsSize) { 2 | int start,end,mid; 3 | start = 0; 4 | end = numsSize - 1; 5 | while(start + 1 < end){ 6 | mid = start + (end - start) / 2; 7 | if(nums[mid] > nums[end]) 8 | start = mid; 9 | else 10 | end = mid; 11 | } 12 | 13 | return nums[start] < nums[end] ? nums[start] : nums[end]; 14 | } 15 | -------------------------------------------------------------------------------- /c/array/find-minimum-in-rotated-sorted-array[1].c: -------------------------------------------------------------------------------- 1 | int findMin(int* nums, int numsSize) { 2 | int start,end,mid; 3 | start = 0; 4 | end = numsSize - 1; 5 | 6 | while(start < end){ 7 | mid = start + (end - start) / 2; 8 | if(nums[mid] > nums[end]) 9 | start = mid + 1; 10 | else 11 | end = mid; 12 | } 13 | 14 | return nums[start]; 15 | } 16 | -------------------------------------------------------------------------------- /c/array/find-peak-element.c: -------------------------------------------------------------------------------- 1 | int findPeakElement(int* nums, int numsSize) { 2 | int i; 3 | for(i = 1; i < numsSize; ++i) 4 | if(nums[i-1] > nums[i]) 5 | return i-1; 6 | 7 | return numsSize - 1; 8 | } 9 | -------------------------------------------------------------------------------- /c/array/find-peak-element[1].c: -------------------------------------------------------------------------------- 1 | int findPeakElement(int* nums, int numsSize) { 2 | int start,end,mid; 3 | start = 0; 4 | end = numsSize - 1; 5 | 6 | while(start < end){ 7 | mid = start + (end - start) / 2; 8 | if(nums[mid] < nums[mid+1]) 9 | start = mid + 1; 10 | else 11 | end = mid; 12 | } 13 | 14 | return start; 15 | } 16 | -------------------------------------------------------------------------------- /c/array/first-missing-positive.c: -------------------------------------------------------------------------------- 1 | int firstMissingPositive(int* nums, int numsSize) { 2 | int i = 0; 3 | 4 | while(i < numsSize){ 5 | if(nums[i] <= 0 || nums[i] >= numsSize || nums[i] == i + 1 6 | || nums[i] == nums[nums[i] - 1]){ 7 | ++i; 8 | }else{ 9 | int tmp = nums[i]; 10 | nums[i] = nums[nums[i] - 1]; 11 | nums[tmp-1] = tmp; 12 | } 13 | } 14 | 15 | for(i = 0; i < numsSize; ++i) 16 | if(nums[i] != i + 1) 17 | break; 18 | 19 | return i + 1; 20 | } 21 | -------------------------------------------------------------------------------- /c/array/jump-game-ii.c: -------------------------------------------------------------------------------- 1 | int jump(int* nums, int numsSize) { 2 | int ret = 0; 3 | int i; 4 | int cur_pos,max_pos; 5 | 6 | cur_pos = 0; 7 | max_pos = 0; 8 | for(i = 0; i < numsSize; ++i){ 9 | if(cur_pos < i){ 10 | ret++; 11 | cur_pos = max_pos; 12 | } 13 | if(nums[i] + i > max_pos) 14 | max_pos = nums[i] + i; 15 | } 16 | 17 | return ret; 18 | } 19 | -------------------------------------------------------------------------------- /c/array/jump-game.c: -------------------------------------------------------------------------------- 1 | bool canJump(int* nums, int numsSize) { 2 | int i = 0; 3 | int max_jump = nums[0]; 4 | 5 | while(max_jump < numsSize-1){ 6 | int max = max_jump; 7 | for(; i <= max_jump; ++i) 8 | if(i + nums[i] > max) 9 | max = i + nums[i]; 10 | if(max_jump == max) 11 | return false; 12 | max_jump = max; 13 | } 14 | 15 | return true; 16 | } 17 | -------------------------------------------------------------------------------- /c/array/majority-element.c: -------------------------------------------------------------------------------- 1 | int majorityElement(int* nums, int numsSize) { 2 | int count; 3 | int ret; 4 | int i; 5 | 6 | count = 0; 7 | for(i = 0; i < numsSize; ++i){ 8 | if(count == 0) 9 | ret = nums[i]; 10 | if(ret == nums[i]) 11 | count++; 12 | else 13 | count--; 14 | } 15 | 16 | return ret; 17 | } 18 | -------------------------------------------------------------------------------- /c/array/maximum-subarray.c: -------------------------------------------------------------------------------- 1 | int maxSubArray(int* nums, int numsSize) { 2 | int i; 3 | int ret = nums[0]; 4 | int cur = 0; 5 | 6 | for(i = 0; i < numsSize; ++i){ 7 | cur += nums[i]; 8 | ret = cur > ret ? cur : ret; 9 | cur = cur > 0 ? cur : 0; 10 | } 11 | 12 | return ret; 13 | } 14 | -------------------------------------------------------------------------------- /c/array/merge-sorted-array.c: -------------------------------------------------------------------------------- 1 | void merge(int* nums1, int m, int* nums2, int n) { 2 | int end = m + n - 1; 3 | int i = m - 1; 4 | int j = n - 1; 5 | 6 | while(i >= 0 && j >= 0) 7 | nums1[end--] = nums1[i] > nums2[j] ? nums1[i--] : nums2[j--]; 8 | 9 | while(i >= 0) 10 | nums1[end--] = nums1[i--]; 11 | 12 | while(j >= 0) 13 | nums1[end--] = nums2[j--]; 14 | } 15 | -------------------------------------------------------------------------------- /c/array/minimum-size-subarray-sum.c: -------------------------------------------------------------------------------- 1 | int minSubArrayLen(int s, int* nums, int numsSize) { 2 | int i,j; 3 | int sum; 4 | int count; 5 | int ret = numsSize + 1; 6 | 7 | i = 0; 8 | j = 0; 9 | sum = 0; 10 | count = 0; 11 | while(1){ 12 | if(i < numsSize && sum >= s){ 13 | if(count < ret) 14 | ret = count; 15 | sum -= nums[i++]; 16 | count--; 17 | }else if(j < numsSize){ 18 | sum += nums[j++]; 19 | count++; 20 | }else{ 21 | break; 22 | } 23 | } 24 | 25 | return ret == numsSize + 1 ? 0 : ret; 26 | } 27 | -------------------------------------------------------------------------------- /c/array/minimum-size-subarray-sum[1].c: -------------------------------------------------------------------------------- 1 | int minSubArrayLen(int s, int* nums, int numsSize) { 2 | int i,j; 3 | int sum; 4 | int ret = numsSize + 1; 5 | 6 | sum = 0; 7 | j = 0; 8 | for(i = 0; i < numsSize; ++i){ 9 | while(j < numsSize && sum < s){ 10 | sum += nums[j++]; 11 | } 12 | 13 | if(sum >= s) 14 | ret = j - i < ret ? j - i : ret; 15 | sum -= nums[i]; 16 | } 17 | 18 | return ret == numsSize + 1 ? 0 : ret; 19 | } 20 | -------------------------------------------------------------------------------- /c/array/remove-duplicates-from-sorted-array-ii.c: -------------------------------------------------------------------------------- 1 | int removeDuplicates(int* nums, int numsSize) { 2 | int count,i; 3 | 4 | if(numsSize <= 2) 5 | return numsSize; 6 | 7 | count = 2; 8 | for(i = 2; i < numsSize; ++i){ 9 | if(nums[i] != nums[count-2]) 10 | nums[count++] = nums[i]; 11 | } 12 | 13 | return count; 14 | } 15 | -------------------------------------------------------------------------------- /c/array/remove-duplicates-from-sorted-array.c: -------------------------------------------------------------------------------- 1 | int removeDuplicates(int* nums, int numsSize) { 2 | int count,i; 3 | 4 | if(numsSize == 0) 5 | return 0; 6 | 7 | count = 1; 8 | for(i = 1; i < numsSize; ++i){ 9 | if(nums[i] != nums[count-1]) 10 | nums[count++] = nums[i]; 11 | } 12 | 13 | return count; 14 | } 15 | -------------------------------------------------------------------------------- /c/array/remove-element.c: -------------------------------------------------------------------------------- 1 | int removeElement(int* nums, int numsSize, int val) { 2 | int count,i; 3 | 4 | count = 0; 5 | for(i = 0; i < numsSize; ++i){ 6 | if(nums[i] != val) 7 | nums[count++] = nums[i]; 8 | } 9 | 10 | return count; 11 | } 12 | -------------------------------------------------------------------------------- /c/array/rotate-array.c: -------------------------------------------------------------------------------- 1 | void reverse(int *nums, int start, int end) 2 | { 3 | int tmp; 4 | while(start < end){ 5 | tmp = nums[start]; 6 | nums[start] = nums[end]; 7 | nums[end] = tmp; 8 | 9 | ++start; 10 | --end; 11 | } 12 | } 13 | 14 | void rotate(int* nums, int numsSize, int k) { 15 | k %= numsSize; 16 | reverse(nums,0,numsSize - k - 1); 17 | reverse(nums,numsSize - k,numsSize -1); 18 | reverse(nums,0,numsSize-1); 19 | } 20 | -------------------------------------------------------------------------------- /c/array/search-a-2d-matrix.c: -------------------------------------------------------------------------------- 1 | bool searchMatrix(int** matrix, int matrixRowSize, int matrixColSize, int target) { 2 | int start,end; 3 | int mid; 4 | int tmp; 5 | 6 | start = 0; 7 | end = matrixRowSize * matrixColSize - 1; 8 | 9 | while(start <= end){ 10 | mid = (start + end) / 2; 11 | tmp = matrix[mid / matrixColSize][mid % matrixColSize]; 12 | if(tmp == target) 13 | return true; 14 | else if(tmp > target) 15 | end = mid - 1; 16 | else 17 | start = mid + 1; 18 | } 19 | 20 | return false; 21 | } 22 | -------------------------------------------------------------------------------- /c/array/search-insert-position.c: -------------------------------------------------------------------------------- 1 | int searchInsert(int* nums, int numsSize, int target) { 2 | int start,end,mid; 3 | 4 | start = 0; 5 | end = numsSize - 1; 6 | while(start < end){ 7 | mid = (start + end) / 2; 8 | if(nums[mid] == target) 9 | return mid; 10 | else if(nums[mid] > target) 11 | end = mid - 1; 12 | else 13 | start = mid + 1; 14 | } 15 | 16 | return nums[start] < target ? start + 1 : start; 17 | } 18 | -------------------------------------------------------------------------------- /c/array/sort-colors.c: -------------------------------------------------------------------------------- 1 | void swap(int *a, int *b) 2 | { 3 | int tmp = *a; 4 | *a = *b; 5 | *b = tmp; 6 | } 7 | 8 | void sortColors(int* nums, int numsSize) { 9 | int i,left,right; 10 | 11 | i = 0; 12 | left = 0; 13 | right = numsSize - 1; 14 | while(i <= right){ 15 | if(nums[i] == 0){ 16 | swap(&nums[left],&nums[i]); 17 | left++; 18 | i++; 19 | }else if(nums[i] == 1){ 20 | i++; 21 | }else{ 22 | swap(&nums[right],&nums[i]); 23 | right--; 24 | } 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /c/array/sort-colors[1].c: -------------------------------------------------------------------------------- 1 | void sortColors(int* nums, int numsSize) { 2 | int i; 3 | int zero = -1; 4 | int one = -1; 5 | int two = -1; 6 | 7 | for(i = 0; i < numsSize; ++i){ 8 | if(nums[i] == 0){ 9 | nums[++two] = 2; 10 | nums[++one] = 1; 11 | nums[++zero] = 0; 12 | }else if(nums[i] == 1){ 13 | nums[++two] = 2; 14 | nums[++one] = 1; 15 | }else{ 16 | nums[++two] = 2; 17 | } 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /c/array/unique-paths.c: -------------------------------------------------------------------------------- 1 | int uniquePaths(int m, int n) { 2 | int **dp; 3 | int i,j; 4 | int ret; 5 | 6 | dp = (int **)malloc(sizeof(int *) * m); 7 | for(i = 0; i < m; ++i) 8 | dp[i] = (int *)malloc(sizeof(int) * n); 9 | for(i = 0; i < m; ++i) 10 | dp[i][0] = 1; 11 | for(j = 0; j < n; ++j) 12 | dp[0][j] = 1; 13 | for(i = 1; i < m; ++i) 14 | for(j = 1; j < n; ++j) 15 | dp[i][j] = dp[i-1][j] + dp[i][j-1]; 16 | 17 | ret = dp[m-1][n-1]; 18 | 19 | for(i = 0; i < m; ++i) 20 | free(dp[i]); 21 | free(dp); 22 | 23 | return ret; 24 | } 25 | -------------------------------------------------------------------------------- /c/backtracking/regular-expression-matching.c: -------------------------------------------------------------------------------- 1 | bool isMatch(char* s, char* p) { 2 | if(*p == 0) 3 | return *s == 0; 4 | 5 | if(p[1] != '*') 6 | return (*s == *p || (*p == '.' && *s != 0)) && 7 | isMatch(s+1,p+1); 8 | 9 | while(*s == *p || (*p == '.' && *s != 0)){ 10 | if(isMatch(s,p+2)) 11 | return true; 12 | s++; 13 | } 14 | 15 | return isMatch(s,p+2); 16 | } 17 | -------------------------------------------------------------------------------- /c/binary-search/divide-two-integers.c: -------------------------------------------------------------------------------- 1 | int divide(int dividend, int divisor) { 2 | long ldd = labs(dividend); 3 | long lds = labs(divisor); 4 | int ret = 0; 5 | int is_neg = 0; 6 | 7 | if(divisor == -1 && dividend == INT_MIN) 8 | return INT_MAX; 9 | 10 | if((dividend > 0 && divisor < 0) || 11 | (dividend < 0 && divisor > 0)) 12 | is_neg = 1; 13 | 14 | while(ldd >= lds){ 15 | int tmp = 0; 16 | while(ldd >= (lds << tmp)) 17 | tmp++; 18 | ldd -= (lds << (tmp - 1)); 19 | ret += (1 << (tmp - 1)); 20 | } 21 | 22 | return is_neg ? -ret : ret; 23 | } 24 | -------------------------------------------------------------------------------- /c/binary-search/find-minimum-in-rotated-sorted-array-ii.c: -------------------------------------------------------------------------------- 1 | int findMin(int* nums, int numsSize) { 2 | int start,end,mid; 3 | 4 | start = 0; 5 | end = numsSize - 1; 6 | 7 | while(start < end){ 8 | mid = (start + end) / 2; 9 | if(nums[mid] > nums[end]) 10 | start = mid + 1; 11 | else if(nums[mid] < nums[end]) 12 | end = mid; 13 | else 14 | --end; 15 | } 16 | 17 | return nums[start]; 18 | } 19 | -------------------------------------------------------------------------------- /c/binary-search/find-minimum-in-rotated-sorted-array.c: -------------------------------------------------------------------------------- 1 | int findMin(int* nums, int numsSize) { 2 | int start,end; 3 | start = 0; 4 | end = numsSize - 1; 5 | 6 | while(start < end){ 7 | int mid = (start + end) / 2; 8 | if(nums[mid] > nums[end]) 9 | start = mid + 1; 10 | else 11 | end = mid; 12 | } 13 | 14 | return nums[start]; 15 | } 16 | -------------------------------------------------------------------------------- /c/binary-search/find-peak-element.c: -------------------------------------------------------------------------------- 1 | int findPeakElement(int* nums, int numsSize) { 2 | int i; 3 | 4 | for(i = 1; i < numsSize; ++i) 5 | if(nums[i-1] > nums[i]) 6 | return i - 1; 7 | 8 | return numsSize - 1; 9 | } 10 | -------------------------------------------------------------------------------- /c/binary-search/find-peak-element[1].c: -------------------------------------------------------------------------------- 1 | int findPeakElement(int* nums, int numsSize) { 2 | int start,end; 3 | start = 0; 4 | end = numsSize - 1; 5 | 6 | while(start < end){ 7 | int mid = (start + end) / 2; 8 | if(nums[mid] < nums[mid+1]) 9 | start = mid + 1; 10 | else 11 | end = mid; 12 | } 13 | 14 | return start; 15 | } 16 | -------------------------------------------------------------------------------- /c/binary-search/first-bad-version.c: -------------------------------------------------------------------------------- 1 | // Forward declaration of isBadVersion API. 2 | bool isBadVersion(int version); 3 | 4 | int firstBadVersion(int n) { 5 | int start,end,mid; 6 | start = 1; 7 | end = n; 8 | 9 | while(start < end){ 10 | mid = start + (end - start) / 2; 11 | if(isBadVersion(mid)){ 12 | end = mid; 13 | }else{ 14 | start = mid + 1; 15 | } 16 | } 17 | 18 | return end; 19 | } 20 | -------------------------------------------------------------------------------- /c/binary-search/longest-increasing-subsequence.c: -------------------------------------------------------------------------------- 1 | int lengthOfLIS(int* nums, int numsSize) { 2 | int *dp; 3 | int i,j; 4 | int max = 0; 5 | 6 | dp = (int *)malloc(sizeof(int) * numsSize); 7 | for(i = 0; i < numsSize; ++i){ 8 | dp[i] = 1; 9 | for(j = 0; j < i; ++j) 10 | if(nums[j] < nums[i]) 11 | dp[i] = dp[j] + 1 > dp[i] ? dp[j] + 1 : dp[i]; 12 | } 13 | 14 | for(i = 0; i < numsSize; ++i) 15 | if(dp[i] > max) 16 | max = dp[i]; 17 | 18 | free(dp); 19 | return max; 20 | } 21 | -------------------------------------------------------------------------------- /c/binary-search/minimum-size-subarray-sum.c: -------------------------------------------------------------------------------- 1 | int minSubArrayLen(int s, int* nums, int numsSize) { 2 | int ret = INT_MAX; 3 | int sum,cur; 4 | int i; 5 | 6 | sum = 0; 7 | cur = 0; 8 | for(i = 0; i < numsSize; ++i){ 9 | cur++; 10 | sum += nums[i]; 11 | while(sum >= s){ 12 | ret = cur < ret ? cur : ret; 13 | sum -= nums[i - cur + 1]; 14 | cur--; 15 | } 16 | } 17 | 18 | return ret == INT_MAX ? 0 : ret; 19 | } 20 | -------------------------------------------------------------------------------- /c/binary-search/powx-n.c: -------------------------------------------------------------------------------- 1 | double myPow(double x, int n) { 2 | if(n == 0) 3 | return 1; 4 | if(n == 1) 5 | return x; 6 | 7 | int is_neg = 0; 8 | if(n < 0){ 9 | is_neg = 1; 10 | n = -n; 11 | } 12 | 13 | double half = myPow(x,n/2); 14 | double ret; 15 | 16 | if(n % 2) 17 | ret = x * half * half; 18 | else 19 | ret = half * half; 20 | 21 | return is_neg ? 1/ret : ret; 22 | } 23 | -------------------------------------------------------------------------------- /c/binary-search/search-a-2d-matrix-ii.c: -------------------------------------------------------------------------------- 1 | bool searchMatrix(int** matrix, int matrixRowSize, int matrixColSize, int target) { 2 | int row,col; 3 | 4 | row = matrixRowSize - 1; 5 | col = 0; 6 | while(row >= 0 && col < matrixColSize){ 7 | if(matrix[row][col] == target) 8 | return true; 9 | if(matrix[row][col] > target) 10 | row--; 11 | else 12 | col++; 13 | } 14 | 15 | return false; 16 | } 17 | -------------------------------------------------------------------------------- /c/binary-search/search-a-2d-matrix.c: -------------------------------------------------------------------------------- 1 | bool searchMatrix(int** matrix, int matrixRowSize, int matrixColSize, int target) { 2 | int start,end,mid; 3 | int tmp; 4 | 5 | start = 0; 6 | end = matrixRowSize * matrixColSize - 1; 7 | while(start <= end){ 8 | mid = (start + end) / 2; 9 | tmp= matrix[mid / matrixColSize][mid % matrixColSize]; 10 | if(tmp == target) 11 | return true; 12 | else if(tmp > target) 13 | end = mid - 1; 14 | else 15 | start = mid + 1; 16 | } 17 | 18 | return false; 19 | } 20 | -------------------------------------------------------------------------------- /c/binary-search/search-a-2d-matrix[2].c: -------------------------------------------------------------------------------- 1 | bool searchMatrix(int** matrix, int matrixRowSize, int matrixColSize, int target) { 2 | int row,col; 3 | 4 | row = matrixRowSize - 1; 5 | col = 0; 6 | 7 | while(row >= 0 && col < matrixColSize){ 8 | if(matrix[row][col] == target) 9 | return true; 10 | 11 | if(matrix[row][col] > target) 12 | --row; 13 | else 14 | ++col; 15 | } 16 | 17 | return false; 18 | } 19 | -------------------------------------------------------------------------------- /c/binary-search/search-insert-position.c: -------------------------------------------------------------------------------- 1 | int searchInsert(int* nums, int numsSize, int target) { 2 | int ret = -1; 3 | int start,end,mid; 4 | 5 | start = 0; 6 | end = numsSize - 1; 7 | 8 | while(start <= end){ 9 | mid = (start + end) / 2; 10 | if(nums[mid] == target){ 11 | ret = mid; 12 | break; 13 | }else if(nums[mid] > target){ 14 | end = mid - 1; 15 | }else{ 16 | start = mid + 1; 17 | } 18 | } 19 | 20 | if(ret == -1) 21 | ret = nums[mid] > target ? mid : mid + 1; 22 | 23 | return ret; 24 | } 25 | -------------------------------------------------------------------------------- /c/binary-search/sqrtx.c: -------------------------------------------------------------------------------- 1 | int mySqrt(int x) { 2 | long start,end,mid; 3 | 4 | start = 0; 5 | end = x; 6 | 7 | while(start <= end){ 8 | mid = (start + end) / 2; 9 | if(mid * mid <= x && (mid + 1) * (mid+1) > x) 10 | break; 11 | else if(mid * mid > x) 12 | end = mid - 1; 13 | else 14 | start = mid + 1; 15 | } 16 | 17 | return mid; 18 | } 19 | -------------------------------------------------------------------------------- /c/divide-and-conquer/majority-element.c: -------------------------------------------------------------------------------- 1 | int majorityElement(int* nums, int numsSize) { 2 | int count,value,i; 3 | 4 | count = 0; 5 | for(i = 0; i < numsSize; ++i){ 6 | if(count == 0){ 7 | ++count; 8 | value = nums[i]; 9 | }else if(value == nums[i]){ 10 | ++count; 11 | }else{ 12 | --count; 13 | } 14 | } 15 | 16 | return value; 17 | } 18 | -------------------------------------------------------------------------------- /c/divide-and-conquer/maximum-subarray.c: -------------------------------------------------------------------------------- 1 | int maxSubArray(int* nums, int numsSize) { 2 | int i, ret, sum; 3 | 4 | sum = 0; 5 | ret = INT_MIN; 6 | for(i = 0; i < numsSize; ++i){ 7 | sum += nums[i]; 8 | ret = sum > ret ? sum : ret; 9 | sum = sum > 0 ? sum : 0; 10 | } 11 | 12 | return ret; 13 | } 14 | -------------------------------------------------------------------------------- /c/divide-and-conquer/search-a-2d-matrix-ii.c: -------------------------------------------------------------------------------- 1 | bool searchMatrix(int** matrix, int matrixRowSize, int matrixColSize, int target) { 2 | int row,col; 3 | 4 | row = matrixRowSize - 1; 5 | col = 0; 6 | 7 | while(row >= 0 && col < matrixColSize){ 8 | if(matrix[row][col] == target) 9 | return true; 10 | if(matrix[row][col] > target) 11 | --row; 12 | else 13 | ++col; 14 | } 15 | 16 | return false; 17 | } 18 | -------------------------------------------------------------------------------- /c/dynamic-programming/best-time-to-buy-and-sell-stock[2].c: -------------------------------------------------------------------------------- 1 | int maxProfit(int* prices, int pricesSize) { 2 | int i; 3 | int ret,min; 4 | 5 | min = INT_MAX; 6 | ret = 0; 7 | for(i = 0; i < pricesSize; ++i){ 8 | min = prices[i] < min ? prices[i] : min; 9 | ret = (prices[i] - min) > ret ? (prices[i] - min) : ret; 10 | } 11 | 12 | return ret; 13 | } 14 | -------------------------------------------------------------------------------- /c/dynamic-programming/climbing-stairs.c: -------------------------------------------------------------------------------- 1 | int climbStairs(int n) { 2 | int *dp; 3 | int i,ret; 4 | 5 | dp = (int *)malloc(sizeof(int) * (n + 1)); 6 | dp[0] = 1; 7 | dp[1] = 1; 8 | for(i = 2; i <= n; ++i) 9 | dp[i] = dp[i-1] + dp[i-2]; 10 | 11 | ret = dp[n]; 12 | free(dp); 13 | return ret; 14 | } 15 | -------------------------------------------------------------------------------- /c/dynamic-programming/climbing-stairs[2].c: -------------------------------------------------------------------------------- 1 | int climbStairs(int n) { 2 | int d1,d2; 3 | int i,ret; 4 | 5 | d1 = 0; 6 | d2 = 1; 7 | ret = 1; 8 | for(i = 1; i <= n; ++i){ 9 | ret = d1 + d2; 10 | d1 = d2; 11 | d2 = ret; 12 | } 13 | 14 | return ret; 15 | } 16 | -------------------------------------------------------------------------------- /c/dynamic-programming/counting-bits.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Return an array of size *returnSize. 3 | * Note: The returned array must be malloced, assume caller calls free(). 4 | */ 5 | int* countBits(int num, int* returnSize) { 6 | int *dp; 7 | int cnt; 8 | int i; 9 | int tmp; 10 | 11 | dp = (int *)malloc(sizeof(int) * (num + 1)); 12 | for(i = 0; i <= num; ++i){ 13 | cnt = 0; 14 | tmp = i; 15 | while(tmp){ 16 | cnt += (tmp & 0x1); 17 | tmp >>= 1; 18 | } 19 | 20 | dp[i] = cnt; 21 | } 22 | 23 | *returnSize = num + 1; 24 | return dp; 25 | } 26 | -------------------------------------------------------------------------------- /c/dynamic-programming/counting-bits[2].c: -------------------------------------------------------------------------------- 1 | /** 2 | * Return an array of size *returnSize. 3 | * Note: The returned array must be malloced, assume caller calls free(). 4 | */ 5 | int* countBits(int num, int* returnSize) { 6 | int *dp; 7 | int i; 8 | 9 | dp = (int *)malloc(sizeof(int) * (num + 1)); 10 | dp[0] = 0; 11 | for(i = 1; i <= num; ++i) 12 | dp[i] = dp[i >> 1] + (i & 0x1); 13 | 14 | *returnSize = num + 1; 15 | return dp; 16 | } 17 | -------------------------------------------------------------------------------- /c/dynamic-programming/decode-ways.c: -------------------------------------------------------------------------------- 1 | int numDecodings(char* s) { 2 | int *dp; 3 | int i,len,value; 4 | 5 | len = strlen(s); 6 | if(len == 0) 7 | return 0; 8 | 9 | dp = (int *)malloc(sizeof(int) * (len + 1)); 10 | dp[0] = 1; 11 | dp[1] = s[0] != '0' ? 1 : 0; 12 | for(i = 2; i <= len; ++i){ 13 | dp[i] = s[i-1] != '0' ? dp[i-1] : 0; 14 | 15 | value = (s[i-2] - '0') * 10 + (s[i-1] - '0'); 16 | if(value >= 10 && value <= 26) 17 | dp[i] += dp[i-2]; 18 | } 19 | 20 | value = dp[len]; 21 | free(dp); 22 | return value; 23 | } 24 | -------------------------------------------------------------------------------- /c/dynamic-programming/house-robber.c: -------------------------------------------------------------------------------- 1 | int rob(int* nums, int numsSize) { 2 | int *dp; 3 | int i,value; 4 | 5 | dp = (int *)malloc(sizeof(int) * (numsSize + 1)); 6 | dp[0] = 0; 7 | dp[1] = nums[0]; 8 | for(i = 2; i <= numsSize; ++i) 9 | dp[i] = dp[i-2] + nums[i-1] > dp[i-1] ? dp[i-2] + nums[i-1] : dp[i-1]; 10 | 11 | value = dp[numsSize]; 12 | free(dp); 13 | return value; 14 | } 15 | -------------------------------------------------------------------------------- /c/dynamic-programming/house-robber[2].c: -------------------------------------------------------------------------------- 1 | int rob(int* nums, int numsSize) { 2 | int value,pre_value,tmp; 3 | int i; 4 | 5 | pre_value = 0; 6 | value = 0; 7 | 8 | for(i = 0; i < numsSize; ++i){ 9 | tmp = value; 10 | value = pre_value + nums[i] > value ? pre_value + nums[i] : value; 11 | pre_value = tmp; 12 | } 13 | 14 | return value; 15 | } 16 | -------------------------------------------------------------------------------- /c/dynamic-programming/longest-valid-parentheses[2].c: -------------------------------------------------------------------------------- 1 | int longestValidParentheses(char* s) { 2 | int *dp; 3 | int i,len,j,max_count; 4 | 5 | len = strlen(s); 6 | dp = (int *)malloc(sizeof(int) * (len + 1)); 7 | dp[0] = 0; 8 | max_count = 0; 9 | 10 | for(i = 1; i <= len; ++i){ 11 | j = i - dp[i-1] - 2; 12 | if(s[i-1] == '(' || j < 0 || s[j] != '('){ 13 | dp[i] = 0; 14 | }else{ 15 | dp[i] = dp[j] + dp[i-1] + 2; 16 | max_count = dp[i] > max_count ? dp[i] : max_count; 17 | } 18 | } 19 | 20 | free(dp); 21 | return max_count; 22 | } 23 | -------------------------------------------------------------------------------- /c/dynamic-programming/maximum-subarray.c: -------------------------------------------------------------------------------- 1 | #define max_2(x, y) ({ \ 2 | int _x = (x); \ 3 | int _y = (y); \ 4 | _x > _y ? _x : _y; \ 5 | }) 6 | 7 | int maxSubArray(int* nums, int numsSize) { 8 | int max_sum, cur_sum; 9 | int i; 10 | 11 | max_sum = nums[0]; 12 | cur_sum = 0; 13 | for(i = 0; i < numsSize; ++i){ 14 | cur_sum += nums[i]; 15 | max_sum = max_2(cur_sum, max_sum); 16 | cur_sum = max_2(0, cur_sum); 17 | } 18 | 19 | return max_sum; 20 | } 21 | -------------------------------------------------------------------------------- /c/dynamic-programming/maximum-subarray[2].c: -------------------------------------------------------------------------------- 1 | #define max_2(x, y) ({ \ 2 | int _x = (x); \ 3 | int _y = (y); \ 4 | _x > _y ? _x : _y; \ 5 | }) 6 | 7 | int maxSubArray(int* nums, int numsSize) { 8 | int *sum; 9 | int i,ret; 10 | 11 | sum = (int *)malloc(sizeof(int) * numsSize); 12 | sum[0] = nums[0]; 13 | for(i = 1; i < numsSize; ++i) 14 | sum[i] = max_2(nums[i], nums[i] + sum[i-1]); 15 | 16 | ret = INT_MIN; 17 | for(i = 0; i < numsSize; ++i) 18 | ret = max_2(sum[i], ret); 19 | 20 | free(sum); 21 | return ret; 22 | } 23 | -------------------------------------------------------------------------------- /c/dynamic-programming/maximum-subarray[3].c: -------------------------------------------------------------------------------- 1 | #define max_2(x, y) ({ \ 2 | int _x = (x); \ 3 | int _y = (y); \ 4 | _x > _y ? _x : _y; \ 5 | }) 6 | 7 | //DP 8 | int maxSubArray(int* nums, int numsSize) { 9 | int cur_sum,pre_sum; 10 | int max_value; 11 | int i; 12 | 13 | cur_sum = nums[0]; 14 | max_value = nums[0]; 15 | for(i = 1; i < numsSize; ++i){ 16 | pre_sum = cur_sum; 17 | cur_sum = max_2(nums[i], nums[i] + pre_sum); 18 | max_value = max_2(cur_sum, max_value); 19 | } 20 | 21 | return max_value; 22 | } 23 | -------------------------------------------------------------------------------- /c/dynamic-programming/perfect-squares.c: -------------------------------------------------------------------------------- 1 | #define min_2(x, y) ({ \ 2 | int _x = (x); \ 3 | int _y = (y); \ 4 | _x < _y ? _x : _y; \ 5 | }) 6 | 7 | 8 | int numSquares(int n) { 9 | int ret; 10 | int i,j; 11 | int *dp; 12 | 13 | dp = (int *)malloc(sizeof(int) * (n + 1)); 14 | dp[0] = 0; 15 | dp[1] = 1; 16 | 17 | for(i = 2; i <= n; ++i){ 18 | dp[i] = i; 19 | for(j = 1; j*j <= i; ++j) 20 | dp[i] = min_2(1 + dp[i-j*j], dp[i]); 21 | } 22 | 23 | ret = dp[n]; 24 | free(dp); 25 | return ret; 26 | } 27 | -------------------------------------------------------------------------------- /c/dynamic-programming/regular-expression-matching[2].c: -------------------------------------------------------------------------------- 1 | bool isMatch(char* s, char* p) { 2 | if(*p == 0) 3 | return *s == 0; 4 | if(p[1] != '*') 5 | return (*s == *p || (*p == '.' && *s != 0)) && 6 | isMatch(s+1,p+1); 7 | 8 | while((*s == *p) || (*p == '.' && *s != 0)){ 9 | if(isMatch(s,p+2)) 10 | return true; 11 | s++; 12 | } 13 | 14 | return isMatch(s,p+2); 15 | } 16 | -------------------------------------------------------------------------------- /c/dynamic-programming/unique-binary-search-trees.c: -------------------------------------------------------------------------------- 1 | int numTrees(int n) { 2 | int *dp; 3 | int i,j; 4 | int ret; 5 | 6 | dp = (int *)malloc(sizeof(int) * (n + 1)); 7 | dp[0] = 1; 8 | 9 | for(i = 1; i <= n; ++i){ 10 | dp[i] = 0; 11 | for(j = 1; j <= i; ++j) 12 | dp[i] += (dp[j-1] * dp[i-j]); 13 | } 14 | 15 | ret = dp[n]; 16 | free(dp); 17 | return ret; 18 | } 19 | -------------------------------------------------------------------------------- /c/dynamic-programming/unique-paths.c: -------------------------------------------------------------------------------- 1 | int uniquePaths(int m, int n) { 2 | int **dp; 3 | int i,j; 4 | int ret; 5 | 6 | dp = (int **)malloc(sizeof(int *) * m); 7 | for(i = 0; i < m; ++i) 8 | dp[i] = (int *)malloc(sizeof(int) * n); 9 | 10 | for(i = 0; i < m; ++i) 11 | dp[i][0] = 1; 12 | for(j = 0; j < n; ++j) 13 | dp[0][j] = 1; 14 | 15 | for(i = 1; i < m; ++i){ 16 | for(j = 1; j < n; ++j) 17 | dp[i][j] = dp[i][j-1] + dp[i-1][j]; 18 | } 19 | 20 | ret = dp[m-1][n-1]; 21 | for(i = 0; i < m; ++i) 22 | free(dp[i]); 23 | free(dp); 24 | 25 | return ret; 26 | } 27 | -------------------------------------------------------------------------------- /c/dynamic-programming/unique-paths[2].c: -------------------------------------------------------------------------------- 1 | int uniquePaths(int m, int n) { 2 | int *dp; 3 | int i,j; 4 | int ret; 5 | 6 | dp = malloc(sizeof(int) * n); 7 | for(i = 0; i < n; ++i) 8 | dp[i] = 1; 9 | 10 | for(i = 1; i < m; ++i) 11 | for(j = 1; j < n; ++j) 12 | dp[j] += dp[j-1]; 13 | 14 | ret = dp[n-1]; 15 | free(dp); 16 | return ret; 17 | } 18 | -------------------------------------------------------------------------------- /c/greedy/assign-cookies.c: -------------------------------------------------------------------------------- 1 | int cmp(const void *a, const void *b) 2 | { 3 | return *(int *)a - *(int *)b; 4 | } 5 | 6 | int findContentChildren(int* g, int gSize, int* s, int sSize) { 7 | int i = gSize - 1; 8 | int j = sSize - 1; 9 | int ret = 0; 10 | 11 | qsort(g, gSize, sizeof(int), cmp); 12 | qsort(s, sSize, sizeof(int), cmp); 13 | 14 | while(i >= 0 && j >= 0){ 15 | if(s[j] >= g[i]){ 16 | j--; 17 | ret++; 18 | } 19 | i--; 20 | } 21 | 22 | return ret; 23 | } 24 | -------------------------------------------------------------------------------- /c/hash-table/contains-duplicate-ii.c: -------------------------------------------------------------------------------- 1 | bool containsNearbyDuplicate(int* nums, int numsSize, int k) { 2 | int i,j; 3 | for(i = 0; i < numsSize; ++i){ 4 | for(j = i + 1; j <= i + k && j < numsSize; ++j) 5 | if(nums[i] == nums[j]) 6 | return true; 7 | } 8 | 9 | return false; 10 | } 11 | -------------------------------------------------------------------------------- /c/hash-table/contains-duplicate.c: -------------------------------------------------------------------------------- 1 | int cmp(const void *a, const void *b) 2 | { 3 | return *(const int *)a - *(const int *)b; 4 | } 5 | 6 | bool containsDuplicate(int* nums, int numsSize) { 7 | qsort(nums, numsSize, sizeof(int),cmp); 8 | 9 | for(int i = 0; i < numsSize -1; ++i) 10 | if(nums[i] == nums[i+1]) 11 | return true; 12 | 13 | return false; 14 | } 15 | -------------------------------------------------------------------------------- /c/hash-table/count-primes.c: -------------------------------------------------------------------------------- 1 | int countPrimes(int n) { 2 | int *arr; 3 | int count = 0; 4 | int i,j; 5 | 6 | arr = malloc(sizeof(int) * n); 7 | memset(arr, 0, sizeof(int) * n); 8 | for(i = 2; i < n; ++i){ 9 | if(arr[i]) 10 | continue; 11 | ++count; 12 | for(j = i * 2; j < n; j += i) 13 | arr[j] = 1; 14 | } 15 | 16 | free(arr); 17 | return count; 18 | } 19 | -------------------------------------------------------------------------------- /c/hash-table/find-the-difference.c: -------------------------------------------------------------------------------- 1 | char findTheDifference(char* s, char* t) { 2 | int hash[256] = {0}; 3 | int len = strlen(s); 4 | int i; 5 | 6 | for(i = 0; i < len; ++i) 7 | hash[s[i]]++; 8 | 9 | for(i = 0; i <= len; ++i) 10 | if(hash[t[i]] == 0) 11 | break; 12 | else 13 | --hash[t[i]]; 14 | 15 | return t[i]; 16 | } 17 | -------------------------------------------------------------------------------- /c/hash-table/happy-number.c: -------------------------------------------------------------------------------- 1 | bool happy(int n, int *count) 2 | { 3 | if(n == 1) 4 | return true; 5 | if(*count == 100 || n == 0) 6 | return false; 7 | 8 | int tmp = 0; 9 | int d; 10 | while(n > 0){ 11 | d = n % 10; 12 | n /= 10; 13 | tmp += d * d; 14 | } 15 | 16 | *count++; 17 | return happy(tmp,count); 18 | } 19 | 20 | bool isHappy(int n) { 21 | int count = 0; 22 | return happy(n,&count); 23 | } 24 | -------------------------------------------------------------------------------- /c/hash-table/happy-number[1].c: -------------------------------------------------------------------------------- 1 | bool isHappy(int n) { 2 | int *flag; 3 | int tmp; 4 | const int N = 100; 5 | 6 | flag = malloc(sizeof(int) * N); 7 | memset(flag, 0, sizeof(int) * N); 8 | 9 | while(1){ 10 | if(n == 1) 11 | break; 12 | if(n < 100 && flag[n]) 13 | break; 14 | 15 | if(n < 100) 16 | flag[n] = 1; 17 | 18 | tmp = 0; 19 | while(n > 0){ 20 | tmp += (n % 10) * (n % 10); 21 | n /= 10; 22 | } 23 | n = tmp; 24 | } 25 | 26 | free(flag); 27 | return n == 1; 28 | } 29 | -------------------------------------------------------------------------------- /c/hash-table/isomorphic-strings.c: -------------------------------------------------------------------------------- 1 | bool isIsomorphic(char* s, char* t) { 2 | int flag[256] = {0}; 3 | int visited[256] = {0}; 4 | int len = strlen(s); 5 | 6 | for(int i = 0; i < len; ++i){ 7 | if(flag[s[i]] == 0){ 8 | if(visited[t[i]]) 9 | return false; 10 | 11 | flag[s[i]] = t[i]; 12 | visited[t[i]] = 1; 13 | }else if(flag[s[i]] != t[i]){ 14 | return false; 15 | } 16 | } 17 | 18 | return true; 19 | } 20 | -------------------------------------------------------------------------------- /c/hash-table/isomorphic-strings[1].c: -------------------------------------------------------------------------------- 1 | bool isIsomorphic(char* s, char* t) { 2 | int ms[256] = {0}; 3 | int mt[256] = {0}; 4 | 5 | int len = strlen(s); 6 | 7 | for(int i = 0; i < len; ++i){ 8 | if(ms[s[i]] != mt[t[i]]) 9 | return false; 10 | 11 | ms[s[i]] = i + 1; 12 | mt[t[i]] = i + 1; 13 | } 14 | 15 | return true; 16 | } 17 | -------------------------------------------------------------------------------- /c/hash-table/longest-palindrome.c: -------------------------------------------------------------------------------- 1 | int longestPalindrome(char* s) { 2 | int map[256] = {0}; 3 | int i,len,ret = 0; 4 | int plus = 0; 5 | 6 | len = strlen(s); 7 | for(i = 0; i < len; ++i) 8 | map[s[i]]++; 9 | 10 | for(i = 0; i < 256; ++i){ 11 | ret += map[i]; 12 | if(map[i] % 2 == 1){ 13 | plus = 1; 14 | ret--; 15 | } 16 | } 17 | 18 | return ret + plus; 19 | } 20 | -------------------------------------------------------------------------------- /c/hash-table/longest-substring-without-repeating-characters.c: -------------------------------------------------------------------------------- 1 | int lengthOfLongestSubstring(char* s) { 2 | int index[256] = {0}; 3 | int last_index = -1; 4 | int len = strlen(s); 5 | int ret = 0; 6 | 7 | for(int i = 0; i < len; ++i){ 8 | last_index = index[s[i]] > last_index ? index[s[i]] : last_index; 9 | index[s[i]] = i + 1; 10 | ret = (i - last_index + 1) > ret ? (i - last_index + 1) : ret; 11 | } 12 | 13 | return ret; 14 | } 15 | -------------------------------------------------------------------------------- /c/hash-table/single-number.c: -------------------------------------------------------------------------------- 1 | int singleNumber(int* nums, int numsSize) { 2 | int ret = 0; 3 | 4 | for(int i = 0; i < numsSize; ++i) 5 | ret ^= nums[i]; 6 | 7 | return ret; 8 | } 9 | -------------------------------------------------------------------------------- /c/hash-table/two-sum.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Note: The returned array must be malloced, assume caller calls free(). 3 | */ 4 | int* twoSum(int* nums, int numsSize, int target) { 5 | int *ret = malloc(sizeof(int) * 2); 6 | 7 | for(int i = 0; i < numsSize; ++i) 8 | for(int j = i + 1; j < numsSize; ++j) 9 | if(nums[i] + nums[j] == target){ 10 | ret[0] = i; 11 | ret[1] = j; 12 | return ret; 13 | } 14 | 15 | return ret; 16 | } 17 | -------------------------------------------------------------------------------- /c/hash-table/valid-anagram.c: -------------------------------------------------------------------------------- 1 | bool isAnagram(char* s, char* t) { 2 | int hash[26] = {0}; 3 | int s_len = strlen(s); 4 | int t_len = strlen(t); 5 | int i; 6 | if(s_len != t_len) 7 | return false; 8 | 9 | for(i = 0; i < s_len; ++i){ 10 | hash[s[i] - 'a']++; 11 | hash[t[i] - 'a']--; 12 | } 13 | 14 | for(i = 0; i < 26; ++i) 15 | if(hash[i]) 16 | return false; 17 | 18 | return true; 19 | } 20 | -------------------------------------------------------------------------------- /c/linked-list/delete-node-in-a-linked-list.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * struct ListNode *next; 6 | * }; 7 | */ 8 | void deleteNode(struct ListNode* node) { 9 | node->val = node->next->val; 10 | node->next = node->next->next; 11 | } 12 | -------------------------------------------------------------------------------- /c/linked-list/linked-list-cycle-ii.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * struct ListNode *next; 6 | * }; 7 | */ 8 | struct ListNode *detectCycle(struct ListNode *head) { 9 | struct ListNode *slow = head; 10 | struct ListNode *fast = head; 11 | 12 | do { 13 | if(!slow || !fast || !fast->next) 14 | return NULL; 15 | 16 | slow = slow->next; 17 | fast = fast->next->next; 18 | }while(slow != fast); 19 | 20 | while(head != slow){ 21 | head = head->next; 22 | slow = slow->next; 23 | } 24 | 25 | return head; 26 | } 27 | -------------------------------------------------------------------------------- /c/linked-list/linked-list-cycle.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * struct ListNode *next; 6 | * }; 7 | */ 8 | bool hasCycle(struct ListNode *head) { 9 | struct ListNode *one; 10 | struct ListNode *two; 11 | 12 | one = head; 13 | two = head; 14 | 15 | while(one && two){ 16 | one = one->next; 17 | two = two->next; 18 | 19 | if(two) 20 | two = two->next; 21 | if(one && one == two) 22 | return true; 23 | } 24 | 25 | return false; 26 | } 27 | -------------------------------------------------------------------------------- /c/linked-list/palindrome-linked-list[2].c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * struct ListNode *next; 6 | * }; 7 | */ 8 | struct ListNode *glist; 9 | bool helper(struct ListNode *head) 10 | { 11 | if(head == NULL) 12 | return true; 13 | if(!helper(head->next)) 14 | return false; 15 | if(head->val != glist->val) 16 | return false; 17 | 18 | glist = glist->next; 19 | return true; 20 | } 21 | 22 | bool isPalindrome(struct ListNode* head) { 23 | glist = head; 24 | return helper(head); 25 | } 26 | -------------------------------------------------------------------------------- /c/linked-list/remove-duplicates-from-sorted-list.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * struct ListNode *next; 6 | * }; 7 | */ 8 | struct ListNode* deleteDuplicates(struct ListNode* head) { 9 | struct ListNode *ret; 10 | struct ListNode *prev; 11 | ret = head; 12 | 13 | while(head && head->next){ 14 | prev = head; 15 | head = head->next; 16 | if(prev->val == head->val){ 17 | prev->next = head->next; 18 | head = prev; 19 | } 20 | } 21 | 22 | return ret; 23 | } 24 | -------------------------------------------------------------------------------- /c/linked-list/remove-linked-list-elements.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * struct ListNode *next; 6 | * }; 7 | */ 8 | struct ListNode* removeElements(struct ListNode* head, int val) { 9 | struct ListNode root; 10 | struct ListNode *cur; 11 | 12 | root.next = head; 13 | cur = &root; 14 | while(cur->next){ 15 | if(cur->next->val == val) 16 | cur->next = cur->next->next; 17 | else 18 | cur = cur->next; 19 | } 20 | 21 | return root.next; 22 | } 23 | -------------------------------------------------------------------------------- /c/linked-list/remove-nth-node-from-end-of-list.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * struct ListNode *next; 6 | * }; 7 | */ 8 | struct ListNode* removeNthFromEnd(struct ListNode* head, int n) { 9 | struct ListNode *prev; 10 | struct ListNode root; 11 | int i; 12 | 13 | root.next = head; 14 | prev = &root; 15 | 16 | for(i = 0; i < n; ++i) 17 | head = head->next; 18 | 19 | while(head){ 20 | head = head->next; 21 | prev = prev->next; 22 | } 23 | 24 | prev->next = prev->next->next; 25 | 26 | return root.next; 27 | } 28 | -------------------------------------------------------------------------------- /c/linked-list/reverse-linked-list.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * struct ListNode *next; 6 | * }; 7 | */ 8 | struct ListNode* reverseList(struct ListNode* head) { 9 | struct ListNode root; 10 | struct ListNode *tmp; 11 | root.next = NULL; 12 | 13 | while(head){ 14 | tmp = head->next; 15 | head->next = root.next; 16 | root.next = head; 17 | head = tmp; 18 | } 19 | 20 | return root.next; 21 | } 22 | -------------------------------------------------------------------------------- /c/linked-list/swap-nodes-in-pairs.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * struct ListNode *next; 6 | * }; 7 | */ 8 | struct ListNode* swapPairs(struct ListNode* head) { 9 | struct ListNode root; 10 | struct ListNode *cur; 11 | 12 | root.next = head; 13 | cur = &root; 14 | while(head && head->next){ 15 | struct ListNode *tmp = head->next->next; 16 | 17 | cur->next = head->next; 18 | head->next->next = head; 19 | head->next = tmp; 20 | 21 | cur = head; 22 | head = head->next; 23 | } 24 | 25 | return root.next; 26 | } 27 | -------------------------------------------------------------------------------- /c/math/add-digits.c: -------------------------------------------------------------------------------- 1 | int addDigits(int num) { 2 | int ret = num; 3 | while(num > 9){ 4 | ret = 0; 5 | while(num){ 6 | ret += (num % 10); 7 | num /= 10; 8 | } 9 | num = ret; 10 | } 11 | 12 | return ret; 13 | } 14 | -------------------------------------------------------------------------------- /c/math/add-digits[1].c: -------------------------------------------------------------------------------- 1 | int addDigits(int num) { 2 | return 1 + (num - 1) % 9; 3 | } 4 | -------------------------------------------------------------------------------- /c/math/count-primes.c: -------------------------------------------------------------------------------- 1 | int countPrimes(int n) { 2 | int ret = 0; 3 | int i,j; 4 | int *prime; 5 | prime = (int *)malloc(sizeof(int) * n); 6 | memset(prime,0,sizeof(int) * n); 7 | 8 | for(i = 2; i < n; ++i){ 9 | if(prime[i]) 10 | continue; 11 | ret++; 12 | for(j = 2*i; j < n; j += i) 13 | prime[j] = 1; 14 | } 15 | 16 | free(prime); 17 | return ret; 18 | } 19 | -------------------------------------------------------------------------------- /c/math/divide-two-integers.c: -------------------------------------------------------------------------------- 1 | iint divide(int dividend, int divisor) { 2 | if(dividend == INT_MIN && divisor == -1) 3 | return INT_MAX; 4 | 5 | long a = labs(dividend); 6 | long b = labs(divisor); 7 | bool is_neg = ((dividend > 0 && divisor < 0) 8 | || (dividend < 0 && divisor > 0)); 9 | int ret = 0; 10 | while(a >= b){ 11 | int tmp = 0; 12 | while(a >= (b << tmp)) 13 | tmp++; 14 | a -= (b << (tmp - 1)); 15 | ret += (1 << (tmp - 1)); 16 | } 17 | 18 | return is_neg ? -ret : ret; 19 | } 20 | -------------------------------------------------------------------------------- /c/math/excel-sheet-column-number.c: -------------------------------------------------------------------------------- 1 | int titleToNumber(char* s) { 2 | int ret = 0; 3 | while(*s){ 4 | ret = ret * 26 + (*s - 'A' + 1); 5 | s++; 6 | } 7 | return ret; 8 | } 9 | -------------------------------------------------------------------------------- /c/math/excel-sheet-column-title.c: -------------------------------------------------------------------------------- 1 | char* convertToTitle(int n) { 2 | char *ret; 3 | int i; 4 | 5 | ret = (char *)malloc(sizeof(char) * 26); 6 | memset(ret,0,sizeof(char) * 26); 7 | i = 24; 8 | while(n){ 9 | ret[i--] = (n-1) % 26 + 'A'; 10 | n = (n-1) / 26; 11 | } 12 | 13 | return ret + i + 1; 14 | } 15 | -------------------------------------------------------------------------------- /c/math/factorial-trailing-zeroes.c: -------------------------------------------------------------------------------- 1 | int trailingZeroes(int n) { 2 | int ret = 0; 3 | while(n){ 4 | ret += n/5; 5 | n /= 5; 6 | } 7 | 8 | return ret; 9 | } 10 | -------------------------------------------------------------------------------- /c/math/happy-number.c: -------------------------------------------------------------------------------- 1 | bool isHappy(int n) { 2 | int flag[100]; 3 | int result; 4 | 5 | memset(flag,0,sizeof(int) * 100); 6 | 7 | while(n){ 8 | if(n == 1) 9 | return true; 10 | if(n < 100 && !flag[n]) 11 | flag[n] = 1; 12 | else if(n < 100 && flag[n]) 13 | break; 14 | result = 0; 15 | while(n){ 16 | result += (n % 10) * (n % 10); 17 | n /= 10; 18 | } 19 | 20 | n = result; 21 | } 22 | 23 | return false; 24 | } 25 | -------------------------------------------------------------------------------- /c/math/missing-number.c: -------------------------------------------------------------------------------- 1 | int missingNumber(int* nums, int numsSize) { 2 | int *arr; 3 | int i; 4 | int ret; 5 | 6 | arr = (int *)malloc(sizeof(int) * (numsSize + 1)); 7 | memset(arr,0,sizeof(int) * (numsSize+1)); 8 | 9 | for(i = 0; i < numsSize; ++i) 10 | arr[nums[i]] = 1; 11 | 12 | for(i = 0; i <= numsSize; ++i) 13 | if(arr[i] == 0){ 14 | ret = i; 15 | break; 16 | } 17 | 18 | free(arr); 19 | return ret; 20 | } 21 | -------------------------------------------------------------------------------- /c/math/missing-number[1].c: -------------------------------------------------------------------------------- 1 | int missingNumber(int* nums, int numsSize) { 2 | int i; 3 | int sum; 4 | 5 | sum = numsSize * (1 + numsSize) / 2; 6 | for(i = 0; i < numsSize; ++i) 7 | sum -= nums[i]; 8 | 9 | return sum; 10 | } 11 | -------------------------------------------------------------------------------- /c/math/number-of-digit-one.c: -------------------------------------------------------------------------------- 1 | int countDigitOne(int n) { 2 | int ret = 0; 3 | long m; 4 | 5 | for(m = 1; m <= n; m *= 10){ 6 | long a = n / m; 7 | long b = n % m; 8 | ret += (a + 8) / 10 * m; 9 | if(a % 10 == 1) 10 | ret += (b + 1); 11 | } 12 | 13 | return ret; 14 | } 15 | -------------------------------------------------------------------------------- /c/math/palindrome-number.c: -------------------------------------------------------------------------------- 1 | bool isPalindrome(int x) { 2 | if(x < 0) 3 | return false; 4 | 5 | int rx = 0; 6 | int tmp = x; 7 | while(tmp){ 8 | rx = 10 * rx + (tmp % 10); 9 | tmp /= 10; 10 | } 11 | 12 | return rx == x; 13 | } 14 | -------------------------------------------------------------------------------- /c/math/perfect-squares[1].c: -------------------------------------------------------------------------------- 1 | int numSquares(int n) { 2 | int *arr; 3 | int i,j; 4 | int min,ret; 5 | 6 | arr = (int *)malloc(sizeof(int) * (n + 1)); 7 | arr[0] = 0; 8 | arr[1] = 1; 9 | 10 | for(i = 2; i <= n; ++i){ 11 | min = i; 12 | j = 1; 13 | while(j * j <= i){ 14 | min = arr[i - j * j] + 1 < min ? arr[i - j * j] + 1 : min; 15 | j++; 16 | } 17 | arr[i] = min; 18 | } 19 | 20 | ret = arr[n]; 21 | free(arr); 22 | return ret; 23 | } 24 | -------------------------------------------------------------------------------- /c/math/power-of-two.c: -------------------------------------------------------------------------------- 1 | bool isPowerOfTwo(int n) { 2 | int ret = 0; 3 | while(n > 0){ 4 | ret += n & 0x1; 5 | n >>= 1; 6 | } 7 | 8 | return ret == 1; 9 | } 10 | -------------------------------------------------------------------------------- /c/math/power-of-two[1].c: -------------------------------------------------------------------------------- 1 | bool isPowerOfTwo(int n) { 2 | return n > 0 && ((n & (n - 1)) == 0); 3 | } 4 | -------------------------------------------------------------------------------- /c/math/powx-n.c: -------------------------------------------------------------------------------- 1 | double myPow(double x, int n) { 2 | if(n == 0) 3 | return 1; 4 | if(n == 1) 5 | return x; 6 | 7 | int is_neg = 0; 8 | if(n < 0){ 9 | n = -n; 10 | is_neg = 1; 11 | } 12 | 13 | double df = myPow(x,n/2); 14 | df *= df; 15 | if(n % 2 == 1) 16 | df *= x; 17 | 18 | return is_neg ? 1 / df : df; 19 | } 20 | -------------------------------------------------------------------------------- /c/math/reverse-integer.c: -------------------------------------------------------------------------------- 1 | int reverse(int x) { 2 | int rx = 0; 3 | int ret = 0; 4 | while(x){ 5 | ret = rx * 10 + x % 10; 6 | if(ret / 10 != rx){ 7 | ret = 0; 8 | break; 9 | } 10 | rx = ret; 11 | x /= 10; 12 | } 13 | 14 | return ret; 15 | } 16 | -------------------------------------------------------------------------------- /c/math/sqrtx.c: -------------------------------------------------------------------------------- 1 | int mySqrt(int x) { 2 | long start,end,mid; 3 | start = 0; 4 | end = x; 5 | mid = 0; 6 | 7 | while(start <= end){ 8 | mid = (start + end) / 2; 9 | if(mid * mid == x || (mid * mid < x && (mid + 1) * (mid + 1) > x)) 10 | break; 11 | if(mid * mid < x) 12 | start = mid+1; 13 | else 14 | end = mid-1; 15 | } 16 | 17 | return mid; 18 | } 19 | -------------------------------------------------------------------------------- /c/math/string-to-integer-atoi.c: -------------------------------------------------------------------------------- 1 | int myAtoi(char* str) { 2 | int ret = 0; 3 | int tmp = 0; 4 | int is_neg = 1; 5 | 6 | while(*str && *str == ' ') 7 | str++; 8 | 9 | if(*str == '-') 10 | is_neg = -1; 11 | 12 | if(*str == '+' || *str == '-') 13 | str++; 14 | 15 | while(*str >= '0' && *str <= '9'){ 16 | tmp = ret * 10 + (*str - '0'); 17 | str++; 18 | if(tmp / 10 != ret) 19 | return is_neg == -1 ? INT_MIN : INT_MAX; 20 | ret = tmp; 21 | } 22 | 23 | return is_neg * ret; 24 | } 25 | -------------------------------------------------------------------------------- /c/math/ugly-number.c: -------------------------------------------------------------------------------- 1 | bool isUgly(int num) { 2 | if(num == 0) 3 | return false; 4 | 5 | while(num % 5 == 0) 6 | num /= 5; 7 | 8 | while(num % 3 == 0) 9 | num /= 3; 10 | 11 | while(num % 2 == 0) 12 | num /= 2; 13 | 14 | return num == 1; 15 | } 16 | -------------------------------------------------------------------------------- /c/stack/valid-parentheses[2].c: -------------------------------------------------------------------------------- 1 | bool isValid(char* s) { 2 | char *st; 3 | int len; 4 | int top = -1; 5 | 6 | len = strlen(s); 7 | st = malloc(len); 8 | 9 | while(*s){ 10 | if(*s == '(' || *s == '{' || *s == '['){ 11 | st[++top] = *s; 12 | }else if( *s == ')' && st[top] == '('){ 13 | --top; 14 | }else if(*s == '}' && st[top] == '{'){ 15 | --top; 16 | }else if(*s == ']' && st[top] == '['){ 17 | --top; 18 | }else{ 19 | return false; 20 | } 21 | 22 | s++; 23 | } 24 | 25 | return top == -1; 26 | } 27 | -------------------------------------------------------------------------------- /c/string/decode-ways[1].c: -------------------------------------------------------------------------------- 1 | int numDecodings(char* s) { 2 | int *dp; 3 | int len,i; 4 | int ret,value; 5 | 6 | len = strlen(s); 7 | if(len == 0) 8 | return 0; 9 | 10 | dp = (int *)malloc(sizeof(int) * (len + 1)); 11 | dp[0] = 1; 12 | dp[1] = s[0] == '0' ? 0 : 1; 13 | 14 | for(i = 2; i <= len; ++i){ 15 | dp[i] = 0; 16 | if(s[i-1] != '0') 17 | dp[i] = dp[i-1]; 18 | 19 | value = (s[i-2] - '0') * 10 + s[i-1] - '0'; 20 | if(value >= 10 && value <= 26) 21 | dp[i] += dp[i-2]; 22 | } 23 | 24 | ret = dp[len]; 25 | free(dp); 26 | 27 | return ret; 28 | } 29 | -------------------------------------------------------------------------------- /c/string/implement-strstr.c: -------------------------------------------------------------------------------- 1 | int strStr(char* haystack, char* needle) { 2 | int jump[256]; 3 | int i,j; 4 | int ht_len,nd_len; 5 | 6 | ht_len = strlen(haystack); 7 | nd_len = strlen(needle); 8 | 9 | for(i = 0; i < ht_len; ++i) 10 | jump[haystack[i]] = nd_len + 1; 11 | for(i = 0; i < nd_len; ++i) 12 | jump[needle[i]] = nd_len - i; 13 | 14 | for(i = 0; i <= ht_len - nd_len; i += jump[haystack[i+nd_len]]){ 15 | j = 0; 16 | while(j < nd_len && haystack[i+j] == needle[j]) 17 | j++; 18 | if(j == nd_len) 19 | return i; 20 | } 21 | 22 | return -1; 23 | } 24 | -------------------------------------------------------------------------------- /c/string/length-of-last-word.c: -------------------------------------------------------------------------------- 1 | int lengthOfLastWord(char* s) { 2 | int start; 3 | int end,last; 4 | 5 | start = -1; 6 | end = 0; 7 | last = strlen(s); 8 | 9 | while(last > 0 && s[last-1] == ' ') 10 | --last; 11 | 12 | while(end < last){ 13 | if(s[end] == ' ') 14 | start = end; 15 | end++; 16 | } 17 | 18 | return end - start - 1; 19 | } 20 | -------------------------------------------------------------------------------- /c/string/length-of-last-word[1].c: -------------------------------------------------------------------------------- 1 | int lengthOfLastWord(char* s) { 2 | int len = strlen(s); 3 | int pos; 4 | 5 | while(len > 0 && s[len-1] == ' ') 6 | --len; 7 | 8 | pos = len - 1; 9 | while(pos >= 0 && s[pos] != ' ') 10 | --pos; 11 | 12 | return len - pos - 1; 13 | } 14 | -------------------------------------------------------------------------------- /c/string/longest-common-prefix.c: -------------------------------------------------------------------------------- 1 | char* longestCommonPrefix(char** strs, int strsSize) { 2 | int n = 0; 3 | int i,loop_flag; 4 | 5 | if(strsSize == 0) 6 | return ""; 7 | loop_flag = 1; 8 | while(loop_flag){ 9 | char value = strs[0][n]; 10 | for(i = 0; i < strsSize; ++i){ 11 | if(strs[i][n] == 0 || strs[i][n] != value){ 12 | loop_flag = 0; 13 | break; 14 | } 15 | } 16 | if(loop_flag) 17 | n++; 18 | } 19 | 20 | return strndup(strs[0],n); 21 | } 22 | -------------------------------------------------------------------------------- /c/string/longest-common-prefix[1].c: -------------------------------------------------------------------------------- 1 | char* longestCommonPrefix(char** strs, int strsSize) { 2 | int i,j; 3 | int len; 4 | 5 | if(strsSize == 0) 6 | return ""; 7 | 8 | len = strlen(strs[0]); 9 | for(i = 0; i < len; ++i){ 10 | for(j = 1; j < strsSize; ++j) 11 | if(strs[j][i] != strs[0][i]) 12 | return strndup(strs[0],i); 13 | } 14 | 15 | return strndup(strs[0],i); 16 | } 17 | -------------------------------------------------------------------------------- /c/string/longest-substring-without-repeating-characters.c: -------------------------------------------------------------------------------- 1 | int lengthOfLongestSubstring(char* s) { 2 | int index[256]; 3 | int last_index; 4 | int len,i,ret; 5 | 6 | memset(index,0,sizeof(int) * 256); 7 | last_index = -1; 8 | len = strlen(s); 9 | 10 | ret = 0; 11 | for(i = 0; i < len; ++i){ 12 | last_index = index[s[i]] > last_index ? index[s[i]] : last_index; 13 | index[s[i]] = i + 1; 14 | ret = (i - last_index + 1 > ret) ? i - last_index + 1 : ret; 15 | } 16 | 17 | return ret; 18 | } 19 | -------------------------------------------------------------------------------- /c/string/string-to-integer-atoi.c: -------------------------------------------------------------------------------- 1 | int myAtoi(char* str) { 2 | int is_neg; 3 | int ret; 4 | 5 | is_neg = 1; 6 | while(*str == ' ') 7 | str++; 8 | 9 | if(*str == '+'){ 10 | str++; 11 | }else if (*str == '-'){ 12 | is_neg = -1; 13 | str++; 14 | } 15 | 16 | ret = 0; 17 | while(*str && (*str >= '0' && *str <= '9')){ 18 | int tmp = ret; 19 | ret = (ret * 10) + *str - '0'; 20 | if(ret / 10 != tmp) 21 | return is_neg == -1 ? INT_MIN : INT_MAX; 22 | str++; 23 | } 24 | 25 | return is_neg * ret; 26 | } 27 | -------------------------------------------------------------------------------- /c/tree/flatten-binary-tree-to-linked-list.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * struct TreeNode *left; 6 | * struct TreeNode *right; 7 | * }; 8 | */ 9 | 10 | void flatten(struct TreeNode* root) { 11 | if(root == NULL) 12 | return ; 13 | 14 | struct TreeNode *left = root->left; 15 | struct TreeNode *right = root->right; 16 | 17 | root->left = NULL; 18 | root->right = left; 19 | 20 | flatten(left); 21 | flatten(right); 22 | 23 | while(root->right) 24 | root = root->right; 25 | 26 | root->right = right; 27 | } 28 | -------------------------------------------------------------------------------- /c/tree/house-robber-iii.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * struct TreeNode *left; 6 | * struct TreeNode *right; 7 | * }; 8 | */ 9 | int rob(struct TreeNode* root) { 10 | if(root == NULL) 11 | return 0; 12 | 13 | int m1 = rob(root->left) + rob(root->right); 14 | int m2 = root->val; 15 | if(root->left) 16 | m2 += rob(root->left->left) + rob(root->left->right); 17 | if(root->right) 18 | m2 += rob(root->right->left) + rob(root->right->right); 19 | 20 | return m2 > m1 ? m2 : m1; 21 | } 22 | -------------------------------------------------------------------------------- /c/tree/invert-binary-tree.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * struct TreeNode *left; 6 | * struct TreeNode *right; 7 | * }; 8 | */ 9 | struct TreeNode* invertTree(struct TreeNode* root) { 10 | if(!root) 11 | return NULL; 12 | 13 | struct TreeNode *node = invertTree(root->left); 14 | root->left = invertTree(root->right); 15 | root->right = node; 16 | 17 | return root; 18 | } 19 | -------------------------------------------------------------------------------- /c/tree/maximum-depth-of-binary-tree[1].c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * struct TreeNode *left; 6 | * struct TreeNode *right; 7 | * }; 8 | */ 9 | int maxDepth(struct TreeNode* root) { 10 | if(root == NULL) 11 | return 0; 12 | 13 | int left = maxDepth(root->left); 14 | int right = maxDepth(root->right); 15 | 16 | return (left > right ? left : right) + 1; 17 | } 18 | -------------------------------------------------------------------------------- /c/tree/minimum-depth-of-binary-tree.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * struct TreeNode *left; 6 | * struct TreeNode *right; 7 | * }; 8 | */ 9 | int minDepth(struct TreeNode* root) { 10 | if(root == NULL) 11 | return 0; 12 | 13 | if(root->left == NULL && root->right == NULL) 14 | return 1; 15 | 16 | int left = minDepth(root->left); 17 | int right = minDepth(root->right); 18 | 19 | if(left == 0) 20 | left = INT_MAX; 21 | if(right == 0) 22 | right = INT_MAX; 23 | 24 | return left < right ? left + 1 : right + 1; 25 | } 26 | -------------------------------------------------------------------------------- /c/tree/path-sum.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * struct TreeNode *left; 6 | * struct TreeNode *right; 7 | * }; 8 | */ 9 | bool hasPathSum(struct TreeNode* root, int sum) { 10 | if(root == NULL) 11 | return false; 12 | 13 | if(root->left == NULL && root->right == NULL) 14 | return root->val == sum; 15 | 16 | bool bleft = hasPathSum(root->left,sum - root->val); 17 | if(bleft) 18 | return true; 19 | 20 | bool bright = hasPathSum(root->right, sum - root->val); 21 | 22 | return bright; 23 | } 24 | -------------------------------------------------------------------------------- /c/tree/same-tree.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * struct TreeNode *left; 6 | * struct TreeNode *right; 7 | * }; 8 | */ 9 | bool isSameTree(struct TreeNode* p, struct TreeNode* q) { 10 | if(p && q){ 11 | if(p->val != q->val) 12 | return false; 13 | return isSameTree(p->left, q->left) && isSameTree(p->right, q->right); 14 | } 15 | 16 | return p == NULL && q == NULL; 17 | } 18 | -------------------------------------------------------------------------------- /c/tree/sum-root-to-leaf-numbers.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * struct TreeNode *left; 6 | * struct TreeNode *right; 7 | * }; 8 | */ 9 | 10 | int sum(struct TreeNode *root, int cur_val) 11 | { 12 | if(root == NULL) 13 | return 0; 14 | 15 | int val = cur_val * 10 + root->val; 16 | if(root->left == NULL && root->right == NULL) 17 | return val; 18 | 19 | return sum(root->left, val) + sum(root->right, val); 20 | } 21 | 22 | int sumNumbers(struct TreeNode* root) { 23 | return sum(root,0); 24 | } 25 | -------------------------------------------------------------------------------- /c/tree/unique-binary-search-trees.c: -------------------------------------------------------------------------------- 1 | int numTrees(int n) { 2 | int *num; 3 | int ret; 4 | 5 | num = malloc(sizeof(int) * (n + 1)); 6 | memset(num, 0, sizeof(int) * (n + 1)); 7 | num[1] = 1; 8 | num[0] = 1; 9 | for(int i = 2;i <= n; ++i){ 10 | for(int j = 0; j < i; ++j) 11 | num[i] +=(num[j] * num[i - j - 1]); 12 | } 13 | 14 | ret = num[n]; 15 | free(num); 16 | return ret; 17 | } 18 | -------------------------------------------------------------------------------- /c/two-pointers/container-with-most-water.c: -------------------------------------------------------------------------------- 1 | #define min(a,b) ((a) < (b) ? (a) : (b)) 2 | 3 | int maxArea(int* height, int heightSize) { 4 | int start,end; 5 | int ret = 0; 6 | int mul; 7 | 8 | start = 0; 9 | end = heightSize - 1; 10 | while(start < end){ 11 | mul = min(height[start],height[end]) * (end - start); 12 | if(mul > ret) 13 | ret = mul; 14 | if(height[start] > height[end]) 15 | --end; 16 | else 17 | ++start; 18 | } 19 | 20 | return ret; 21 | } 22 | -------------------------------------------------------------------------------- /c/two-pointers/implement-strstr.c: -------------------------------------------------------------------------------- 1 | int strStr(char* haystack, char* needle) { 2 | int step[256]; 3 | int i,j; 4 | int nd_len = strlen(needle); 5 | int ht_len = strlen(haystack); 6 | 7 | for(i = 0; i < ht_len; ++i) 8 | step[haystack[i]] = nd_len + 1; 9 | 10 | for(i = 0; i < nd_len; ++i) 11 | step[needle[i]] = nd_len - i; 12 | 13 | for(i = 0; i <= ht_len - nd_len; i += step[haystack[i+nd_len]]){ 14 | j = 0; 15 | while(j < nd_len && haystack[j+i] == needle[j]) 16 | ++j; 17 | if(j == nd_len) 18 | return i; 19 | } 20 | 21 | return -1; 22 | } 23 | -------------------------------------------------------------------------------- /c/two-pointers/linked-list-cycle-ii.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * struct ListNode *next; 6 | * }; 7 | */ 8 | struct ListNode *detectCycle(struct ListNode *head) { 9 | struct ListNode *l1,*l2; 10 | 11 | l1 = head; 12 | l2 = head; 13 | do{ 14 | if(!l1 || !l2 || !l2->next) 15 | return NULL; 16 | l2 = l2->next->next; 17 | l1 = l1->next; 18 | }while(l1 != l2); 19 | 20 | l1 = head; 21 | while(l1 && l2 && l1 != l2){ 22 | l1 = l1->next; 23 | l2 = l2->next; 24 | } 25 | 26 | return l1; 27 | } 28 | -------------------------------------------------------------------------------- /c/two-pointers/linked-list-cycle.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * struct ListNode *next; 6 | * }; 7 | */ 8 | bool hasCycle(struct ListNode *head) { 9 | struct ListNode *slow = head; 10 | struct ListNode *fast = head; 11 | 12 | while(fast && fast->next){ 13 | fast = fast->next->next; 14 | slow = slow->next; 15 | if(fast == slow) 16 | return true; 17 | } 18 | 19 | return false; 20 | } 21 | -------------------------------------------------------------------------------- /c/two-pointers/longest-substring-without-repeating-characters[1].c: -------------------------------------------------------------------------------- 1 | int lengthOfLongestSubstring(char* s) { 2 | int index[256]; 3 | int last_pos = -1; 4 | int i; 5 | int ret = 0; 6 | int len; 7 | 8 | memset(index,0,sizeof(int) * 256); 9 | len = strlen(s); 10 | for(i = 0; i < len; ++i){ 11 | last_pos = index[s[i]] > last_pos ? index[s[i]] : last_pos; 12 | index[s[i]] = i+1; 13 | ret = (i - last_pos + 1) > ret ? (i - last_pos + 1) : ret; 14 | } 15 | 16 | return ret; 17 | } 18 | -------------------------------------------------------------------------------- /c/two-pointers/merge-sorted-array.c: -------------------------------------------------------------------------------- 1 | void merge(int* nums1, int m, int* nums2, int n) { 2 | int end = m + n - 1; 3 | int i,j; 4 | 5 | i = m - 1; 6 | j = n - 1; 7 | while(i >= 0 && j >= 0){ 8 | if(nums1[i] > nums2[j]) 9 | nums1[end--] = nums1[i--]; 10 | else 11 | nums1[end--] = nums2[j--]; 12 | } 13 | 14 | while(j >= 0) 15 | nums1[end--] = nums2[j--]; 16 | } 17 | -------------------------------------------------------------------------------- /c/two-pointers/minimum-size-subarray-sum.c: -------------------------------------------------------------------------------- 1 | int minSubArrayLen(int s, int* nums, int numsSize) { 2 | int ret = numsSize + 1; 3 | int start = 0; 4 | int end = 0; 5 | int sum = 0; 6 | 7 | while(end < numsSize){ 8 | sum += nums[end++]; 9 | while(sum >= s){ 10 | ret = (end - start) < ret ? (end - start) : ret; 11 | sum -= nums[start++]; 12 | } 13 | } 14 | 15 | return ret == numsSize + 1 ? 0 : ret; 16 | } 17 | -------------------------------------------------------------------------------- /c/two-pointers/remove-duplicates-from-sorted-array-ii.c: -------------------------------------------------------------------------------- 1 | int removeDuplicates(int* nums, int numsSize) { 2 | int i,count; 3 | 4 | count = 1; 5 | for(i = 2; i < numsSize; ++i) 6 | if(nums[i] != nums[count-1]) 7 | nums[++count] = nums[i]; 8 | 9 | return numsSize < 2 ? numsSize : count+1; 10 | } 11 | -------------------------------------------------------------------------------- /c/two-pointers/remove-duplicates-from-sorted-array.c: -------------------------------------------------------------------------------- 1 | int removeDuplicates(int* nums, int numsSize) { 2 | int i,count = 0; 3 | 4 | if(numsSize == 0) 5 | return 0; 6 | 7 | for(i = 0; i < numsSize; ++i) 8 | if(nums[i] != nums[count]) 9 | nums[++count] = nums[i]; 10 | 11 | return count+1; 12 | } 13 | -------------------------------------------------------------------------------- /c/two-pointers/remove-element.c: -------------------------------------------------------------------------------- 1 | int removeElement(int* nums, int numsSize, int val) { 2 | int count = -1; 3 | int i; 4 | 5 | for(i = 0; i < numsSize; ++i) 6 | if(nums[i] != val) 7 | nums[++count] = nums[i]; 8 | 9 | return count+1; 10 | } 11 | -------------------------------------------------------------------------------- /c/two-pointers/remove-nth-node-from-end-of-list.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * struct ListNode *next; 6 | * }; 7 | */ 8 | struct ListNode* removeNthFromEnd(struct ListNode* head, int n) { 9 | struct ListNode root; 10 | struct ListNode *l1,*l2; 11 | 12 | root.next = head; 13 | l1 = &root; 14 | l2 = &root; 15 | 16 | while(n--){ 17 | l2 = l2->next; 18 | } 19 | 20 | while(l2->next){ 21 | l1 = l1->next; 22 | l2 = l2->next; 23 | } 24 | 25 | l1->next = l1->next->next; 26 | 27 | return root.next; 28 | } 29 | -------------------------------------------------------------------------------- /c/two-pointers/sort-colors.c: -------------------------------------------------------------------------------- 1 | void sortColors(int* nums, int numsSize) { 2 | int i; 3 | int zero,one,two; 4 | 5 | zero = one = two = 0; 6 | for(i = 0; i < numsSize; ++i){ 7 | if(nums[i] == 0){ 8 | nums[two++] = nums[one]; 9 | nums[one++] = nums[zero]; 10 | nums[zero++] = 0; 11 | }else if(nums[i] == 1){ 12 | nums[two++] = nums[one]; 13 | nums[one++] = 1; 14 | }else{ 15 | nums[two++] = 2; 16 | } 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /go.mod: -------------------------------------------------------------------------------- 1 | module leetcode 2 | 3 | go 1.18 4 | -------------------------------------------------------------------------------- /go/alg/best_time_to_buy_and_sell_stock/code.go: -------------------------------------------------------------------------------- 1 | package besttimetobuyandsellstock 2 | 3 | func maxProfit(prices []int) int { 4 | minP := int(^uint(0) >> 1) 5 | maxVal := 0 6 | for i := 0; i < len(prices); i++ { 7 | if prices[i] < minP { 8 | minP = prices[i] 9 | } 10 | 11 | if prices[i]-minP > maxVal { 12 | maxVal = prices[i] - minP 13 | } 14 | } 15 | 16 | return maxVal 17 | } 18 | -------------------------------------------------------------------------------- /go/alg/binary_search/code.go: -------------------------------------------------------------------------------- 1 | package binarysearch 2 | 3 | func search(nums []int, target int) int { 4 | l, r := 0, len(nums)-1 5 | for l <= r { 6 | mid := l + (r-l)/2 7 | if nums[mid] == target { 8 | return mid 9 | } 10 | 11 | if nums[mid] > target { 12 | r = mid - 1 13 | } else { 14 | l = mid + 1 15 | } 16 | } 17 | 18 | return -1 19 | } 20 | -------------------------------------------------------------------------------- /go/alg/bit/hamming_distance/code.go: -------------------------------------------------------------------------------- 1 | package hammingdistance 2 | 3 | func hammingDistance(x int, y int) int { 4 | val := x ^ y 5 | cnt := 0 6 | for val > 0 { 7 | cnt += val & 0x1 8 | val >>= 1 9 | } 10 | 11 | return cnt 12 | } 13 | -------------------------------------------------------------------------------- /go/alg/bit/hamming_distance/code_test.go: -------------------------------------------------------------------------------- 1 | package hammingdistance 2 | 3 | import "testing" 4 | 5 | func TestHammingDistance(t *testing.T) { 6 | cnt := hammingDistance(4, 1) 7 | t.Logf("%d\n", cnt) //2 8 | 9 | cnt = hammingDistance(3, 1) 10 | t.Logf("%d\n", cnt) //1 11 | } 12 | -------------------------------------------------------------------------------- /go/alg/bit/integer_replacement/code.go: -------------------------------------------------------------------------------- 1 | package integer 2 | 3 | func min(a, b int) int { 4 | if a > b { 5 | return b 6 | } 7 | 8 | return a 9 | } 10 | 11 | func integerReplacement(n int) int { 12 | if n == 1 { 13 | return 0 14 | } 15 | 16 | if n%2 == 0 { 17 | return 1 + integerReplacement(n/2) 18 | } 19 | 20 | return 2 + min(integerReplacement((n+1)/2), integerReplacement((n-1)/2)) 21 | } 22 | -------------------------------------------------------------------------------- /go/alg/bit/power_of_four/code.go: -------------------------------------------------------------------------------- 1 | package poweroffour 2 | 3 | func isPowerOfFour(n int) bool { 4 | if n <= 0 { 5 | return false 6 | } 7 | 8 | if n&(n-1) != 0 { 9 | return false 10 | } 11 | 12 | return n&0xaaaaaaaa == 0 13 | } 14 | -------------------------------------------------------------------------------- /go/alg/bit/power_of_four/code_test.go: -------------------------------------------------------------------------------- 1 | package poweroffour 2 | 3 | import ( 4 | "testing" 5 | ) 6 | 7 | func TestIsPowerOfFour(t *testing.T) { 8 | if isPowerOfFour(0) != false { 9 | t.Fatal("test failed") 10 | } 11 | 12 | if isPowerOfFour(16) != true { 13 | t.Fatal("test failed") 14 | } 15 | 16 | if isPowerOfFour(5) != false { 17 | t.Fatal("test failed") 18 | } 19 | 20 | if isPowerOfFour(1) != true { 21 | t.Fatal("test failed") 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /go/alg/climbing_stairs/code.go: -------------------------------------------------------------------------------- 1 | package climbingstairs 2 | 3 | func climbStairs(n int) int { 4 | if n <= 1 { 5 | return 1 6 | } 7 | 8 | dp := make([]int, n+1) 9 | dp[1] = 1 10 | dp[2] = 2 11 | for i := 3; i <= n; i++ { 12 | dp[i] = dp[i-1] + dp[i-2] 13 | } 14 | 15 | return dp[n] 16 | } 17 | -------------------------------------------------------------------------------- /go/alg/contains_duplicate_ii/code.go: -------------------------------------------------------------------------------- 1 | package containsduplicateii 2 | 3 | func containsNearbyDuplicate(nums []int, k int) bool { 4 | flag := make(map[int]struct{}, k) 5 | l := 0 6 | r := 0 7 | for r < len(nums) { 8 | if _, ok := flag[nums[r]]; ok { 9 | return true 10 | } 11 | flag[nums[r]] = struct{}{} 12 | r++ 13 | 14 | if r-l > k { 15 | delete(flag, nums[l]) 16 | l++ 17 | } 18 | } 19 | 20 | return false 21 | } 22 | -------------------------------------------------------------------------------- /go/alg/contains_duplicate_iii/code_test.go: -------------------------------------------------------------------------------- 1 | package containsduplicateiii 2 | 3 | import "testing" 4 | 5 | func TestContainsNearbyAlmostDuplicate(t *testing.T) { 6 | nums := []int{-3, 3, -6} 7 | k := 2 8 | m := 3 9 | ok := containsNearbyAlmostDuplicate(nums, k, m) 10 | t.Logf("%v\n", ok) 11 | } 12 | -------------------------------------------------------------------------------- /go/alg/daily_temperatures/code.go: -------------------------------------------------------------------------------- 1 | package dailytemperatures 2 | 3 | func dailyTemperatures(temperatures []int) (arr []int) { 4 | st := make([]int, len(temperatures)) 5 | top := -1 6 | 7 | arr = make([]int, len(temperatures)) 8 | 9 | for idx, val := range temperatures { 10 | for top > -1 && val > temperatures[st[top]] { 11 | arr[st[top]] = idx - st[top] 12 | top-- 13 | } 14 | top++ 15 | st[top] = idx 16 | } 17 | 18 | for top > -1 { 19 | arr[st[top]] = 0 20 | top-- 21 | } 22 | 23 | return 24 | } 25 | -------------------------------------------------------------------------------- /go/alg/generate_parentheses/code.go: -------------------------------------------------------------------------------- 1 | package generateparentheses 2 | 3 | func generateParenthesis(n int) (arr []string) { 4 | if n == 0 { 5 | return 6 | } 7 | 8 | set := make(map[string]struct{}) 9 | set["()"] = struct{}{} 10 | 11 | for i := 2; i <= n; i++ { 12 | newSet := make(map[string]struct{}) 13 | for str := range set { 14 | for i := 0; i <= len(str); i++ { 15 | newStr := str[:i] + "()" + str[i:] 16 | newSet[newStr] = struct{}{} 17 | } 18 | } 19 | set = newSet 20 | } 21 | 22 | for str := range set { 23 | arr = append(arr, str) 24 | } 25 | 26 | return arr 27 | } 28 | -------------------------------------------------------------------------------- /go/alg/kth_largest_element_in_an_array/code_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "testing" 4 | 5 | func TestFindKthLargest(t *testing.T) { 6 | // nums := []int{3, 2, 1, 5, 6, 4} 7 | // k := 2 8 | // val := findKthLargest(nums, k) 9 | // t.Logf("%d", val) //5 10 | 11 | nums := []int{3, 1, 2, 4} 12 | k := 2 13 | val := findKthLargest(nums, k) 14 | t.Logf("%d", val) //3 15 | 16 | // nums := []int{3, 2, 3, 1, 2, 4, 5, 5, 6} 17 | // k := 4 18 | // val := findKthLargest(nums, k) 19 | // t.Logf("%d", val) //4 20 | } 21 | -------------------------------------------------------------------------------- /go/alg/kth_largest_element_in_an_array/kth_largest_element_in_an_array.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lightmen/leetcode/5f554156a5e235a8a97736a88f4f830019215152/go/alg/kth_largest_element_in_an_array/kth_largest_element_in_an_array.exe -------------------------------------------------------------------------------- /go/alg/kth_largest_element_in_an_array/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | nums := []int{3, 2, 3, 1, 2, 4, 5, 5, 6} 7 | k := 4 8 | val := findKthLargest(nums, k) 9 | fmt.Printf("%d\n", val) //4 10 | } 11 | -------------------------------------------------------------------------------- /go/alg/largest_number/code.go: -------------------------------------------------------------------------------- 1 | package largestnumber 2 | 3 | import ( 4 | "sort" 5 | "strconv" 6 | ) 7 | 8 | type IntSlice []int 9 | 10 | func (s IntSlice) Len() int { 11 | return len(s) 12 | } 13 | 14 | func (s IntSlice) Less(i, j int) bool { 15 | si := strconv.Itoa(s[i]) 16 | sj := strconv.Itoa(s[j]) 17 | 18 | return si+sj > sj+si 19 | } 20 | 21 | func (s IntSlice) Swap(i, j int) { 22 | s[i], s[j] = s[j], s[i] 23 | } 24 | 25 | func largestNumber(nums []int) string { 26 | sort.Sort(IntSlice(nums)) 27 | s := "" 28 | for _, val := range nums { 29 | s += strconv.Itoa(val) 30 | } 31 | 32 | return s 33 | } 34 | -------------------------------------------------------------------------------- /go/alg/largest_number/code_test.go: -------------------------------------------------------------------------------- 1 | package largestnumber 2 | 3 | import "testing" 4 | 5 | func TestLargestNumber(t *testing.T) { 6 | // nums := []int{10, 2} 7 | // t.Logf("%s", largestNumber(nums)) 8 | 9 | nums := []int{3, 30} 10 | t.Logf("%s", largestNumber(nums)) 11 | } 12 | -------------------------------------------------------------------------------- /go/alg/largest_number/next_permutation/code_test.go: -------------------------------------------------------------------------------- 1 | package nextpermutation 2 | 3 | import "testing" 4 | 5 | func TestNextPermutation(t *testing.T) { 6 | nums := []int{1, 3, 2} 7 | nextPermutation(nums) 8 | t.Logf("%v", nums) 9 | } 10 | -------------------------------------------------------------------------------- /go/alg/longest_increasing_subsequence/code.go: -------------------------------------------------------------------------------- 1 | package longest 2 | 3 | func max(a, b int) int { 4 | if a > b { 5 | return a 6 | } 7 | 8 | return b 9 | } 10 | 11 | func lengthOfLIS(nums []int) int { 12 | if len(nums) == 0 { 13 | return 0 14 | } 15 | 16 | dp := make([]int, len(nums)) 17 | maxLen := 0 18 | for i, val := range nums { 19 | dp[i] = 1 20 | for j := 0; j <= i-1; j++ { 21 | if val > nums[j] { 22 | dp[i] = max(dp[i], dp[j]+1) 23 | } 24 | } 25 | maxLen = max(maxLen, dp[i]) 26 | } 27 | 28 | return maxLen 29 | } 30 | -------------------------------------------------------------------------------- /go/alg/longest_substring_without_repeating_characters/code.go: -------------------------------------------------------------------------------- 1 | package longest_substring 2 | 3 | func lengthOfLongestSubstring(s string) int { 4 | flag := make(map[byte]struct{}) 5 | start, end := 0, 0 6 | maxSub := 0 7 | for start < len(s) { 8 | for end < len(s) { 9 | if _, ok := flag[s[end]]; ok { 10 | break 11 | } 12 | flag[s[end]] = struct{}{} 13 | if end-start+1 > maxSub { 14 | maxSub = end - start + 1 15 | } 16 | end++ 17 | } 18 | 19 | delete(flag, s[start]) 20 | start++ 21 | } 22 | 23 | return maxSub 24 | } 25 | -------------------------------------------------------------------------------- /go/alg/longest_substring_without_repeating_characters/code1.go: -------------------------------------------------------------------------------- 1 | package longest_substring 2 | 3 | func lengthOfLongestSubstring1(s string) int { 4 | var index [256]int 5 | for i := 0; i < len(index); i++ { 6 | index[i] = -1 7 | } 8 | 9 | lastIndex := -1 10 | maxSub := 0 11 | for i := 0; i < len(s); i++ { 12 | ch := int(s[i]) 13 | if index[ch] >= lastIndex { 14 | lastIndex = index[ch] + 1 15 | } 16 | 17 | index[ch] = i 18 | if i-lastIndex+1 > maxSub { 19 | maxSub = i - lastIndex + 1 20 | } 21 | } 22 | 23 | return maxSub 24 | } 25 | -------------------------------------------------------------------------------- /go/alg/longest_substring_without_repeating_characters/code1_test.go: -------------------------------------------------------------------------------- 1 | package longest_substring 2 | 3 | import "testing" 4 | 5 | func TestLengthOfLongestSubstring1(t *testing.T) { 6 | s := "abcabcbb" 7 | 8 | t.Log(lengthOfLongestSubstring1(s)) 9 | } 10 | -------------------------------------------------------------------------------- /go/alg/lru_cache/code_test.go: -------------------------------------------------------------------------------- 1 | package lrucache 2 | 3 | import "testing" 4 | 5 | func TestLRUCache(t *testing.T) { 6 | lru := Constructor(2) 7 | lru.Put(1, 1) // 缓存是 {1=1} 8 | lru.Put(2, 2) // 缓存是 {1=1, 2=2} 9 | t.Log(lru.Get(1)) // 返回 1 10 | lru.Put(3, 3) // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3} 11 | t.Log(lru.Get(2)) // 返回 -1 (未找到) 12 | lru.Put(4, 4) // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3} 13 | t.Log(lru.Get(1)) // 返回 -1 (未找到) 14 | t.Log(lru.Get(3)) // 返回 3 15 | t.Log(lru.Get(4)) // 返回 4 16 | 17 | } 18 | -------------------------------------------------------------------------------- /go/alg/maximum_subarray/code.go: -------------------------------------------------------------------------------- 1 | package maximumsubarray 2 | 3 | import "math" 4 | 5 | func max(a, b int) int { 6 | if a > b { 7 | return a 8 | } 9 | 10 | return b 11 | } 12 | 13 | func maxSubArray(nums []int) int { 14 | maxSum := math.MinInt 15 | 16 | sum := 0 17 | for _, val := range nums { 18 | sum += val 19 | maxSum = max(maxSum, sum) 20 | if sum < 0 { 21 | sum = 0 22 | } 23 | } 24 | 25 | return maxSum 26 | } 27 | -------------------------------------------------------------------------------- /go/alg/maximum_subarray/code_test.go: -------------------------------------------------------------------------------- 1 | package maximumsubarray 2 | 3 | import "testing" 4 | 5 | func TestMaxSubArray(t *testing.T) { 6 | nums := []int{-2, 1, -3, 4, -1, 2, 1, -5, 4} 7 | if maxSubArray(nums) != 6 { 8 | t.Fatalf("test failed") 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /go/alg/minimum_size_subarray_sum/code.go: -------------------------------------------------------------------------------- 1 | package minimumsizesubarraysum 2 | 3 | func minSubArrayLen(target int, nums []int) int { 4 | start, end := 0, 0 5 | sum := 0 6 | minSub := len(nums) + 1 7 | for end < len(nums) { 8 | sum += nums[end] 9 | 10 | for start <= end && sum >= target { 11 | if sum >= target && end-start+1 < minSub { 12 | minSub = end - start + 1 13 | } 14 | sum -= nums[start] 15 | start++ 16 | } 17 | 18 | end++ 19 | } 20 | 21 | if minSub <= len(nums) { 22 | return minSub 23 | } 24 | 25 | return 0 26 | } 27 | -------------------------------------------------------------------------------- /go/alg/minimum_size_subarray_sum/code_test.go: -------------------------------------------------------------------------------- 1 | package minimumsizesubarraysum 2 | 3 | import "testing" 4 | 5 | func TestMinSubArrayLen(t *testing.T) { 6 | nums := []int{2, 3, 1, 2, 4, 3} 7 | sub := minSubArrayLen(7, nums) 8 | 9 | t.Logf("%d", sub) 10 | } 11 | -------------------------------------------------------------------------------- /go/alg/next_greater_element_i/code.go: -------------------------------------------------------------------------------- 1 | package nextgreaterelementi 2 | 3 | func nextGreaterElement(nums1 []int, nums2 []int) []int { 4 | valMap := make(map[int]int) 5 | st := make([]int, len(nums2)) 6 | top := -1 7 | 8 | for _, val := range nums2 { 9 | for top > -1 && val > st[top] { 10 | valMap[st[top]] = val 11 | top-- 12 | } 13 | top++ 14 | st[top] = val 15 | } 16 | 17 | for i := 0; i <= top; i++ { 18 | valMap[st[i]] = -1 19 | } 20 | 21 | arr := make([]int, len(nums1)) 22 | for idx, val := range nums1 { 23 | arr[idx] = valMap[val] 24 | } 25 | 26 | return arr 27 | } 28 | -------------------------------------------------------------------------------- /go/alg/palindrome_number/code.go: -------------------------------------------------------------------------------- 1 | package palindrome_number 2 | 3 | func isPalindrome(x int) bool { 4 | if x < 0 { 5 | return false 6 | } 7 | 8 | tmp := x 9 | val := 0 10 | for tmp > 0 { 11 | remain := tmp % 10 12 | tmp /= 10 13 | val = val*10 + remain 14 | } 15 | 16 | return val == x 17 | } 18 | -------------------------------------------------------------------------------- /go/alg/permutation_in_string/code.go: -------------------------------------------------------------------------------- 1 | package permutationinstring 2 | 3 | func checkInclusion(s1 string, s2 string) bool { 4 | if len(s2) < len(s1) { 5 | return false 6 | } 7 | 8 | cnt1 := [26]int{} 9 | cnt2 := [26]int{} 10 | for i, v := range s1 { 11 | cnt1[v-'a']++ 12 | cnt2[s2[i]-'a']++ 13 | } 14 | 15 | if cnt1 == cnt2 { 16 | return true 17 | } 18 | 19 | for i := len(s1); i < len(s2); i++ { 20 | cnt2[s2[i]-'a']++ 21 | cnt2[s2[i-len(s1)]-'a']-- 22 | if cnt1 == cnt2 { 23 | return true 24 | } 25 | } 26 | 27 | return false 28 | } 29 | -------------------------------------------------------------------------------- /go/alg/permutation_in_string/code_test.go: -------------------------------------------------------------------------------- 1 | package permutationinstring 2 | 3 | import "testing" 4 | 5 | func TestCheckInclusion(t *testing.T) { 6 | s1 := "adc" 7 | s2 := "dcda" 8 | ok := checkInclusion(s1, s2) 9 | t.Logf("%v", ok) 10 | } 11 | -------------------------------------------------------------------------------- /go/alg/permutations/code.go: -------------------------------------------------------------------------------- 1 | package permutations 2 | 3 | func permute(nums []int) [][]int { 4 | arrList := make([][]int, 0) 5 | process(nums, 0, &arrList) 6 | return arrList 7 | } 8 | 9 | func swap(nums []int, i, j int) { 10 | nums[i], nums[j] = nums[j], nums[i] 11 | } 12 | 13 | func process(nums []int, i int, arrList *[][]int) { 14 | if i == len(nums)-1 { 15 | newNums := make([]int, len(nums)) 16 | copy(newNums, nums) 17 | *arrList = append(*arrList, newNums) 18 | return 19 | } 20 | 21 | for j := i; j < len(nums); j++ { 22 | swap(nums, i, j) 23 | 24 | process(nums, i+1, arrList) 25 | 26 | swap(nums, i, j) 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /go/alg/permutations/code_test.go: -------------------------------------------------------------------------------- 1 | package permutations 2 | 3 | import "testing" 4 | 5 | func TestPermute(t *testing.T) { 6 | nums := []int{1, 2, 3} 7 | arrList := permute(nums) 8 | t.Logf("%v", arrList) 9 | } 10 | -------------------------------------------------------------------------------- /go/alg/permutations_ii/code_test.go: -------------------------------------------------------------------------------- 1 | package permutationii 2 | 3 | import "testing" 4 | 5 | func TestPermuteUnique(t *testing.T) { 6 | nums := []int{2, 1, 1, 2} 7 | arrList := permuteUnique(nums) 8 | 9 | t.Logf("%v", arrList) 10 | 11 | nums = []int{1, 2, 3} 12 | arrList = permuteUnique(nums) 13 | 14 | t.Logf("%v", arrList) 15 | } 16 | -------------------------------------------------------------------------------- /go/alg/regular_expression_matching/code_test.go: -------------------------------------------------------------------------------- 1 | package wildcardmatregularexpressionmatchingching 2 | 3 | import "testing" 4 | 5 | func TestIsMatch(t *testing.T) { 6 | s := "aa" 7 | p := ".*" 8 | 9 | ok := isMatch(s, p) 10 | t.Logf("%v\n", ok) 11 | } 12 | -------------------------------------------------------------------------------- /go/alg/remove_k_digits/code.go: -------------------------------------------------------------------------------- 1 | package removekdigits 2 | 3 | import "strings" 4 | 5 | func removeKdigits(num string, k int) string { 6 | st := make([]byte, len(num)) 7 | top := -1 8 | 9 | for i := 0; i < len(num); i++ { 10 | for k > 0 && top > -1 && num[i] < st[top] { 11 | k-- 12 | top-- 13 | } 14 | top++ 15 | st[top] = num[i] 16 | } 17 | 18 | st = st[:top-k+1] 19 | s := strings.TrimLeft(string(st), "0") 20 | if s == "" { 21 | s = "0" 22 | } 23 | 24 | return s 25 | } 26 | -------------------------------------------------------------------------------- /go/alg/remove_k_digits/code_test.go: -------------------------------------------------------------------------------- 1 | package removekdigits 2 | 3 | import ( 4 | "testing" 5 | ) 6 | 7 | func TestNum(t *testing.T) { 8 | num := "1432219" 9 | k := 3 10 | t.Logf("%s", removeKdigits(num, k)) //1219 11 | 12 | num = "10200" 13 | k = 1 14 | t.Logf("%s", removeKdigits(num, k)) //200 15 | 16 | num = "10" 17 | k = 2 18 | t.Logf("%s", removeKdigits(num, k)) //0 19 | } 20 | -------------------------------------------------------------------------------- /go/alg/search_in_rotated_sorted_array/code.go: -------------------------------------------------------------------------------- 1 | package searchinrotatedsortedarray 2 | 3 | func search(nums []int, target int) int { 4 | l, r := 0, len(nums)-1 5 | for l <= r { 6 | mid := l + (r-l)/2 7 | if nums[mid] == target { 8 | return mid 9 | } 10 | 11 | if nums[mid] > target { 12 | if nums[l] <= target || nums[l] > nums[mid] { 13 | r = mid - 1 14 | } else { 15 | l = mid + 1 16 | } 17 | } else { 18 | if nums[r] >= target || nums[r] < nums[mid] { 19 | l = mid + 1 20 | } else { 21 | r = mid - 1 22 | } 23 | 24 | } 25 | } 26 | 27 | return -1 28 | } 29 | -------------------------------------------------------------------------------- /go/alg/search_in_rotated_sorted_array/code_test.go: -------------------------------------------------------------------------------- 1 | package searchinrotatedsortedarray 2 | 3 | import "testing" 4 | 5 | func TestSearch(t *testing.T) { 6 | nums := []int{4, 5, 6, 7, 8, 1, 2, 3} 7 | target := 8 8 | if search(nums, target) != 4 { 9 | t.Fatal("test failed") 10 | } 11 | 12 | nums = []int{1, 2, 3, 4} 13 | target = 3 14 | if search(nums, target) != 2 { 15 | t.Fatal("test failed") 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /go/alg/sliding_window_maximum/code.go: -------------------------------------------------------------------------------- 1 | package sliding_window_maximum 2 | 3 | func maxSlidingWindow(nums []int, k int) []int { 4 | arr := make([]int, 0) 5 | l := 0 6 | r := -1 7 | queue := make([]int, len(nums)) 8 | front := 0 9 | end := -1 10 | for r < len(nums)-1 { 11 | r++ 12 | for end-front >= 0 && nums[r] >= nums[queue[end]] { 13 | end-- 14 | } 15 | end++ 16 | queue[end] = r 17 | 18 | if r-l+1 > k { 19 | if queue[front] == l { 20 | front++ 21 | } 22 | l++ 23 | } 24 | 25 | if r-l+1 == k { 26 | arr = append(arr, nums[queue[front]]) 27 | } 28 | } 29 | 30 | return arr 31 | } 32 | -------------------------------------------------------------------------------- /go/alg/sort_an_array/code_test.go: -------------------------------------------------------------------------------- 1 | package sortanarray 2 | 3 | import "testing" 4 | 5 | func TestSort(t *testing.T) { 6 | arr := []int{23, 5, 98, 60, 23, 134} 7 | sortArray(arr) 8 | t.Logf("%v", arr) 9 | 10 | arr = []int{1, 2, 3, 4} 11 | sortArray(arr) 12 | t.Logf("%v", arr) 13 | } 14 | -------------------------------------------------------------------------------- /go/alg/wildcard_matching/code_test.go: -------------------------------------------------------------------------------- 1 | package wildcardmatching 2 | 3 | import "testing" 4 | 5 | func TestIsMatch(t *testing.T) { 6 | s := "aab" 7 | p := "c*a*b" 8 | 9 | ok := isMatch(s, p) 10 | 11 | t.Logf("ok: %v\n", ok) 12 | } 13 | -------------------------------------------------------------------------------- /go/array/array-partition-i.go: -------------------------------------------------------------------------------- 1 | func arrayPairSum(nums []int) int { 2 | sort.Ints(nums) 3 | 4 | ret := 0 5 | for i := 0; i < len(nums); i += 2 { 6 | ret += nums[i] 7 | } 8 | 9 | return ret 10 | } 11 | -------------------------------------------------------------------------------- /go/array/best-time-to-buy-and-sell-stock-ii.go: -------------------------------------------------------------------------------- 1 | func maxProfit(prices []int) int { 2 | var ret int 3 | 4 | for i := 1; i < len(prices); i++ { 5 | if(prices[i] > prices[i-1]) { 6 | ret += prices[i] - prices[i-1] 7 | } 8 | } 9 | 10 | return ret 11 | } 12 | -------------------------------------------------------------------------------- /go/array/best-time-to-buy-and-sell-stock.go: -------------------------------------------------------------------------------- 1 | func maxProfit(prices []int) int { 2 | ret := 0; 3 | cur := int(^uint(0) >> 1) 4 | 5 | for i := 0; i < len(prices); i++ { 6 | if prices[i] - cur > ret { 7 | ret = prices[i] - cur 8 | } 9 | if prices[i] < cur { 10 | cur = prices[i] 11 | } 12 | } 13 | 14 | return ret 15 | } 16 | -------------------------------------------------------------------------------- /go/array/contains-duplicate-ii.go: -------------------------------------------------------------------------------- 1 | func containsNearbyDuplicate(nums []int, k int) bool { 2 | for i := 0; i < len(nums); i++ { 3 | for j := i + 1; j < len(nums) && j <= i + k; j++{ 4 | if(nums[i] == nums[j]){ 5 | return true 6 | } 7 | } 8 | } 9 | 10 | return false 11 | } 12 | -------------------------------------------------------------------------------- /go/array/contains-duplicate-ii[1].go: -------------------------------------------------------------------------------- 1 | func containsNearbyDuplicate(nums []int, k int) bool { 2 | var mp map[int]int 3 | mp = make(map[int]int) 4 | 5 | for idx, value := range nums { 6 | key, ok := mp[value] 7 | if(ok && idx - key <= k){ 8 | return true 9 | } 10 | mp[value] = idx 11 | } 12 | 13 | return false 14 | } 15 | -------------------------------------------------------------------------------- /go/array/contains-duplicate.go: -------------------------------------------------------------------------------- 1 | func containsDuplicate(nums []int) bool { 2 | var mp = make(map[int]int) 3 | 4 | for idx, value := range nums { 5 | _, ok := mp[value] 6 | if ok { 7 | return true 8 | } 9 | mp[value] = idx 10 | } 11 | 12 | return false 13 | } 14 | -------------------------------------------------------------------------------- /go/array/majority-element.go: -------------------------------------------------------------------------------- 1 | func majorityElement(nums []int) int { 2 | var count, value int 3 | 4 | for i := range nums { 5 | if count == 0 { 6 | value = nums[i] 7 | } 8 | if value == nums[i] { 9 | count++ 10 | }else{ 11 | count-- 12 | } 13 | } 14 | 15 | return value 16 | } 17 | -------------------------------------------------------------------------------- /go/array/maximum-subarray.go: -------------------------------------------------------------------------------- 1 | func maxSubArray(nums []int) int { 2 | var maxsum, cursum int 3 | 4 | maxsum = math.MinInt32 5 | for _, value := range nums { 6 | cursum += value 7 | if cursum > maxsum { 8 | maxsum = cursum 9 | } 10 | if cursum < 0 { 11 | cursum = 0 12 | } 13 | } 14 | 15 | return maxsum 16 | } 17 | -------------------------------------------------------------------------------- /go/array/merge-sorted-array.go: -------------------------------------------------------------------------------- 1 | func merge(nums1 []int, m int, nums2 []int, n int) { 2 | i := m - 1 3 | j := n - 1 4 | k := m + n - 1 5 | for i >= 0 && j >= 0 { 6 | if nums1[i] > nums2[j] { 7 | nums1[k] = nums1[i] 8 | i-- 9 | } else { 10 | nums1[k] = nums2[j] 11 | j-- 12 | } 13 | k-- 14 | } 15 | 16 | for j >= 0 { 17 | nums1[k] = nums2[j] 18 | k-- 19 | j-- 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /go/array/missing-number.go: -------------------------------------------------------------------------------- 1 | func missingNumber(nums []int) int { 2 | ret := len(nums) * (len(nums) + 1) / 2 3 | for _, v := range nums { 4 | ret -= v 5 | } 6 | 7 | return ret 8 | } 9 | -------------------------------------------------------------------------------- /go/array/plus-one.go: -------------------------------------------------------------------------------- 1 | func plusOne(digits []int) []int { 2 | var carry = 1 3 | var arr = make([]int, len(digits) + 1) 4 | 5 | for i := len(digits); i > 0; i-- { 6 | arr[i] = (digits[i-1] + carry) % 10 7 | carry = (digits[i-1] + carry) / 10 8 | } 9 | 10 | if carry == 1 { 11 | arr[0] = carry 12 | return arr 13 | } 14 | return arr[1:] 15 | } 16 | -------------------------------------------------------------------------------- /go/array/remove-duplicates-from-sorted-array.go: -------------------------------------------------------------------------------- 1 | func removeDuplicates(nums []int) int { 2 | c := 0 3 | 4 | if len(nums) == 0 { 5 | return 0 6 | } 7 | 8 | for i := 0; i < len(nums); i++ { 9 | if(nums[i] != nums[c]){ 10 | c++ 11 | nums[c], nums[i] = nums[i], nums[c] 12 | } 13 | } 14 | 15 | return c + 1 16 | } 17 | -------------------------------------------------------------------------------- /go/array/remove-element.go: -------------------------------------------------------------------------------- 1 | func removeElement(nums []int, val int) int { 2 | i := 0 3 | j := len(nums) - 1 4 | for i <= j { 5 | for i <= j && nums[i] != val { 6 | i++ 7 | } 8 | 9 | for j >= i && nums[j] == val { 10 | j-- 11 | } 12 | 13 | if(i < j) { 14 | nums[i], nums[j] = nums[j], nums[i] 15 | } 16 | } 17 | 18 | return i 19 | } 20 | -------------------------------------------------------------------------------- /go/array/remove-element[1].go: -------------------------------------------------------------------------------- 1 | func removeElement(nums []int, val int) int { 2 | idx := 0 3 | for i := 0; i < len(nums); i++ { 4 | if nums[i] != val { 5 | nums[idx] = nums[i] 6 | idx++ 7 | } 8 | } 9 | return idx 10 | } 11 | -------------------------------------------------------------------------------- /go/array/rotate-array.go: -------------------------------------------------------------------------------- 1 | func rotate(nums []int, k int) { 2 | k = k % len(nums) 3 | 4 | for k > 0 { 5 | var tmp = nums[len(nums) - 1] 6 | for i := len(nums) - 1; i > 0; i-- { 7 | nums[i] = nums[i - 1] 8 | } 9 | nums[0] = tmp 10 | k-- 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /go/array/rotate-array[1].go: -------------------------------------------------------------------------------- 1 | func rotate(nums []int, k int) { 2 | k %= len(nums) 3 | r := make([]int, len(nums)) 4 | copy(r, nums[len(nums) - k:]) 5 | copy(r[k:], nums[:len(nums) - k]) 6 | copy(nums, r) 7 | } 8 | -------------------------------------------------------------------------------- /go/array/rotate-array[2].go: -------------------------------------------------------------------------------- 1 | func rotate(nums []int, k int) { 2 | k %= len(nums) 3 | 4 | reverse(nums, 0, len(nums) - k - 1) 5 | reverse(nums, len(nums) - k, len(nums) - 1) 6 | reverse(nums, 0, len(nums) - 1) 7 | } 8 | 9 | func reverse(nums []int, start, end int){ 10 | for(start < end){ 11 | nums[start], nums[end] = nums[end], nums[start] 12 | start++ 13 | end-- 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /go/array/search-insert-position.go: -------------------------------------------------------------------------------- 1 | func searchInsert(nums []int, target int) int { 2 | i, j := 0, len(nums) - 1 3 | for i <= j { 4 | mid := (i + j) >> 1 5 | if nums[mid] == target { 6 | return mid 7 | }else if nums[mid] > target { 8 | j = mid - 1 9 | }else { 10 | i = mid + 1 11 | } 12 | } 13 | 14 | return i 15 | } 16 | -------------------------------------------------------------------------------- /go/array/two-sum-ii-input-array-is-sorted[1].go: -------------------------------------------------------------------------------- 1 | func twoSum(numbers []int, target int) []int { 2 | var mp = make(map[int] int) 3 | 4 | for key, value := range numbers { 5 | idx, ok := mp[target - value] 6 | if ok { 7 | return []int{idx + 1, key + 1} 8 | } 9 | 10 | mp[value] = key 11 | } 12 | 13 | return []int{-1,-1} 14 | } 15 | -------------------------------------------------------------------------------- /go/array/two-sum.go: -------------------------------------------------------------------------------- 1 | func twoSum(nums []int, target int) []int { 2 | var ret []int 3 | for i := 0; i < len(nums); i++ { 4 | for j := i + 1; j < len(nums); j++ { 5 | if ((nums[i] + nums[j]) == target) { 6 | ret = append(ret,i,j) 7 | return ret 8 | } 9 | } 10 | } 11 | 12 | return ret 13 | } 14 | -------------------------------------------------------------------------------- /go/array/two-sum[1].go: -------------------------------------------------------------------------------- 1 | two-sum 2 | func twoSum(nums []int, target int) []int { 3 | var mp = make(map[int] int) 4 | for i := 0; i < len(nums); i++ { 5 | mp[nums[i]] = i 6 | } 7 | 8 | for j := 0; j < len(nums); j++{ 9 | index, ok := mp[target - nums[j]] 10 | if(ok && index != j){ 11 | return []int{index,j} 12 | } 13 | } 14 | 15 | return nil 16 | } 17 | -------------------------------------------------------------------------------- /go/dp/longest-palindromic-substring/code_test.go: -------------------------------------------------------------------------------- 1 | package dp 2 | 3 | import "testing" 4 | 5 | func TestLongestPalindrome(t *testing.T) { 6 | s := "aba" 7 | rs := longestPalindrome(s) 8 | if rs != "aba" { 9 | t.Fatalf("test failed: %s", rs) 10 | } 11 | 12 | s = "cbbd" 13 | rs = longestPalindrome(s) 14 | if rs != "bb" { 15 | t.Fatalf("test failed: %s", rs) 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /go/dp/unique_binary_search_trees/code.go: -------------------------------------------------------------------------------- 1 | package unique_binary_search_trees 2 | 3 | func numTrees(n int) int { 4 | dp := make([]int, n+1) 5 | dp[0] = 1 6 | dp[1] = 1 7 | for i := 2; i <= n; i++ { 8 | for j := 1; j <= i; j++ { 9 | dp[i] += dp[j-1] * dp[i-j] 10 | } 11 | } 12 | 13 | return dp[n] 14 | } 15 | -------------------------------------------------------------------------------- /go/dp/unique_binary_search_trees/code_test.go: -------------------------------------------------------------------------------- 1 | package unique_binary_search_trees 2 | 3 | import "testing" 4 | 5 | func TestNumTrees(t *testing.T) { 6 | val := numTrees(3) 7 | if val != 5 { 8 | t.Fatalf("test failed: %d", val) 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /go/kmp/code.go: -------------------------------------------------------------------------------- 1 | package kmp 2 | 3 | //返回s1中，首次出现s2的下标，如果s1中不包含s2， 返回-1 4 | func KMP(s1, s2 string) int{ 5 | 6 | return -1 7 | } 8 | 9 | func getNext(s string) (arr []int) { 10 | if len(s) <= 1 { 11 | return []int{-1} 12 | } 13 | 14 | arr = make([]int, len(s)) 15 | arr[0] = -1 16 | arr[1] = 1 17 | idx := 2 18 | prev := 0 19 | ch := []byte(s) 20 | for idx < len(s){ 21 | if ch[idx] == ch[arr[prev]+1] { 22 | arr[idx] = arr[prev] + 1 23 | idx++ 24 | prev = idx -1 25 | }else if arr[prev] == -1 { 26 | arr[idx] = 1 27 | idx++ 28 | }else { 29 | idx = arr[prev] 30 | } 31 | } 32 | return 33 | } -------------------------------------------------------------------------------- /go/kmp/code1_test.go: -------------------------------------------------------------------------------- 1 | package kmp 2 | 3 | import "testing" 4 | 5 | func TestKmp(t *testing.T) { 6 | s := "rabaieet" 7 | p := "abai" 8 | 9 | idx := Kmp(s, p) 10 | t.Logf("idx: %d", idx) 11 | } 12 | -------------------------------------------------------------------------------- /go/list/add_two_numbers/code_test.go: -------------------------------------------------------------------------------- 1 | package addtwonumbers 2 | -------------------------------------------------------------------------------- /go/list/add_two_numbers_ii/code_test.go: -------------------------------------------------------------------------------- 1 | package addtwonumbersii 2 | -------------------------------------------------------------------------------- /go/list/detect_cycle/code.go: -------------------------------------------------------------------------------- 1 | package detectcycle 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | func detectCycle(head *ListNode) *ListNode { 9 | if head == nil { 10 | return nil 11 | } 12 | 13 | slow, fast := head, head 14 | for slow != nil && fast != nil { 15 | slow = slow.Next 16 | fast = fast.Next 17 | if fast == nil || fast.Next == nil { //说明链表没有环 18 | return nil 19 | } 20 | 21 | fast = fast.Next 22 | 23 | if slow == fast { 24 | break 25 | } 26 | } 27 | 28 | for head != slow { 29 | head = head.Next 30 | slow = slow.Next 31 | } 32 | 33 | return head 34 | } 35 | -------------------------------------------------------------------------------- /go/list/detect_cycle/code_test.go: -------------------------------------------------------------------------------- 1 | package detectcycle 2 | 3 | import "testing" 4 | 5 | func TestDetectCycle(t *testing.T) { 6 | n1 := &ListNode{ 7 | Val: 3, 8 | } 9 | n2 := &ListNode{ 10 | Val: 2, 11 | } 12 | n3 := &ListNode{ 13 | Val: 0, 14 | } 15 | n4 := &ListNode{ 16 | Val: -4, 17 | } 18 | 19 | n1.Next = n2 20 | n2.Next = n3 21 | n3.Next = n4 22 | n4.Next = n2 23 | 24 | node := detectCycle(n1) 25 | 26 | t.Logf("val: %d", node.Val) 27 | } 28 | -------------------------------------------------------------------------------- /go/list/get_kth_from_end/code.go: -------------------------------------------------------------------------------- 1 | package getkthfromend 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | func getKthFromEnd(head *ListNode, k int) *ListNode { 9 | cnt := 0 10 | p := head 11 | for p != nil { 12 | cnt++ 13 | p = p.Next 14 | } 15 | 16 | k = cnt - k 17 | for k > 0 { 18 | head = head.Next 19 | k-- 20 | } 21 | 22 | return head 23 | } 24 | -------------------------------------------------------------------------------- /go/list/linked_list_cycle/code.go: -------------------------------------------------------------------------------- 1 | package linkedlistcycle 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | func hasCycle(head *ListNode) bool { 9 | if head == nil { 10 | return false 11 | } 12 | slow, fast := head, head.Next 13 | for slow != nil && fast != nil { 14 | if slow == fast { 15 | return true 16 | } 17 | slow = slow.Next 18 | fast = fast.Next 19 | if fast != nil { 20 | fast = fast.Next 21 | } 22 | } 23 | 24 | return false 25 | } 26 | -------------------------------------------------------------------------------- /go/list/odd_even_linked_list/code.go: -------------------------------------------------------------------------------- 1 | package oddevenlinkedlist 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | func oddEvenList(head *ListNode) *ListNode { 9 | oddRoot := &ListNode{} 10 | evenRoot := &ListNode{} 11 | odd := oddRoot 12 | even := evenRoot 13 | 14 | isOdd := true 15 | for head != nil { 16 | next := head.Next 17 | if isOdd { 18 | odd.Next = head 19 | odd = head 20 | } else { 21 | even.Next = head 22 | even = head 23 | } 24 | head.Next = nil 25 | head = next 26 | isOdd = !isOdd 27 | } 28 | 29 | odd.Next = evenRoot.Next 30 | return oddRoot.Next 31 | } 32 | -------------------------------------------------------------------------------- /go/list/remove_nth_node_from_end_list/code.go: -------------------------------------------------------------------------------- 1 | package removenthnodefromendlist 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | func removeNthFromEnd(head *ListNode, n int) *ListNode { 9 | root := &ListNode{ 10 | Next: head, 11 | } 12 | 13 | cnt := 0 14 | for head != nil { 15 | cnt++ 16 | head = head.Next 17 | } 18 | 19 | n = cnt - n 20 | 21 | p := root 22 | for n > 0 && p != nil { 23 | p = p.Next 24 | n-- 25 | } 26 | 27 | if p == nil || p.Next == nil { 28 | return root.Next 29 | } 30 | 31 | p.Next = p.Next.Next 32 | 33 | return root.Next 34 | } 35 | -------------------------------------------------------------------------------- /go/list/reorder_list/code_test.go: -------------------------------------------------------------------------------- 1 | package reorderlist 2 | 3 | import "testing" 4 | 5 | func TestOrderList(t *testing.T) { 6 | head := &ListNode{ 7 | Val: 1, 8 | Next: &ListNode{ 9 | Val: 2, 10 | Next: &ListNode{ 11 | Val: 3, 12 | Next: &ListNode{ 13 | Val: 4, 14 | }, 15 | }, 16 | }, 17 | } 18 | 19 | reorderList(head) 20 | } 21 | -------------------------------------------------------------------------------- /go/list/reverse/code.go: -------------------------------------------------------------------------------- 1 | package reverse 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | func reverseList(head *ListNode) *ListNode { 9 | root := &ListNode{} 10 | for head != nil { 11 | tmp := head.Next 12 | head.Next = root.Next 13 | root.Next = head 14 | head = tmp 15 | } 16 | 17 | return root.Next 18 | } 19 | -------------------------------------------------------------------------------- /go/list/reverse_nodes_in_k_group/code_test.go: -------------------------------------------------------------------------------- 1 | package reversenodesinkgroup 2 | 3 | import "testing" 4 | 5 | func TestReverseKGroup(t *testing.T) { 6 | head := &ListNode{ 7 | Val: 1, 8 | Next: &ListNode{ 9 | Val: 2, 10 | Next: &ListNode{ 11 | Val: 3, 12 | Next: &ListNode{ 13 | Val: 4, 14 | Next: &ListNode{ 15 | Val: 5, 16 | }, 17 | }, 18 | }, 19 | }, 20 | } 21 | 22 | head = reverseKGroup(head, 2) 23 | 24 | for head != nil { 25 | t.Logf("%d\n", head.Val) 26 | head = head.Next 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /go/list/rotate_list/code.go: -------------------------------------------------------------------------------- 1 | package rotatelist 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | func rotateRight(head *ListNode, k int) *ListNode { 9 | if head == nil { 10 | return nil 11 | } 12 | 13 | cur := head 14 | cnt := 0 15 | tail := cur 16 | for cur != nil { 17 | cnt++ 18 | tail = cur 19 | cur = cur.Next 20 | } 21 | 22 | k = k % cnt 23 | k = cnt - k 24 | cur = &ListNode{ 25 | Next: head, 26 | } 27 | 28 | cnt = 0 29 | for cur != nil && cnt != k { 30 | cur = cur.Next 31 | cnt++ 32 | } 33 | 34 | tail.Next = head 35 | head = cur.Next 36 | cur.Next = nil 37 | 38 | return head 39 | } 40 | -------------------------------------------------------------------------------- /go/list/shan_chu_lian_biao/code.go: -------------------------------------------------------------------------------- 1 | package shanchulianbiao 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | func deleteNode(head *ListNode, val int) *ListNode { 9 | root := &ListNode{ 10 | Next: head, 11 | } 12 | cur := root 13 | for head != nil && head.Val != val { 14 | cur = head 15 | head = head.Next 16 | } 17 | 18 | if head == nil { 19 | return nil 20 | } 21 | 22 | cur.Next = head.Next 23 | head.Next = nil 24 | head = nil 25 | return root.Next 26 | } 27 | -------------------------------------------------------------------------------- /go/misc/joseph/code.go: -------------------------------------------------------------------------------- 1 | package joseph 2 | 3 | //约瑟夫环问题 4 | 5 | //给定n个人，从1 到 n 编号，每隔m个人，删掉一个人，最后剩余一人为止， 6 | // 求最后剩下的那个人的编号 7 | 8 | //f(n,m) = (f(n-1, m) + m) % n 9 | //参考： https://blog.csdn.net/u011500062/article/details/72855826 10 | func Joseph(n, m int) int { 11 | idx := 0 12 | for i := 2; i <= n; i++ { 13 | idx = (idx + m) % i 14 | } 15 | 16 | //注意，由于编号从1开始的，所以这里加1 17 | return idx + 1 18 | } 19 | -------------------------------------------------------------------------------- /go/misc/joseph/code_test.go: -------------------------------------------------------------------------------- 1 | package joseph 2 | 3 | import "testing" 4 | 5 | func TestJoseph(t *testing.T) { 6 | n := 11 7 | m := 3 8 | 9 | idx := Joseph(n, m) 10 | if idx != 7 { 11 | t.Fatalf("test failed: %d", idx) 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /go/misc/longest-palindromic-substring/code_test.go: -------------------------------------------------------------------------------- 1 | package longest_palindromic_substring 2 | 3 | import "testing" 4 | 5 | func TestLongestPalindrome(t *testing.T) { 6 | s := "babad" 7 | result := longestPalindrome(s) 8 | if result != "bab" && result != "aba" { 9 | t.Fatalf("test failed:%s", result) 10 | } 11 | 12 | s = "" 13 | result = longestPalindrome(s) 14 | if result != "" { 15 | t.Fatalf("test failed:%s", result) 16 | } 17 | 18 | s = "a" 19 | result = longestPalindrome(s) 20 | if result != "a" { 21 | t.Fatalf("test failed:%s", result) 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /go/misc/sliding-window-maximum/code.go: -------------------------------------------------------------------------------- 1 | package sliding_window_maximum 2 | 3 | func maxSlidingWindow(nums []int, k int) []int { 4 | if k > len(nums) { 5 | k = len(nums) 6 | } 7 | 8 | qArr := make([]int, len(nums)) 9 | l := 0 10 | r := -1 11 | 12 | arr := make([]int, 0, len(nums) - k + 1) 13 | for idx, val := range nums { 14 | for l <= r && idx - qArr[l] >= k { 15 | l++ 16 | } 17 | 18 | for r >= l && nums[qArr[r]] <= val { 19 | r-- 20 | } 21 | 22 | r++ 23 | qArr[r] = idx 24 | 25 | if idx >= k-1 { 26 | arr = append(arr, nums[qArr[l]]) 27 | } 28 | } 29 | 30 | return arr 31 | } 32 | -------------------------------------------------------------------------------- /go/misc/sum-of-subarray-minimums/code_test.go: -------------------------------------------------------------------------------- 1 | package sum_of_subarray_minimums 2 | 3 | import "testing" 4 | 5 | func TestSumSubarrayMins(t *testing.T) { 6 | arr := []int{3,1,2,4} 7 | result := sumSubarrayMins(arr) 8 | expect := 17 9 | if result !=expect { 10 | t.Fatalf("test failed: %d", result) 11 | } 12 | 13 | arr = []int{71,55,82,55} 14 | result = sumSubarrayMins(arr) 15 | expect = 593 16 | if result !=expect { 17 | t.Fatalf("test failed: %d", result) 18 | } 19 | 20 | arr = []int{1,2,1} 21 | result = sumSubarrayMins(arr) 22 | expect = 4 23 | if result !=expect { 24 | t.Fatalf("test failed: %d", result) 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /go/misc/yuan-quan-zhong-zui-hou-sheng-xia-de-shu-zi-lcof/code.go: -------------------------------------------------------------------------------- 1 | package yuan_quan_zhong_zui_hou_sheng_xia_de_shu_zi_lcof 2 | 3 | //see https://blog.csdn.net/u011500062/article/details/72855826 4 | func lastRemaining(n int, m int) int { 5 | p := 0 6 | for i := 2; i <= n; i++ { 7 | p = (p + m) % i 8 | } 9 | return p 10 | } 11 | -------------------------------------------------------------------------------- /go/misc/yuan-quan-zhong-zui-hou-sheng-xia-de-shu-zi-lcof/code_test.go: -------------------------------------------------------------------------------- 1 | package yuan_quan_zhong_zui_hou_sheng_xia_de_shu_zi_lcof 2 | 3 | import "testing" 4 | 5 | func TestLastRemaining(t *testing.T) { 6 | var result int 7 | result = lastRemaining(5, 3) 8 | if result != 3 { 9 | t.Fatalf("test failed: %d", result) 10 | } 11 | 12 | result = lastRemaining(10, 17) 13 | if result != 2 { 14 | t.Fatalf("test failed: %d", result) 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /go/sort/heap/code_test.go: -------------------------------------------------------------------------------- 1 | package heap 2 | 3 | import ( 4 | "reflect" 5 | "testing" 6 | ) 7 | 8 | func TestHeapSort(t *testing.T) { 9 | arr := []int{1, 7, 3, 5, 3, 6,9} 10 | heapSort(arr) 11 | expect := []int{1, 3, 3, 5, 6, 7, 9} 12 | 13 | if !reflect.DeepEqual(arr, expect) { 14 | t.Fatalf("test failed:%v", arr) 15 | } 16 | 17 | 18 | arr = []int{1,1} 19 | heapSort(arr) 20 | expect = []int{1,1} 21 | 22 | if !reflect.DeepEqual(arr, expect) { 23 | t.Fatalf("test failed:%v", arr) 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /go/sort/heap/heap_test.go: -------------------------------------------------------------------------------- 1 | package heap 2 | 3 | import "testing" 4 | 5 | func TestSort(t *testing.T) { 6 | arr := []int{3, -1, 45, 3, 5, 98, 12, 2, 10} 7 | sort(arr) 8 | t.Logf("%v", arr) 9 | } 10 | -------------------------------------------------------------------------------- /go/stack/132-pattern_test.go: -------------------------------------------------------------------------------- 1 | package stack 2 | 3 | import "testing" 4 | 5 | func TestFind132pattern(t *testing.T) { 6 | nums := []int{1, 2, 3, 4} 7 | if find132pattern(nums) == true { 8 | t.Fatalf("test failed") 9 | } 10 | 11 | nums = []int{1,0,1,-4,-3} 12 | if find132pattern(nums) == true { 13 | t.Fatalf("test failed") 14 | } 15 | 16 | nums = []int{3, 1, 4, 2} 17 | if find132pattern(nums) == false { 18 | t.Fatalf("test failed") 19 | } 20 | 21 | nums = []int{-1, 3, 2, 0} 22 | if find132pattern(nums) == false { 23 | t.Fatalf("test failed") 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /go/stack/backspace-string-compare.go: -------------------------------------------------------------------------------- 1 | package stack 2 | 3 | func toStack(s string) (st []int32, top int) { 4 | top = -1 5 | st = make([]int32, len(s)) 6 | for _, val := range s { 7 | if val != '#' { 8 | top++ 9 | st[top] = val 10 | }else if top > -1{ 11 | top-- 12 | } 13 | } 14 | 15 | return 16 | } 17 | 18 | func backspaceCompare(S string, T string) bool { 19 | st1, top1 := toStack(S) 20 | st2, top2 := toStack(T) 21 | 22 | if top1 != top2 { 23 | return false 24 | } 25 | 26 | for idx := 0; idx <= top1; idx++ { 27 | if st1[idx] != st2[idx] { 28 | return false 29 | } 30 | } 31 | return true 32 | } 33 | -------------------------------------------------------------------------------- /go/stack/backspace-string-compare_test.go: -------------------------------------------------------------------------------- 1 | package stack 2 | 3 | import "testing" 4 | 5 | func TestBackspaceCompare(t *testing.T) { 6 | S := "ab#c" 7 | T := "ad#c" 8 | if !backspaceCompare(S, T) { 9 | t.Fatalf("test failed ") 10 | } 11 | 12 | S = "ab##" 13 | T = "c#d#" 14 | if !backspaceCompare(S, T) { 15 | t.Fatalf("test failed ") 16 | } 17 | 18 | 19 | S = "a##c" 20 | T = "#a#c" 21 | if !backspaceCompare(S, T) { 22 | t.Fatalf("test failed ") 23 | } 24 | 25 | 26 | S = "a#c" 27 | T = "b" 28 | if backspaceCompare(S, T) { 29 | t.Fatalf("test failed ") 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /go/stack/baseball-game.go: -------------------------------------------------------------------------------- 1 | package stack 2 | 3 | import "strconv" 4 | 5 | func calPoints(ops []string) int { 6 | st := make([]int, len(ops)) 7 | top := -1 8 | 9 | for _, s := range ops { 10 | switch s { 11 | case "C": 12 | top-- 13 | case "D": 14 | val := st[top] * 2 15 | top++ 16 | st[top] = val 17 | case "+": 18 | val := st[top-1] + st[top] 19 | top++ 20 | st[top] = val 21 | default: 22 | val,_ := strconv.ParseInt(s, 10, 64) 23 | top++ 24 | st[top] = int(val) 25 | } 26 | } 27 | 28 | var sum int 29 | for idx := 0; idx <= top; idx++ { 30 | sum += st[idx] 31 | } 32 | 33 | return sum 34 | } 35 | -------------------------------------------------------------------------------- /go/stack/baseball-game_test.go: -------------------------------------------------------------------------------- 1 | package stack 2 | 3 | import "testing" 4 | 5 | func TestCalPoints(t *testing.T) { 6 | ops := []string{"5","2","C","D","+"} 7 | 8 | sum := calPoints(ops) 9 | if sum != 30 { 10 | t.Fatalf("test failed: %d",sum) 11 | } 12 | 13 | ops = []string{"5","-2","4","C","D","9","+","+"} 14 | sum = calPoints(ops) 15 | if sum != 27 { 16 | t.Fatalf("test failed: %d",sum) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /go/stack/check-if-word-is-valid-after-substitutions.go: -------------------------------------------------------------------------------- 1 | package stack 2 | 3 | func isValid1(s string) bool { 4 | st := New() 5 | for _, c := range s { 6 | if c < 'c' { 7 | st.Push(c) 8 | continue 9 | } 10 | 11 | if st.Len() < 2 { 12 | return false 13 | } 14 | 15 | b := st.Pop() 16 | if b.(int32) != 'b' { 17 | return false 18 | } 19 | 20 | a := st.Pop() 21 | if a.(int32) != 'a' { 22 | return false 23 | } 24 | } 25 | 26 | return st.Len() == 0 27 | } 28 | -------------------------------------------------------------------------------- /go/stack/check-if-word-is-valid-after-substitutions_test.go: -------------------------------------------------------------------------------- 1 | package stack 2 | 3 | import "testing" 4 | 5 | func TestIsValid1(t *testing.T) { 6 | var s string 7 | s = "aabcbc" 8 | if !isValid1(s) { 9 | t.Fatalf("test failed") 10 | } 11 | 12 | s = "abcabcababcc" 13 | if !isValid1(s) { 14 | t.Fatalf("test failed") 15 | } 16 | 17 | 18 | s = "abccba" 19 | if isValid1(s) { 20 | t.Fatalf("test failed") 21 | } 22 | 23 | 24 | s = "cababc" 25 | if isValid1(s) { 26 | t.Fatalf("test failed") 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /go/stack/exclusive-time-of-functions_test.go: -------------------------------------------------------------------------------- 1 | package stack 2 | 3 | import "testing" 4 | 5 | func TestExclusiveTime(t *testing.T) { 6 | n := 2 7 | logs := []string { 8 | "0:start:0", 9 | "1:start:2", 10 | "1:end:5", 11 | "0:end:6", 12 | } 13 | 14 | arr := exclusiveTime(n, logs) 15 | if arr[0] != 3 || arr[1] != 4 { 16 | t.Fatalf("test failed: %+v", arr) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /go/stack/find-the-most-competitive-subsequence.go: -------------------------------------------------------------------------------- 1 | package stack 2 | 3 | func mostCompetitive(nums []int, k int) []int { 4 | st := make([]int, len(nums)) 5 | top := -1 6 | 7 | for i := 0; i < len(nums); i++ { 8 | val := nums[i] 9 | for top > -1 && val < st[top] &&(top + len(nums) - i) >= k { 10 | top-- 11 | } 12 | 13 | top++ 14 | st[top] = val 15 | } 16 | 17 | return st[:k] 18 | } -------------------------------------------------------------------------------- /go/stack/implement-queue-using-stacks-lcci_test.go: -------------------------------------------------------------------------------- 1 | package stack 2 | 3 | import "testing" 4 | 5 | func TestQueue(t *testing.T) { 6 | queue := Constructor() 7 | 8 | queue.Push(1) 9 | queue.Push(2) 10 | queue.Push(3) 11 | val := queue.Peek() 12 | if val != 1 { 13 | t.Fatalf("test failed, val: %d", val) 14 | } 15 | 16 | queue.Pop() 17 | if queue.Empty() { 18 | t.Fatalf("test failed") 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /go/stack/longest-well-performing-interval_test.go: -------------------------------------------------------------------------------- 1 | package stack 2 | 3 | import "testing" 4 | 5 | func TestLongestWPI(t *testing.T) { 6 | arr := []int{9,9,6,0,6,6,9} 7 | 8 | wpi := longestWPI(arr) 9 | if wpi != 3 { 10 | t.Fatalf("test failed:%d", wpi) 11 | } 12 | 13 | arr = []int{6,9,9} 14 | wpi = longestWPI(arr) 15 | if wpi != 3 { 16 | t.Fatalf("test failed:%d", wpi) 17 | } 18 | 19 | arr = []int{9,6, 9} 20 | 21 | wpi = longestWPI(arr) 22 | if wpi != 3 { 23 | t.Fatalf("test failed:%d", wpi) 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /go/stack/minimum-remove-to-make-valid-parentheses.go: -------------------------------------------------------------------------------- 1 | package stack 2 | 3 | func minRemoveToMakeValid(s string) string { 4 | st := make([]int32, len(s)) 5 | top := -1 6 | 7 | idSt := make([]int, len(s)) 8 | idTop := -1 9 | 10 | for idx, v := range s { 11 | if v == '(' || (v == ')' && (top == -1 || st[top] != '(') ){ 12 | top++ 13 | st[top] = v 14 | 15 | idTop++ 16 | idSt[idTop] = idx 17 | continue 18 | }else if v == ')' { 19 | top-- 20 | idTop-- 21 | } 22 | } 23 | 24 | for idTop > -1 { 25 | idx := idSt[idTop] 26 | idTop-- 27 | 28 | s = s[:idx] + s[idx+1:] 29 | } 30 | 31 | return s 32 | } 33 | -------------------------------------------------------------------------------- /go/stack/next-greater-node-in-linked-list.go: -------------------------------------------------------------------------------- 1 | package stack 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | func nextLargerNodes(head *ListNode) []int { 9 | arr := make([]int, 0) 10 | for head != nil { 11 | arr = append(arr, head.Val) 12 | head = head.Next 13 | } 14 | 15 | ret := make([]int, len(arr)) 16 | st := make([]int, len(arr)) 17 | top := -1 18 | for i := len(arr)-1; i >= 0; i-- { 19 | for top > -1 && arr[i] >= st[top] { 20 | top-- 21 | } 22 | 23 | if top > -1 { 24 | ret[i] = st[top] 25 | } 26 | top++ 27 | st[top] = arr[i] 28 | } 29 | 30 | return ret 31 | } 32 | -------------------------------------------------------------------------------- /go/stack/valid-parentheses_test.go: -------------------------------------------------------------------------------- 1 | package stack 2 | 3 | import "testing" 4 | 5 | func TestIsValid(t *testing.T) { 6 | s := "" 7 | if ok := isValid(s); !ok { 8 | t.Fatalf("test failed: %s", s) 9 | } 10 | 11 | s = "{{(){}[]}}" 12 | if ok := isValid(s); !ok { 13 | t.Fatalf("test failed: %s", s) 14 | } 15 | 16 | s = "{{(){}[]}}}" 17 | if ok := isValid(s); ok { 18 | t.Fatalf("test failed: %s", s) 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /go/stack/verify-preorder-serialization-of-a-binary-tree.go: -------------------------------------------------------------------------------- 1 | package stack 2 | 3 | import "strings" 4 | 5 | func isValidSerialization(preorder string) bool { 6 | arrs := strings.Split(preorder, ",") 7 | slots := 1 8 | 9 | for _, val := range arrs { 10 | slots-- 11 | if slots < 0 { 12 | return false 13 | } 14 | 15 | if val != "#" { 16 | slots += 2 17 | } 18 | } 19 | 20 | return slots == 0 21 | } 22 | 23 | -------------------------------------------------------------------------------- /go/stack/verify-preorder-serialization-of-a-binary-tree_test.go: -------------------------------------------------------------------------------- 1 | package stack 2 | 3 | import "testing" 4 | 5 | func TestIsValidSerialization(t *testing.T) { 6 | preorder := "9,3,4,#,#,1,#,#,2,#,6,#,#" 7 | if !isValidSerialization(preorder) { 8 | t.Fatalf("test failed") 9 | } 10 | 11 | preorder = "1,#" 12 | if isValidSerialization(preorder) { 13 | t.Fatalf("test failed") 14 | } 15 | 16 | preorder = "9,#,#,1" 17 | if isValidSerialization(preorder) { 18 | t.Fatalf("test failed") 19 | } 20 | 21 | preorder = "9,3,4,#,#,1,#,#,#,2,#,6,#,#" 22 | if isValidSerialization(preorder) { 23 | t.Fatalf("test failed") 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /go/tree/binary_tree_level_order_traversal/code1.go: -------------------------------------------------------------------------------- 1 | package binarytree 2 | 3 | func levelOrder(root *TreeNode) (result [][]int) { 4 | if root == nil { 5 | return 6 | } 7 | 8 | q := []*TreeNode{root} 9 | 10 | for len(q) > 0 { 11 | var p []*TreeNode 12 | arr := make([]int, 0) 13 | for _, node := range q { 14 | arr = append(arr, node.Val) 15 | if node.Left != nil { 16 | p = append(p, node.Left) 17 | } 18 | if node.Right != nil { 19 | p = append(p, node.Right) 20 | } 21 | } 22 | result = append(result, arr) 23 | q = p 24 | } 25 | 26 | return 27 | } 28 | -------------------------------------------------------------------------------- /go/tree/binary_tree_level_order_traversal/code_test.go: -------------------------------------------------------------------------------- 1 | package binarytree 2 | 3 | import "testing" 4 | 5 | func TestLevelOrder(t *testing.T) { 6 | root := &TreeNode{ 7 | Val: 1, 8 | } 9 | left := &TreeNode{ 10 | Val: 2, 11 | Left: &TreeNode{ 12 | Val: 4, 13 | }, 14 | } 15 | right := &TreeNode{ 16 | Val: 3, 17 | } 18 | 19 | root.Left = left 20 | root.Right = right 21 | 22 | result := levelOrder(root) 23 | t.Logf("%v", result) 24 | } 25 | -------------------------------------------------------------------------------- /go/tree/binary_tree_pruning/code.go: -------------------------------------------------------------------------------- 1 | package binarytreepruning 2 | 3 | type TreeNode struct { 4 | Val int 5 | Left *TreeNode 6 | Right *TreeNode 7 | } 8 | 9 | func pruneTree(root *TreeNode) *TreeNode { 10 | if root == nil { 11 | return nil 12 | } 13 | 14 | root.Left = pruneTree(root.Left) 15 | root.Right = pruneTree(root.Right) 16 | if root.Left == nil && root.Right == nil && root.Val == 0 { 17 | return nil 18 | } 19 | 20 | return root 21 | } 22 | -------------------------------------------------------------------------------- /go/tree/invert_binary_tree/code.go: -------------------------------------------------------------------------------- 1 | package invertbinarytree 2 | 3 | type TreeNode struct { 4 | Val int 5 | Left *TreeNode 6 | Right *TreeNode 7 | } 8 | 9 | func invertTree(root *TreeNode) *TreeNode { 10 | if root == nil { 11 | return nil 12 | } 13 | left := invertTree(root.Left) 14 | right := invertTree(root.Right) 15 | 16 | root.Left = right 17 | root.Right = left 18 | 19 | return root 20 | } 21 | -------------------------------------------------------------------------------- /go/tree/lowest_common_ancestor/code.go: -------------------------------------------------------------------------------- 1 | package lowestcommonancestor 2 | 3 | type TreeNode struct { 4 | Val int 5 | Left *TreeNode 6 | Right *TreeNode 7 | } 8 | 9 | func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode { 10 | if root == nil || root == p || root == q { 11 | return root 12 | } 13 | 14 | left := lowestCommonAncestor(root.Left, p, q) 15 | right := lowestCommonAncestor(root.Right, p, q) 16 | if left != nil && right != nil { 17 | return root 18 | } 19 | 20 | if left != nil { 21 | return left 22 | } 23 | 24 | return right 25 | } 26 | -------------------------------------------------------------------------------- /misc/3sum-closest.c: -------------------------------------------------------------------------------- 1 | int threeSumClosest(int* nums, int numsSize, int target) { 2 | int i,j,k; 3 | int m,sum,ab; 4 | m = INT_MAX; 5 | for(i = 0; i < numsSize; ++i) 6 | for(j = i + 1; j < numsSize; ++j) 7 | for(k = j + 1; k < numsSize; ++k){ 8 | ab = abs(nums[i]+ nums[j] + nums[k] - target); 9 | if(ab < m){ 10 | m = ab; 11 | sum = nums[i] + nums[j] + nums[k]; 12 | } 13 | if(ab == 0) 14 | return sum; 15 | } 16 | 17 | return sum; 18 | } 19 | -------------------------------------------------------------------------------- /misc/README.md: -------------------------------------------------------------------------------- 1 | # leetcode 2 | the algorithm codes of LeetCode OJ(https://leetcode.com/problemset/algorithms/) 3 | 4 | those codes are mostly implemented by C languages 5 | 6 | -------------------------------------------------------------------------------- /misc/best-time-to-buy-and-sell-stock-ii.c: -------------------------------------------------------------------------------- 1 | int maxProfit(int* prices, int pricesSize) { 2 | int i; 3 | int ret = 0; 4 | 5 | for(i = 1; i < pricesSize; ++i){ 6 | if(prices[i] > prices[i-1]) 7 | ret += prices[i] - prices[i-1]; 8 | } 9 | 10 | return ret; 11 | } 12 | -------------------------------------------------------------------------------- /misc/best-time-to-buy-and-sell-stock.c: -------------------------------------------------------------------------------- 1 | int maxProfit(int prices[], int n){ 2 | int i,min,profit; 3 | min = prices[0]; 4 | profit = 0; 5 | for(i = 0; i < n; ++i){ 6 | if(prices[i] - min > profit) 7 | profit = prices[i] - min; 8 | if(prices[i] < min) 9 | min = prices[i]; 10 | } 11 | return profit; 12 | } 13 | -------------------------------------------------------------------------------- /misc/bitwise-and-of-numbers-range.c: -------------------------------------------------------------------------------- 1 | #define BIT(num,bit) (num & (1 << bit)) 2 | 3 | int rangeBitwiseAnd(int m, int n) { 4 | int bit = 0; 5 | int i; 6 | for(i = 31; i >= 0; --i){ 7 | if(BIT(n,i)) 8 | break; 9 | } 10 | while(i >= 0){ 11 | if(BIT(m,i) != BIT(n,i)) 12 | break; 13 | if(BIT(m,i)) 14 | bit |= (1 << i); 15 | i--; 16 | } 17 | return bit; 18 | } 19 | -------------------------------------------------------------------------------- /misc/bitwise-and-of-numbers-range[2].c: -------------------------------------------------------------------------------- 1 | int rangeBitwiseAnd(int m, int n) { 2 | int i = 0; 3 | while(m != n){ 4 | m >>= 1; 5 | n >>= 1; 6 | i++; 7 | } 8 | return (m << i); 9 | } 10 | -------------------------------------------------------------------------------- /misc/climbing-stairs.c: -------------------------------------------------------------------------------- 1 | int climbStairs(int n) { 2 | int dp[n+1]; 3 | int i; 4 | dp[0] = 0; 5 | 6 | if(n == 1) 7 | return 1; 8 | else if(n == 2) 9 | return 2; 10 | 11 | dp[1] = 1; 12 | dp[2] = 2; 13 | for(i=3; i <= n; ++i) 14 | dp[i] = dp[i-1] + dp[i-2]; 15 | 16 | return dp[n]; 17 | } 18 | -------------------------------------------------------------------------------- /misc/combinations.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | void rec(vector > &vret, vector &vt, 4 | int l,int p, int n, int k) 5 | { 6 | if(l == k){ 7 | vret.push_back(vt); 8 | }else{ 9 | for(int i = p; i <= n; ++i){ 10 | vt.push_back(i); 11 | rec(vret,vt,l+1,i+1,n,k); 12 | vt.pop_back(); 13 | } 14 | } 15 | } 16 | vector> combine(int n, int k) { 17 | vector > vret; 18 | vector vt; 19 | rec(vret,vt,0,1,n,k); 20 | 21 | return vret; 22 | } 23 | }; 24 | -------------------------------------------------------------------------------- /misc/container-with-most-water.c: -------------------------------------------------------------------------------- 1 | int maxArea(int* height, int heightSize) { 2 | int i,j; 3 | int area = INT_MIN; 4 | int min_height; 5 | int tmp; 6 | 7 | i = 0; 8 | j = heightSize - 1; 9 | while(i < j){ 10 | min_height = height[i] < height[j] ? height[i] : height[j]; 11 | tmp = min_height * (j - i); 12 | if( tmp > area) 13 | area = tmp; 14 | 15 | if(height[i] > height[j]) 16 | j--; 17 | else 18 | i++; 19 | } 20 | 21 | return area; 22 | } 23 | -------------------------------------------------------------------------------- /misc/contains-duplicate-ii.c: -------------------------------------------------------------------------------- 1 | bool containsNearbyDuplicate(int* nums, int numsSize, int k) { 2 | int i,j; 3 | for(i = 0; i < numsSize; ++i) 4 | for(j = i; j <= i+k && j < numsSize; ++j){ 5 | if(i != j && nums[i] == nums[j]) 6 | return true; 7 | } 8 | 9 | return false; 10 | } 11 | -------------------------------------------------------------------------------- /misc/contains-duplicate-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool containsNearbyDuplicate(vector& nums, int k) { 4 | map m; 5 | int len = nums.size(); 6 | for(int i = 0; i < len; ++i){ 7 | if(m.find(nums[i]) != m.end() && i-m[nums[i]] <= k) 8 | return true; 9 | m[nums[i]] = i; 10 | } 11 | return false; 12 | } 13 | }; 14 | -------------------------------------------------------------------------------- /misc/contains-duplicate-iii.c: -------------------------------------------------------------------------------- 1 | bool containsNearbyAlmostDuplicate(int* nums, int numsSize, int k, int t) { 2 | int i,j; 3 | 4 | for(i = 0; i < numsSize; ++i){ 5 | for(j = i;j < numsSize && j <= i + k; ++j) 6 | if(i != j && labs(nums[j] - nums[i]) <= t) 7 | return true; 8 | } 9 | 10 | return false; 11 | } 12 | -------------------------------------------------------------------------------- /misc/contains-duplicate.c: -------------------------------------------------------------------------------- 1 | tatic int cmp(const void *a, const void *b) 2 | { 3 | return *(int *)a - *(int *)b; 4 | } 5 | bool containsDuplicate(int* nums, int numsSize) { 6 | int i; 7 | qsort(nums,numsSize,sizeof(int),cmp); 8 | i = 1; 9 | while(i < numsSize){ 10 | if(nums[i] == nums[i-1]) 11 | return true; 12 | ++i; 13 | } 14 | return false; 15 | } 16 | -------------------------------------------------------------------------------- /misc/count-primes.c: -------------------------------------------------------------------------------- 1 | int countPrimes(int n) { 2 | int *prime; 3 | int count = 0; 4 | prime = (int *)malloc(sizeof(int) * n); 5 | memset(prime,0,sizeof(int) * n); 6 | int i,j; 7 | for(i = 2; i < n; ++i){ 8 | if(!prime[i]){ 9 | count++; 10 | j = 2; 11 | while(j * i < n){ 12 | prime[j*i] = 1; 13 | j++; 14 | } 15 | } 16 | } 17 | return count; 18 | } 19 | -------------------------------------------------------------------------------- /misc/count-primes.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int countPrimes(int n) { 4 | bool *prime = new bool[n]; 5 | int i,j; 6 | int count = 0; 7 | for(i = 2; i < n; ++i){ 8 | if(!prime[i]){ 9 | count++; 10 | j = 2; 11 | while(i * j < n){ 12 | prime[i * j] = 1; 13 | j++; 14 | } 15 | } 16 | } 17 | return count; 18 | } 19 | }; 20 | -------------------------------------------------------------------------------- /misc/decode-ways.c: -------------------------------------------------------------------------------- 1 | int numDecodings(char *s) { 2 | int i,len; 3 | //int *dp = NULL; 4 | int dp[5000]; 5 | len = strlen(s); 6 | 7 | //dp = (int *)malloc(sizeof(int) * (len+1)); 8 | //if(dp == NULL) 9 | // return len; 10 | dp[len-1] = s[len-1] == '0' ? 0 : 1; 11 | dp[len] = 1; 12 | 13 | for(i = len-2; i >= 0; --i){ 14 | if(s[i] == '0') 15 | dp[i] = 0; 16 | else if(((s[i] - '0') * 10 + (s[i+1] - '0')) > 26) 17 | dp[i] = dp[i+1]; 18 | else 19 | dp[i] = dp[i+1] + dp[i+2]; 20 | } 21 | return dp[0]; 22 | } 23 | -------------------------------------------------------------------------------- /misc/delete-node-in-a-linked-list.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * struct ListNode *next; 6 | * }; 7 | */ 8 | void deleteNode(struct ListNode* node) { 9 | node->val = node->next->val; 10 | node->next = node->next->next; 11 | } 12 | -------------------------------------------------------------------------------- /misc/excel-sheet-column-number.c: -------------------------------------------------------------------------------- 1 | int titleToNumber(char *s) { 2 | int ret = 0; 3 | int len; 4 | int i = 0; 5 | len = strlen(s); 6 | while(i < len){ 7 | ret = ret * 26 + s[i] - 'A' + 1; 8 | i++; 9 | } 10 | return ret; 11 | } 12 | -------------------------------------------------------------------------------- /misc/excel-sheet-column-title.c: -------------------------------------------------------------------------------- 1 | char *convertToTitle(int n) { 2 | int i = 0; 3 | char *ret = (char *)malloc(sizeof(char) * 15); 4 | i = 14; 5 | ret[i--] = '\0'; 6 | while(n){ 7 | ret[i--] = (n-1) % 26 + 'A'; 8 | n = (n-1)/26; 9 | } 10 | 11 | return ret+i+1; 12 | } 13 | -------------------------------------------------------------------------------- /misc/factorial-trailing-zeroes.c: -------------------------------------------------------------------------------- 1 | int trailingZeroes(int n) { 2 | int ret = 0; 3 | while(n){ 4 | ret += n/5; 5 | n /= 5; 6 | } 7 | return ret; 8 | } 9 | -------------------------------------------------------------------------------- /misc/find-minimum-in-rotated-sorted-array-ii.c: -------------------------------------------------------------------------------- 1 | int findMin(int num[], int n) { 2 | int mid,begin,end; 3 | begin = 0; 4 | end = n - 1; 5 | while(begin <= end){ 6 | mid = (begin + end) / 2; 7 | if(mid -1 >= 0 && num[mid] < num[mid - 1]) 8 | return num[mid]; 9 | else if(num[mid] > num[end]) 10 | begin = mid + 1; 11 | else if(num[mid] < num[end]) 12 | end = mid - 1; 13 | else 14 | end--; 15 | } 16 | 17 | return num[0]; 18 | } 19 | -------------------------------------------------------------------------------- /misc/find-minimum-in-rotated-sorted-array.c: -------------------------------------------------------------------------------- 1 | int findMin(int num[], int n) { 2 | int beg = 0; 3 | int end = n - 1; 4 | int mid = 0; 5 | while(beg < end){ 6 | mid = (beg + end) / 2; 7 | if(num[mid] > num[mid + 1]) 8 | return num[mid + 1]; 9 | if(num[mid] > num[beg]) 10 | beg = mid + 1; 11 | else 12 | end = mid; 13 | } 14 | return num[0]; 15 | } 16 | -------------------------------------------------------------------------------- /misc/find-peak-element.c: -------------------------------------------------------------------------------- 1 | int findPeakElement(int num[], int n) { 2 | int i = 0; 3 | while(i < n-1){ 4 | if(num[i] > num[i+1]) 5 | return i; 6 | else 7 | i++; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /misc/find-peak-element[2].c: -------------------------------------------------------------------------------- 1 | int findPeakElement(int num[], int n) { 2 | int begin = 0; 3 | int end = n-1; 4 | int mid = 0; 5 | while(begin < end){ 6 | mid = (begin + end) / 2; 7 | if(num[mid] < num[mid+1]) 8 | begin = mid+1; 9 | else 10 | end = mid; 11 | } 12 | return begin; 13 | } 14 | -------------------------------------------------------------------------------- /misc/first-missing-positive.c: -------------------------------------------------------------------------------- 1 | static void swap(int *a, int *b) 2 | { 3 | *a ^= *b; 4 | *b ^= *a; 5 | *a ^= *b; 6 | } 7 | int firstMissingPositive(int* nums, int numsSize) { 8 | int i; 9 | for(i = 0; i < numsSize;){ 10 | if(nums[i] <= 0 || nums[i] == i + 1 || 11 | nums[i] > numsSize || nums[i] == nums[nums[i]-1]) 12 | i++; 13 | else 14 | swap(&nums[i],&nums[nums[i]-1]); 15 | } 16 | 17 | for(i = 0; i < numsSize; ++i) 18 | if(nums[i] != i+1) 19 | break; 20 | return i + 1; 21 | } 22 | -------------------------------------------------------------------------------- /misc/gas-station.c: -------------------------------------------------------------------------------- 1 | int canCompleteCircuit(int* gas, int gasSize, int* cost, int costSize) { 2 | int i; 3 | int cur = 0; 4 | int ret = 0; 5 | int sum = 0; 6 | 7 | for(i = 0; i < gasSize; ++i){ 8 | cur += gas[i] - cost[i]; 9 | sum += gas[i] - cost[i]; 10 | if(cur < 0){ 11 | cur = 0; 12 | ret = i+1; 13 | } 14 | } 15 | 16 | return sum < 0 ? -1 : ret; 17 | } 18 | -------------------------------------------------------------------------------- /misc/generate-parentheses.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector generateParenthesis(int n) { 4 | string s; 5 | vector v; 6 | recursive(n,n,s,v); 7 | return v; 8 | } 9 | void recursive(int left,int right,string s,vector &v){ 10 | if(left == 0 && right == 0){ 11 | v.push_back(s); 12 | return ; 13 | } 14 | if(left > 0){ 15 | recursive(left-1,right,s+'(',v); 16 | } 17 | if(right > 0 && right > left){ 18 | recursive(left,right-1,s+')',v); 19 | } 20 | } 21 | }; 22 | -------------------------------------------------------------------------------- /misc/happy-number.c: -------------------------------------------------------------------------------- 1 | bool isHappy(int n) { 2 | int prev; 3 | int tmp; 4 | int result = 0; 5 | int count = 0; 6 | do{ 7 | if(count++ == 20) 8 | break; 9 | prev = n; 10 | result = 0; 11 | while(n){ 12 | tmp = n % 10; 13 | n /= 10; 14 | result += (tmp * tmp); 15 | } 16 | n = result; 17 | if(n == 1) 18 | return true; 19 | }while(prev != n); 20 | 21 | return false; 22 | } 23 | -------------------------------------------------------------------------------- /misc/happy-number[2].c: -------------------------------------------------------------------------------- 1 | //if n is not happy, there always 4 in cycle 2 | bool isHappy(int n) { 3 | int result = 0; 4 | int magic = 4; 5 | 6 | do{ 7 | if(n == magic) 8 | break; 9 | result = 0; 10 | while(n){ 11 | result += ((n%10) * (n%10)); 12 | n /= 10; 13 | } 14 | n = result; 15 | if(n == 1) 16 | return true; 17 | }while(n); 18 | 19 | return false; 20 | } 21 | -------------------------------------------------------------------------------- /misc/happy-number[3].c: -------------------------------------------------------------------------------- 1 | bool isHappy(int n) { 2 | int *flag; 3 | int result; 4 | 5 | flag = (int *)malloc(sizeof(int) * 1000); 6 | memset(flag,0,sizeof(int) * 1000); 7 | 8 | while(n){ 9 | result = 0; 10 | while(n){ 11 | result += ((n%10) * (n%10)); 12 | n /= 10; 13 | } 14 | n = result; 15 | if(flag[n]) 16 | break; 17 | flag[n] = 1; 18 | if(n == 1) 19 | return true; 20 | } 21 | return false; 22 | } 23 | -------------------------------------------------------------------------------- /misc/house-robber.c: -------------------------------------------------------------------------------- 1 | int rob(int num[], int n) { 2 | int *dp; 3 | int i,ret; 4 | dp = (int *)malloc(sizeof(int) * (n+1)); 5 | dp[0] = 0; 6 | dp[1] = num[0]; 7 | for(i = 2; i <= n; ++i) 8 | dp[i] = (dp[i-1] > (dp[i-2] + num[i-1])) ? 9 | dp[i-1] : dp[i-2] + num[i-1]; 10 | ret = dp[n]; 11 | 12 | free(dp); 13 | return ret; 14 | } 15 | -------------------------------------------------------------------------------- /misc/implement-strstr.c: -------------------------------------------------------------------------------- 1 | int strStr(char* haystack, char* needle) { 2 | int jump[256]; 3 | int nd_len = strlen(needle); 4 | int ht_len = strlen(haystack); 5 | int i,j; 6 | 7 | for(i = 0; i < 256; ++i) 8 | jump[i] = nd_len + 1; 9 | 10 | for(i = 0; i < nd_len; ++i) 11 | jump[needle[i]] = nd_len - i; 12 | 13 | for(i = 0; i <= ht_len - nd_len; i += jump[haystack[i+nd_len]]){ 14 | j = 0; 15 | while(j < nd_len && needle[j] == haystack[i+j]) 16 | ++j; 17 | 18 | if(j == nd_len) 19 | return i; 20 | } 21 | 22 | return -1; 23 | } 24 | -------------------------------------------------------------------------------- /misc/intersection-of-two-linked-lists.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * struct ListNode *next; 6 | * }; 7 | */ 8 | struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) { 9 | struct ListNode *la,*lb; 10 | la = headA; 11 | lb = headB; 12 | while(la && lb){ 13 | if(la->val > lb->val) 14 | lb = lb->next; 15 | else if(la->val < lb->val) 16 | la = la->next; 17 | else 18 | return la; 19 | } 20 | return NULL; 21 | } 22 | -------------------------------------------------------------------------------- /misc/invert-binary-tree.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * struct TreeNode *left; 6 | * struct TreeNode *right; 7 | * }; 8 | */ 9 | struct TreeNode* invertTree(struct TreeNode* root) { 10 | if(!root) 11 | return NULL; 12 | 13 | struct TreeNode *tmp; 14 | tmp = root->left; 15 | root->left = invertTree(root->right); 16 | root->right = invertTree(tmp); 17 | 18 | return root; 19 | } 20 | -------------------------------------------------------------------------------- /misc/isomorphic-strings.c: -------------------------------------------------------------------------------- 1 | bool isIsomorphic(char* s, char* t) { 2 | int flag[256],visited[256]; 3 | int i,len; 4 | len = strlen(s); 5 | 6 | memset(flag,0,sizeof(int) * 256); 7 | memset(visited,0,sizeof(int) * 256); 8 | 9 | for(i = 0; i < len; ++i){ 10 | if(flag[s[i]] == 0){ 11 | if(visited[t[i]]) 12 | return false; 13 | 14 | flag[s[i]] = t[i]; 15 | visited[t[i]] = 1; 16 | }else if(flag[s[i]] != t[i]){ 17 | return false; 18 | } 19 | } 20 | return true; 21 | } 22 | -------------------------------------------------------------------------------- /misc/jump-game-ii.c: -------------------------------------------------------------------------------- 1 | int jump(int* nums, int numsSize) { 2 | int i,cur_pos,max_pos; 3 | int ret; 4 | 5 | ret = 0; 6 | cur_pos = 0; 7 | max_pos = 0; 8 | 9 | for(i = 0; i < numsSize; ++i){ 10 | if(cur_pos < i){ 11 | ret++; 12 | cur_pos = max_pos; 13 | } 14 | max_pos = nums[i]+i > max_pos ? nums[i]+i : max_pos; 15 | } 16 | 17 | return ret; 18 | } 19 | -------------------------------------------------------------------------------- /misc/jump-game.c: -------------------------------------------------------------------------------- 1 | bool canJump(int A[], int n) { 2 | int beg,end,max_jump,i; 3 | beg = 0; 4 | end = A[0]; 5 | while(end < n-1){ 6 | max_jump = end; 7 | for(i = beg; i <= end; ++i){ 8 | if(max_jump < (i+A[i])) 9 | max_jump = i + A[i]; 10 | } 11 | if(max_jump == end) 12 | break; 13 | beg = end; 14 | end = max_jump; 15 | } 16 | if(end < n - 1) 17 | return false; 18 | return true; 19 | } 20 | -------------------------------------------------------------------------------- /misc/jump-game[2].c: -------------------------------------------------------------------------------- 1 | bool canJump(int* nums, int numsSize) { 2 | int i,max_pos; 3 | 4 | max_pos = 0; 5 | for(i = 0; i < numsSize; ++i){ 6 | max_pos = nums[i]+i > max_pos ? nums[i]+i : max_pos; 7 | if(max_pos <= i) 8 | break; 9 | } 10 | 11 | if(max_pos >= (numsSize-1)) 12 | return true; 13 | return false; 14 | } 15 | -------------------------------------------------------------------------------- /misc/kth-largest-element-in-an-array.c: -------------------------------------------------------------------------------- 1 | static int cmp(const int *a, const int *b) 2 | { 3 | return *(int *)b - *(int *)a; 4 | } 5 | int findKthLargest(int* nums, int numsSize, int k) { 6 | qsort(nums,numsSize,sizeof(int),cmp); 7 | return nums[k-1]; 8 | } 9 | -------------------------------------------------------------------------------- /misc/largest-number.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | static bool cmp(const int a, const int b) 4 | { 5 | return to_string(a) + to_string(b) > to_string(b) + to_string(a); 6 | } 7 | string largestNumber(vector &num) { 8 | sort(num.begin(),num.end(),cmp); 9 | string ret; 10 | int len = num.size(); 11 | for(int i = 0; i < len; ++i) 12 | ret += to_string(num[i]); 13 | 14 | return ret[0] == '0' ? "0" : ret; 15 | } 16 | }; 17 | -------------------------------------------------------------------------------- /misc/length-of-last-word.c: -------------------------------------------------------------------------------- 1 | int lengthOfLastWord(char *s) { 2 | int len = strlen(s); 3 | int i = len -1; 4 | int ret = 0; 5 | while(i >= 0 && s[i] == ' ') 6 | i--; 7 | while(i >= 0 && s[i] != ' '){ 8 | ret++; 9 | i--; 10 | } 11 | 12 | return ret; 13 | } 14 | -------------------------------------------------------------------------------- /misc/linked-list-cycle-ii.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * struct ListNode *next; 6 | * }; 7 | */ 8 | struct ListNode *detectCycle(struct ListNode *head) { 9 | while(head != NULL){ 10 | if(INT_MIN != head->val) 11 | head->val = INT_MIN; 12 | else 13 | return head; 14 | head = head->next; 15 | } 16 | return NULL; 17 | } 18 | -------------------------------------------------------------------------------- /misc/longest-common-prefix.c: -------------------------------------------------------------------------------- 1 | ar* longestCommonPrefix(char** strs, int strsSize) { 2 | if(strsSize == 0) 3 | return ""; 4 | int len0 = strlen(strs[0]); 5 | char *prefix = (char *)malloc(sizeof(char) * (len0 + 1)); 6 | memset(prefix,0,sizeof(char) * (len0 + 1)); 7 | int i,j; 8 | for(i = 0; i < len0; ++i){ 9 | for(j = 1; j < strsSize; ++j) 10 | if(strs[j][i] != strs[0][i]) 11 | break; 12 | if(j != strsSize) 13 | break; 14 | prefix[i] = strs[0][i]; 15 | } 16 | 17 | return prefix; 18 | } 19 | -------------------------------------------------------------------------------- /misc/longest-consecutive-sequence.c: -------------------------------------------------------------------------------- 1 | static int cmp(const void *a, const void *b) 2 | { 3 | return *(int *)a - *(int *)b; 4 | } 5 | int longestConsecutive(int* nums, int numsSize) { 6 | int max = 1; 7 | int i; 8 | int cur = 1; 9 | qsort(nums,numsSize,sizeof(int),cmp); 10 | for(i = 1; i < numsSize; ++i){ 11 | if(nums[i] == nums[i-1]+1){ 12 | cur++; 13 | if(cur > max) 14 | max = cur; 15 | }else if(nums[i] != nums[i-1]){ 16 | cur = 1; 17 | } 18 | } 19 | return max; 20 | } 21 | -------------------------------------------------------------------------------- /misc/longest-substring-without-repeating-characters.c: -------------------------------------------------------------------------------- 1 | int lengthOfLongestSubstring(char* s) { 2 | int len = strlen(s); 3 | int max = 0; 4 | int flag[256]; 5 | int i,j; 6 | 7 | for(i = 0; i < len; ++i){ 8 | memset(flag,0,sizeof(int) * 256); 9 | j = 0; 10 | while(i+j < len && !flag[s[i+j]]){ 11 | flag[s[i+j]] = 1; 12 | j++; 13 | if(j > max) 14 | max = j; 15 | } 16 | } 17 | 18 | return max; 19 | } 20 | -------------------------------------------------------------------------------- /misc/longest-substring-without-repeating-characters[2].c: -------------------------------------------------------------------------------- 1 | int lengthOfLongestSubstring(char* s) { 2 | int index[256]; 3 | int i = 0; 4 | int len = strlen(s); 5 | int last_pos = -1,longest = 0; 6 | 7 | memset(index,0,sizeof(int)*256); 8 | 9 | for(i = 0; i < len; ++i){ 10 | last_pos = index[s[i]] > last_pos ? index[s[i]] : last_pos; 11 | index[s[i]] = i+1; 12 | longest = i - last_pos + 1 > longest ? i - last_pos + 1 : longest; 13 | } 14 | 15 | return longest; 16 | } 17 | -------------------------------------------------------------------------------- /misc/lowest-common-ancestor-of-a-binary-search-tree[1].c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * struct TreeNode *left; 6 | * struct TreeNode *right; 7 | * }; 8 | */ 9 | struct TreeNode* lowestCommonAncestor(struct TreeNode* root, struct TreeNode* p, struct TreeNode* q) { 10 | if(root->val > p->val && root->val > q->val) 11 | return lowestCommonAncestor(root->left,p,q); 12 | if(root->val < p->val && root->val < q->val) 13 | return lowestCommonAncestor(root->right,p,q); 14 | 15 | return root; 16 | } 17 | -------------------------------------------------------------------------------- /misc/lowest-common-ancestor-of-a-binary-tree.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * struct TreeNode *left; 6 | * struct TreeNode *right; 7 | * }; 8 | */ 9 | struct TreeNode* lowestCommonAncestor(struct TreeNode* root, struct TreeNode* p, struct TreeNode* q) { 10 | if(!root || root == p || root == q) 11 | return root; 12 | 13 | struct TreeNode *left = lowestCommonAncestor(root->left,p,q); 14 | struct TreeNode *right = lowestCommonAncestor(root->right,p,q); 15 | 16 | if(left && right) 17 | return root; 18 | 19 | return left ? left : right; 20 | } 21 | -------------------------------------------------------------------------------- /misc/majority-element.c: -------------------------------------------------------------------------------- 1 | int majorityElement(int num[], int n) { 2 | int ret,count,i; 3 | count = 0; 4 | for(i = 0; i < n; ++i){ 5 | if(count == 0) 6 | ret = num[i]; 7 | if(ret == num[i]) 8 | count++; 9 | else 10 | count--; 11 | } 12 | return ret; 13 | } 14 | -------------------------------------------------------------------------------- /misc/majority-element[2].c: -------------------------------------------------------------------------------- 1 | int cmp(const void *a, const void *b) 2 | { 3 | return *(int *)a - *(int *)b; 4 | } 5 | int majorityElement(int num[], int n) { 6 | qsort(num,n,sizeof(int),cmp); 7 | return num[n/2]; 8 | } 9 | -------------------------------------------------------------------------------- /misc/maximum-depth-of-binary-tree.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * struct TreeNode *left; 6 | * struct TreeNode *right; 7 | * }; 8 | */ 9 | int maxDepth(struct TreeNode *root) { 10 | int lc,rc; 11 | if(root == NULL) 12 | return 0; 13 | lc = maxDepth(root->left); 14 | rc = maxDepth(root->right); 15 | 16 | return lc > rc ? lc + 1 : rc + 1; 17 | } 18 | -------------------------------------------------------------------------------- /misc/maximum-gap.c: -------------------------------------------------------------------------------- 1 | static int cmp(const void *a,const void *b) 2 | { 3 | return *(int *)a - *(int *)b; 4 | } 5 | int maximumGap(int num[], int n) { 6 | int *arr; 7 | int i,j; 8 | int max = 0; 9 | 10 | qsort(num,n,sizeof(int),cmp); 11 | for(i = 0; i < n-1; ++i) 12 | if(abs(num[i+1] - num[i]) > max) 13 | max = abs(num[i+1] - num[i]); 14 | 15 | return max; 16 | } 17 | -------------------------------------------------------------------------------- /misc/maximum-subarray.c: -------------------------------------------------------------------------------- 1 | int maxSubArray(int A[], int n) { 2 | int max,tmp,i; 3 | max = A[0]; 4 | tmp = 0; 5 | for(i = 0;i < n; ++i){ 6 | tmp += A[i]; 7 | if(tmp > max) 8 | max = tmp; 9 | if(tmp < 0) 10 | tmp = 0; 11 | } 12 | return max; 13 | } 14 | -------------------------------------------------------------------------------- /misc/merge-sorted-array.c: -------------------------------------------------------------------------------- 1 | void merge(int A[], int m, int B[], int n) { 2 | int i,j; 3 | int cnt = 0; 4 | i = m + n -1; 5 | for(j = m-1; j >= 0; --j,--i) 6 | A[i] = A[j]; 7 | i++; 8 | j = 0; 9 | while(j < n && i < m + n){ 10 | if(A[i] <= B[j]) 11 | A[cnt] = A[i++]; 12 | else 13 | A[cnt] = B[j++]; 14 | cnt++; 15 | } 16 | while(j < n) 17 | A[cnt++] = B[j++]; 18 | while(i < m + n) 19 | A[cnt++] = A[i++]; 20 | } 21 | -------------------------------------------------------------------------------- /misc/merge-sorted-array[2].c: -------------------------------------------------------------------------------- 1 | void merge(int A[], int m, int B[], int n) { 2 | int i,j,k; 3 | i = m - 1; 4 | j = n - 1; 5 | k = m + n -1; 6 | while(i >= 0 && j >= 0) 7 | A[k--] = A[i] > B[j] ? A[i--] : B[j--]; 8 | 9 | while(j >= 0) 10 | A[k--] = B[j--]; 11 | } 12 | -------------------------------------------------------------------------------- /misc/min-stack.cpp: -------------------------------------------------------------------------------- 1 | class MinStack { 2 | public: 3 | stack st; 4 | stack st_min; 5 | void push(int x) { 6 | st.push(x); 7 | if(st_min.empty() || x <= st_min.top()) 8 | st_min.push(x); 9 | } 10 | 11 | void pop() { 12 | if(st.top() <= st_min.top()) 13 | st_min.pop(); 14 | st.pop(); 15 | } 16 | 17 | int top() { 18 | return st.top(); 19 | } 20 | 21 | int getMin() { 22 | return st_min.top(); 23 | } 24 | }; 25 | -------------------------------------------------------------------------------- /misc/minimum-depth-of-binary-tree.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * struct TreeNode *left; 6 | * struct TreeNode *right; 7 | * }; 8 | */ 9 | int minDepth(struct TreeNode *root) { 10 | int lc,rc; 11 | if(root == NULL) 12 | return 0; 13 | if(root->left == NULL && root->right == NULL) 14 | return 1; 15 | lc = minDepth(root->left); 16 | rc = minDepth(root->right); 17 | if(root->left == NULL || root->right == NULL) 18 | return root->left ? lc + 1 : rc + 1; 19 | return lc < rc ? lc + 1 : rc + 1; 20 | } 21 | -------------------------------------------------------------------------------- /misc/minimum-size-subarray-sum.c: -------------------------------------------------------------------------------- 1 | int minSubArrayLen(int s, int* nums, int numsSize) { 2 | int ret = numsSize + 1; 3 | int i,j; 4 | int sum = 0; 5 | i = j = 0; 6 | 7 | while(j < numsSize){ 8 | sum += nums[j]; 9 | while(sum >= s){ 10 | if(j - i + 1 < ret) 11 | ret = j - i + 1; 12 | sum -= nums[i]; 13 | i++; 14 | } 15 | j++; 16 | } 17 | 18 | return (ret == (numsSize + 1)) ? 0 : ret; 19 | } 20 | -------------------------------------------------------------------------------- /misc/number-of-1-bits.c: -------------------------------------------------------------------------------- 1 | int hammingWeight(uint32_t n) { 2 | int ret = 0; 3 | while(n){ 4 | ret += (n & 1); 5 | n = n >> 1; 6 | } 7 | 8 | return ret; 9 | } 10 | -------------------------------------------------------------------------------- /misc/number-of-digit-one.c: -------------------------------------------------------------------------------- 1 | int countDigitOne(int n) { 2 | int ret = 0; 3 | long m; 4 | 5 | for(m = 1; m <= n; m *= 10){ 6 | long a = n / m; 7 | long b = n % m; 8 | ret += (a + 8) / 10 * m; 9 | if(a % 10 == 1) 10 | ret += (b + 1); 11 | } 12 | 13 | return ret; 14 | } 15 | -------------------------------------------------------------------------------- /misc/palindrome-number.c: -------------------------------------------------------------------------------- 1 | bool isPalindrome(int x) { 2 | int rev = 0; 3 | int tmp = x; 4 | 5 | if(x < 0) 6 | return false; 7 | 8 | while(tmp){ 9 | rev = rev * 10 + tmp % 10; 10 | tmp /= 10; 11 | } 12 | 13 | return rev == x; 14 | } 15 | -------------------------------------------------------------------------------- /misc/path-sum.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * struct TreeNode *left; 6 | * struct TreeNode *right; 7 | * }; 8 | */ 9 | bool hasPathSum(struct TreeNode *root, int sum) { 10 | if(!root) 11 | return false; 12 | if(root->val == sum && root->left == NULL 13 | && root->right == NULL) 14 | return true; 15 | 16 | return hasPathSum(root->left,sum - root->val) || 17 | hasPathSum(root->right,sum - root->val); 18 | } 19 | -------------------------------------------------------------------------------- /misc/plus-one.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector plusOne(vector &digits) { 4 | int n = digits.size(); 5 | int carry = 1; 6 | int i = n - 1; 7 | while(carry && i >= 0){ 8 | digits[i] += carry; 9 | carry = digits[i] / 10; 10 | digits[i] %= 10; 11 | i--; 12 | } 13 | if(carry){ 14 | digits.push_back(0); 15 | digits[0] = 1; 16 | } 17 | return digits; 18 | } 19 | }; 20 | -------------------------------------------------------------------------------- /misc/power-of-two.c: -------------------------------------------------------------------------------- 1 | bool isPowerOfTwo(int n) { 2 | int count = 0; 3 | 4 | while(n > 0){ 5 | count += (n & 0x1); 6 | n >>= 1; 7 | } 8 | 9 | return count == 1; 10 | } 11 | -------------------------------------------------------------------------------- /misc/powx-n.c: -------------------------------------------------------------------------------- 1 | double myPow(double x, int n) { 2 | int nagative = 0; 3 | double ret,tmp; 4 | if(n == 0) 5 | return 1; 6 | if(n == 1) 7 | return x; 8 | if(n < 0){ 9 | nagative = 1; 10 | n = -n; 11 | } 12 | tmp = myPow(x,n/2); 13 | ret = tmp * tmp; 14 | if(n % 2){ 15 | ret *= x; 16 | } 17 | if(nagative) 18 | ret = 1 / ret; 19 | return ret; 20 | } 21 | -------------------------------------------------------------------------------- /misc/powx-n[2].c: -------------------------------------------------------------------------------- 1 | double myPow(double x, int n) { 2 | double tmp; 3 | if(n == 0) 4 | return 1; 5 | tmp = myPow(x,n/2); 6 | if(n % 2) 7 | return n < 0 ? 1 / x * tmp * tmp : x * tmp * tmp; 8 | return tmp * tmp; 9 | } 10 | -------------------------------------------------------------------------------- /misc/rectangle-area.c: -------------------------------------------------------------------------------- 1 | int computeArea(int A, int B, int C, int D, int E, int F, int G, int H) { 2 | int ret = (C - A) * (D - B) + (G - E) * (H - F); 3 | int x0 = A > E ? A : E; 4 | int y0 = B > F ? B : F; 5 | int x1 = C < G ? C : G; 6 | int y1 = D < H ? D : H; 7 | 8 | if(x1 <= x0 || y1 <= y0) 9 | return ret; 10 | 11 | return ret - (x1 - x0) * (y1 - y0); 12 | } 13 | -------------------------------------------------------------------------------- /misc/regular-expression-matching.c: -------------------------------------------------------------------------------- 1 | bool isMatch(char* s, char* p) { 2 | if(*p == 0) 3 | return *s == 0; 4 | 5 | if(p[1] != '*') 6 | return ((*p == *s) || (*p == '.' && *s != 0)) 7 | && isMatch(s+1,p+1); 8 | 9 | while((*s == *p) || (*p == '.' && *s != 0)){ 10 | if(isMatch(s,p+2)) 11 | return true; 12 | s++; 13 | } 14 | 15 | return isMatch(s,p+2); 16 | } 17 | -------------------------------------------------------------------------------- /misc/remove-duplicates-from-sorted-array-ii.c: -------------------------------------------------------------------------------- 1 | int removeDuplicates(int A[], int n) { 2 | int ret = 1; 3 | int count = 1; 4 | int i; 5 | for(i = 1; i < n; ++i){ 6 | if(A[i] != A[i-1] || count == 1){ 7 | if(A[i] == A[i-1]) 8 | count = 2; 9 | else 10 | count = 1; 11 | A[ret++] = A[i]; 12 | continue; 13 | } 14 | count++; 15 | } 16 | return n ? ret : 0; 17 | } 18 | -------------------------------------------------------------------------------- /misc/remove-duplicates-from-sorted-array.c: -------------------------------------------------------------------------------- 1 | int removeDuplicates(int A[], int n) { 2 | int i,j; 3 | i = 0; 4 | j = 0; 5 | while(j < n){ 6 | A[i++] = A[j++]; 7 | while(j < n && A[j] == A[j-1]) 8 | ++j; 9 | } 10 | return i; 11 | } 12 | -------------------------------------------------------------------------------- /misc/remove-duplicates-from-sorted-array[2].c: -------------------------------------------------------------------------------- 1 | int removeDuplicates(int A[], int n) { 2 | int ret = 1; 3 | int i; 4 | for(i = 1; i < n; ++i){ 5 | if(A[i] != A[i-1]) 6 | A[ret++] = A[i]; 7 | } 8 | return n ? ret : 0; 9 | } 10 | -------------------------------------------------------------------------------- /misc/remove-duplicates-from-sorted-list.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * struct ListNode *next; 6 | * }; 7 | */ 8 | struct ListNode* deleteDuplicates(struct ListNode* head) { 9 | struct ListNode root; 10 | struct ListNode *prev; 11 | root.next = head; 12 | prev = head; 13 | while(prev && prev->next){ 14 | head = prev->next; 15 | if(prev->val == head->val){ 16 | prev->next = head->next; 17 | }else{ 18 | prev = prev->next; 19 | } 20 | } 21 | return root.next; 22 | } 23 | -------------------------------------------------------------------------------- /misc/remove-element.c: -------------------------------------------------------------------------------- 1 | int removeElement(int A[], int n, int elem) { 2 | int i,next; 3 | next = 0; 4 | for(i = 0; i < n; ++i) 5 | if(A[i] != elem) 6 | A[next++] = A[i]; 7 | 8 | return next; 9 | } 10 | -------------------------------------------------------------------------------- /misc/remove-element[2].c: -------------------------------------------------------------------------------- 1 | int removeElement(int A[], int n, int elem) { 2 | int begin,end; 3 | int tmp; 4 | begin = 0; 5 | end = n-1; 6 | 7 | while(begin <= end){ 8 | while(end >= 0 && A[end] == elem) 9 | end--; 10 | while(begin <= n-1 && A[begin] != elem) 11 | begin++; 12 | 13 | if(begin < end){ 14 | tmp = A[begin]; 15 | A[begin] = A[end]; 16 | A[end] = tmp; 17 | } 18 | } 19 | 20 | return begin; 21 | } 22 | -------------------------------------------------------------------------------- /misc/remove-linked-list-elements.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * struct ListNode *next; 6 | * }; 7 | */ 8 | struct ListNode* removeElements(struct ListNode* head, int val) { 9 | struct ListNode root; 10 | struct ListNode *prev; 11 | 12 | root.next = head; 13 | prev = &root; 14 | 15 | while(head){ 16 | if(head->val == val){ 17 | prev->next = head->next; 18 | //free(head); 19 | head = prev; 20 | } 21 | prev = head; 22 | head = head->next; 23 | } 24 | 25 | return root.next; 26 | } 27 | -------------------------------------------------------------------------------- /misc/reverse-bits.c: -------------------------------------------------------------------------------- 1 | uint32_t reverseBits(uint32_t n) { 2 | unsigned int ret = 0; 3 | int count = 32; 4 | while(count-- > 0){ 5 | ret = (ret << 1) | (n & 1); 6 | n = n >> 1; 7 | } 8 | 9 | return ret; 10 | } 11 | -------------------------------------------------------------------------------- /misc/reverse-integer.c: -------------------------------------------------------------------------------- 1 | int reverse(int x) { 2 | long long ret = 0; 3 | long long a = x; 4 | int positive_flag = 1; 5 | if(x < 0){ 6 | positive_flag = -1; 7 | a = -x; 8 | } 9 | while(a){ 10 | ret = ret * 10 + a % 10; 11 | a /= 10; 12 | } 13 | 14 | if(ret > 0x7fffffff || ret < (-0x7fffffff - 1)) 15 | return 0; 16 | 17 | return positive_flag * ret; 18 | } 19 | -------------------------------------------------------------------------------- /misc/reverse-linked-list.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * struct ListNode *next; 6 | * }; 7 | */ 8 | struct ListNode* reverseList(struct ListNode* head) { 9 | struct ListNode root; 10 | struct ListNode *tmp; 11 | root.next = NULL; 12 | while(head){ 13 | tmp = head->next; 14 | head->next = root.next; 15 | root.next = head; 16 | head = tmp; 17 | } 18 | return root.next; 19 | } 20 | -------------------------------------------------------------------------------- /misc/rotate-array.c: -------------------------------------------------------------------------------- 1 | static void reverse(int nums[], int begin, int end) 2 | { 3 | int tmp; 4 | while(begin < end) 5 | { 6 | tmp = nums[begin]; 7 | nums[begin] = nums[end]; 8 | nums[end] = tmp; 9 | 10 | begin++; 11 | end--; 12 | } 13 | } 14 | 15 | void rotate(int nums[], int n, int k) 16 | { 17 | k = k % n; 18 | reverse(nums,0,n - k - 1); 19 | reverse(nums,n - k, n -1); 20 | reverse(nums,0,n-1); 21 | } 22 | -------------------------------------------------------------------------------- /misc/rotate-array[2].c: -------------------------------------------------------------------------------- 1 | void rotate(int nums[], int n, int k) { 2 | int i = 0; 3 | int count = 0; 4 | int start = 0; 5 | int cur = 0; 6 | int tmp = nums[0]; 7 | 8 | if(k <= 0) 9 | return ; 10 | 11 | 12 | while(count < n){ 13 | do{ 14 | nums[start] = nums[(k+cur)%n]; 15 | nums[(k+cur)%n] = tmp; 16 | tmp = nums[start]; 17 | cur = (k+cur) % n; 18 | count++; 19 | }while(cur != start); 20 | 21 | start++; 22 | cur = start; 23 | tmp = nums[cur]; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /misc/rotate-array[3].c: -------------------------------------------------------------------------------- 1 | void rotate(int nums[], int n, int k) { 2 | int *arr; 3 | int i; 4 | arr = (char *)malloc(sizeof(int) * n); 5 | k = k % n; 6 | for(i = 0; i < n; ++i) 7 | arr[(i+k)%n] = nums[i]; 8 | for(i = 0; i < n; ++i) 9 | nums[i] = arr[i]; 10 | } 11 | -------------------------------------------------------------------------------- /misc/same-tree.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * struct TreeNode *left; 6 | * struct TreeNode *right; 7 | * }; 8 | */ 9 | bool isSameTree(struct TreeNode *p, struct TreeNode *q) { 10 | if(!p && !q) 11 | return true; 12 | if((!p && q) || (p && !q)) 13 | return false; 14 | if(p->val == q->val){ 15 | return isSameTree(p->left,q->left) && isSameTree(p->right,q->right); 16 | } 17 | return false; 18 | } 19 | -------------------------------------------------------------------------------- /misc/search-a-2d-matrix.c: -------------------------------------------------------------------------------- 1 | bool searchMatrix(int **matrix, int m, int n, int target) { 2 | int mid,begin,end,tmp; 3 | begin = 0; 4 | end = m * n - 1; 5 | while(begin <= end){ 6 | mid = (begin + end) / 2; 7 | tmp = matrix[mid/n][mid%n]; 8 | if(tmp == target) 9 | return true; 10 | else if(tmp > target) 11 | end = mid - 1; 12 | else 13 | begin = mid + 1; 14 | } 15 | return false; 16 | } 17 | -------------------------------------------------------------------------------- /misc/search-insert-position.c: -------------------------------------------------------------------------------- 1 | int searchInsert(int A[], int n, int target) { 2 | int beg,end,mid; 3 | beg = 0; 4 | end = n-1; 5 | 6 | while(beg <= end){ 7 | mid = (beg + end) / 2; 8 | if(A[mid] == target) 9 | return mid; 10 | else if(A[mid] > target) 11 | end = mid - 1; 12 | else 13 | beg = mid + 1; 14 | } 15 | return beg; 16 | } 17 | -------------------------------------------------------------------------------- /misc/single-number-ii.c: -------------------------------------------------------------------------------- 1 | int singleNumber(int A[], int n) { 2 | int bits[32]; 3 | int i,j; 4 | int ret = 0; 5 | memset(bits,0,sizeof(int) * 32); 6 | for(i = 0; i < n; ++i) 7 | for(j = 0; j < 32; ++j) 8 | bits[j] += ((A[i] >> j) & 0x1); 9 | 10 | for(j = 0; j < 32; ++j) 11 | if(bits[j] % 3) 12 | ret += (1 << j); 13 | return ret; 14 | } 15 | -------------------------------------------------------------------------------- /misc/single-number-ii[2].c: -------------------------------------------------------------------------------- 1 | int singleNumber(int A[], int n) { 2 | int one = 0, two = 0, reset; 3 | int i; 4 | for(i = 0; i < n; ++i){ 5 | two |= (one & A[i]); 6 | one ^= A[i]; 7 | reset = one & two; 8 | two ^= reset; 9 | one ^= reset; 10 | } 11 | 12 | return one; 13 | } 14 | -------------------------------------------------------------------------------- /misc/single-number.c: -------------------------------------------------------------------------------- 1 | int singleNumber(int A[], int n) { 2 | int ret,i; 3 | ret = 0; 4 | for(i = 0; i < n; ++i) 5 | ret ^= A[i]; 6 | return ret; 7 | } 8 | -------------------------------------------------------------------------------- /misc/sort-colors.c: -------------------------------------------------------------------------------- 1 | void sortColors(int A[], int n) { 2 | int cnt[3]={0}; 3 | int i; 4 | for(i = 0; i < n; ++i) 5 | cnt[A[i]]++; 6 | for(i = 0; i < cnt[0]; ++i) 7 | A[i] = 0; 8 | for(i = cnt[0]; i < cnt[0] + cnt[1]; ++i) 9 | A[i] = 1; 10 | for(i = cnt[0] + cnt[1]; i < n; ++i) 11 | A[i] = 2; 12 | } 13 | -------------------------------------------------------------------------------- /misc/sort-colors[2].c: -------------------------------------------------------------------------------- 1 | void sortColors(int A[], int n) { 2 | int i,one,two; 3 | one = 0; 4 | two = 0; 5 | for(i = 0; i < n; ++i){ 6 | if(A[i] == 0){ 7 | A[i] = A[two]; 8 | A[two] = A[one]; 9 | A[one] = 0; 10 | ++one; 11 | ++two; 12 | }else if(A[i] == 1){ 13 | A[i] = A[two]; 14 | A[two] = 1; 15 | two++; 16 | } 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /misc/sqrtx.c: -------------------------------------------------------------------------------- 1 | int mySqrt(int x) { 2 | int i,tmp; 3 | long begin = 0; 4 | long end = x; 5 | long mid; 6 | if(x == 1) 7 | return 1; 8 | while(begin < end){ 9 | mid = (begin + end) / 2; 10 | if(mid * mid == x || (mid * mid < x && (mid + 1) * (mid + 1) > x)) 11 | return mid; 12 | if(mid * mid < x) 13 | begin = mid; 14 | else 15 | end = mid; 16 | 17 | } 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /misc/unique-binary-search-trees.c: -------------------------------------------------------------------------------- 1 | int numTrees(int n) { 2 | int *arr; 3 | int i,j; 4 | arr = (int *)malloc(sizeof(int) * (n + 1)); 5 | memset(arr,0,sizeof(int) * (n+1)); 6 | arr[0] = 1; 7 | 8 | for(i = 1; i <= n; ++i){ 9 | for(j = 0; j < i; ++j) 10 | arr[i] += arr[j] * arr[i-j-1]; 11 | } 12 | return arr[n]; 13 | } 14 | -------------------------------------------------------------------------------- /misc/unique-paths.c: -------------------------------------------------------------------------------- 1 | int uniquePaths(int m, int n) { 2 | int **dp; 3 | int i,j; 4 | 5 | dp = (int **)malloc(sizeof(int *) * (m+1)); 6 | for(i = 0; i <= m; ++i){ 7 | dp[i] = (int *)malloc(sizeof(int) * (n+1)); 8 | memset(dp[i],0,sizeof(int)*(n+1)); 9 | } 10 | dp[1][1] = 1; 11 | for(i = 1; i <= m; ++i) 12 | for(j = 1; j <= n; ++j) 13 | dp[i][j] += dp[i][j-1] + dp[i-1][j]; 14 | 15 | return dp[m][n]; 16 | } 17 | -------------------------------------------------------------------------------- /misc/word-break[1].cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool wordBreak(string s, unordered_set& wordDict) { 4 | int size = s.size(); 5 | vector dp(size+1,false); 6 | dp[0] = true; 7 | for(int i = 0; i < size; ++i){ 8 | if(dp[i]){ 9 | for(int len = 1; len + i <= size; ++len){ 10 | if(wordDict.find(s.substr(i,len)) != wordDict.end()) 11 | dp[i+len] = true; 12 | } 13 | } 14 | } 15 | 16 | return dp[size]; 17 | } 18 | }; 19 | -------------------------------------------------------------------------------- /python/greedy/assign-cookies.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def findContentChildren(self, g, s): 3 | """ 4 | :type g: List[int] 5 | :type s: List[int] 6 | :rtype: int 7 | """ 8 | i, j = len(g) - 1, len(s) - 1 9 | g, s = sorted(g), sorted(s) 10 | ret = 0 11 | 12 | while min(i, j) >= 0: 13 | if s[j] >= g[i]: 14 | ret += 1 15 | j -= 1 16 | 17 | i -= 1 18 | 19 | return ret 20 | -------------------------------------------------------------------------------- /python/hash-table/4sum-ii.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def fourSumCount(self, A, B, C, D): 3 | """ 4 | :type A: List[int] 5 | :type B: List[int] 6 | :type C: List[int] 7 | :type D: List[int] 8 | :rtype: int 9 | """ 10 | d1 = {} 11 | ret = 0; 12 | for a in A: 13 | for b in B: 14 | d1[a+b] = d1.get(a+b,0) + 1 15 | 16 | for c in C: 17 | for d in D: 18 | key = c + d 19 | ret += d1.get(-key, 0) 20 | 21 | return ret 22 | -------------------------------------------------------------------------------- /python/hash-table/anagrams.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def groupAnagrams(self, strs): 3 | d = {} 4 | ret = [] 5 | 6 | for s in strs: 7 | key = ''.join(sorted(s)) 8 | 9 | if d.get(key, -1) == -1: 10 | d[key] = len(ret) 11 | ret.append([s]) 12 | continue 13 | 14 | ret[d[key]].append(s) 15 | 16 | return ret 17 | -------------------------------------------------------------------------------- /python/hash-table/binary-tree-inorder-traversal.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def inorderTraversal(self, root): 10 | if root is None: 11 | return [] 12 | 13 | return self.inorderTraversal(root.left) + [root.val] \ 14 | + self.inorderTraversal(root.right) 15 | -------------------------------------------------------------------------------- /python/hash-table/binary-tree-inorder-traversal[1].py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def inorderTraversal(self, root): 10 | res = [] 11 | st = [] 12 | 13 | while root or st: 14 | while root: 15 | st.append(root) 16 | root = root.left 17 | 18 | root = st.pop() 19 | res.append(root.val) 20 | root = root.right 21 | 22 | return res 23 | -------------------------------------------------------------------------------- /python/hash-table/contains-duplicate-ii.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def containsNearbyDuplicate(self, nums, k): 3 | d = {} 4 | for i in range(len(nums)): 5 | idx = d.get(nums[i]) 6 | if idx >= 0 and i - idx <= k: 7 | return True 8 | 9 | d[nums[i]] = i 10 | 11 | return False 12 | -------------------------------------------------------------------------------- /python/hash-table/contains-duplicate.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def containsDuplicate(self, nums): 3 | nums.sort() 4 | for i in range(len(nums)-1): 5 | if nums[i] == nums[i+1]: 6 | return True 7 | 8 | return False 9 | -------------------------------------------------------------------------------- /python/hash-table/contains-duplicate[1].py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def containsDuplicate(self, nums): 3 | return len(nums) != len(set(nums)) 4 | -------------------------------------------------------------------------------- /python/hash-table/contiguous-array.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def findMaxLength(self, nums): 3 | """ 4 | :type nums: List[int] 5 | :rtype: int 6 | """ 7 | d = {0 : -1} 8 | cur_sum = 0 9 | res = 0 10 | 11 | for i in range(len(nums)): 12 | cur_sum += (2 * nums[i] - 1) 13 | if cur_sum in d: 14 | res = res if res > i - d[cur_sum] else i - d[cur_sum] 15 | else: 16 | d[cur_sum] = i 17 | 18 | return res 19 | -------------------------------------------------------------------------------- /python/hash-table/count-primes.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def countPrimes(self, n): 3 | arr = [0] * n 4 | count = 0 5 | for i in xrange(2,n): 6 | if arr[i] != 0: 7 | continue 8 | count += 1 9 | for j in xrange(2*i,n,i): 10 | arr[j] = 1 11 | 12 | return count 13 | -------------------------------------------------------------------------------- /python/hash-table/find-the-difference.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def findTheDifference(self, s, t): 3 | h = {}; 4 | for key in s: 5 | if h.get(key) is None: 6 | h[key] = 1 7 | else: 8 | h[key] += 1 9 | 10 | for key in t: 11 | if h.get(key,0) == 0: 12 | return key 13 | h[key] -= 1 14 | -------------------------------------------------------------------------------- /python/hash-table/happy-number.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def __init__(self): 3 | self.count = 0 4 | 5 | def isHappy(self, n): 6 | if n == 1: 7 | return True 8 | if self.count == 100: 9 | return False 10 | 11 | d = 0 12 | tmp = 0 13 | while n > 0: 14 | d = n % 10 15 | n /= 10 16 | tmp += (d * d) 17 | 18 | self.count += 1 19 | return self.isHappy(tmp) 20 | -------------------------------------------------------------------------------- /python/hash-table/happy-number[1].py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def isHappy(self, n): 3 | s = set() 4 | 5 | while True: 6 | s.add(n) 7 | n = sum([int(x) * int(x) for x in list(str(n))]) 8 | if n == 1 or n in s: 9 | break 10 | 11 | return n == 1 12 | -------------------------------------------------------------------------------- /python/hash-table/intersection-of-two-arrays-ii.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def intersect(self, nums1, nums2): 3 | ret = [] 4 | d = {} 5 | 6 | for val in nums1: 7 | if d.get(val): 8 | d[val] += 1 9 | else: 10 | d[val] = 1 11 | 12 | for val in nums2: 13 | if d.get(val,0) > 0: 14 | ret.append(val) 15 | d[val] -= 1 16 | 17 | return ret 18 | -------------------------------------------------------------------------------- /python/hash-table/intersection-of-two-arrays.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def intersection(self, nums1, nums2): 3 | return [val for val in set(nums1) if val in nums2] 4 | #'return list(set(nums1) & set(nums2))' is also OK 5 | -------------------------------------------------------------------------------- /python/hash-table/island-perimeter.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def islandPerimeter(self, grid): 3 | row = len(grid) 4 | col = len(grid[0]) if row else 0 5 | p = 0 6 | for i in range(row): 7 | for j in range(col): 8 | if grid[i][j] == 0: 9 | continue 10 | p += 4 11 | 12 | if i > 0 and grid[i-1][j]: 13 | p -= 2 14 | if j > 0 and grid[i][j-1]: 15 | p -= 2 16 | 17 | return p 18 | -------------------------------------------------------------------------------- /python/hash-table/isomorphic-strings.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def isIsomorphic(self, s, t): 3 | slen = len(s) 4 | flag = {} 5 | visited = {} 6 | 7 | for i in range(slen): 8 | if flag.get(s[i],-1) == -1: 9 | if visited.get(t[i],-1) != -1: 10 | return False 11 | 12 | flag[s[i]] = t[i] 13 | visited[t[i]] = 1 14 | elif flag.get(s[i]) != t[i]: 15 | return False 16 | 17 | return True 18 | -------------------------------------------------------------------------------- /python/hash-table/isomorphic-strings[1].py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def isIsomorphic(self, s, t): 3 | ms = {} 4 | mt = {} 5 | 6 | for i in range(len(s)): 7 | if ms.get(s[i],-1) != mt.get(t[i],-1): 8 | return False 9 | 10 | ms[s[i]] = i 11 | mt[t[i]] = i 12 | 13 | return True 14 | -------------------------------------------------------------------------------- /python/hash-table/keyboard-row[1].py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def findWords(self, words): 3 | """ 4 | :type words: List[str] 5 | :rtype: List[str] 6 | """ 7 | s1 = set("qwertyuiop") 8 | s2 = set("asdfghjkl") 9 | s3 = set("zxcvbnm") 10 | 11 | res = [] 12 | for word in words: 13 | sw = set(word.lower()) 14 | if sw.issubset(s1) or sw.issubset(s2) or sw.issubset(s3): 15 | res.append(word) 16 | 17 | return res 18 | -------------------------------------------------------------------------------- /python/hash-table/longest-palindrome.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def longestPalindrome(self, s): 3 | """ 4 | :type s: str 5 | :rtype: int 6 | """ 7 | d = {} 8 | ret = 0 9 | plus = 0 10 | for c in s: 11 | d[c] = d.get(c,0) + 1 12 | 13 | for (key,count) in d.items(): 14 | ret += count 15 | if count % 2 : 16 | ret -= 1 17 | plus = 1 18 | 19 | return ret + plus 20 | -------------------------------------------------------------------------------- /python/hash-table/longest-substring-without-repeating-characters.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def lengthOfLongestSubstring(self, s): 3 | index = {} 4 | last_index = 0 5 | ret = 0 6 | for i in xrange(len(s)): 7 | if index.get(s[i],-1) >= last_index: 8 | last_index = index[s[i]] + 1 9 | index[s[i]] = i 10 | ret = max((i - last_index + 1),ret) 11 | 12 | return ret 13 | -------------------------------------------------------------------------------- /python/hash-table/repeated-dna-sequences.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def findRepeatedDnaSequences(self, s): 3 | """ 4 | :type s: str 5 | :rtype: List[str] 6 | """ 7 | d = set() 8 | res = set() 9 | for i in range(len(s)-9): 10 | if s[i:i + 10] in d: 11 | res.add(s[i:i + 10]) 12 | else: 13 | d.add(s[i:i + 10]) 14 | 15 | return list(res) 16 | -------------------------------------------------------------------------------- /python/hash-table/single-number.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def singleNumber(self, nums): 3 | ret = 0 4 | for val in nums: 5 | ret ^= val 6 | 7 | return ret 8 | -------------------------------------------------------------------------------- /python/hash-table/single-number[1].py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def singleNumber(self, nums): 3 | h = {} 4 | 5 | for val in nums: 6 | h[val] = 1 if h.get(val,-1) == -1 else 2 7 | 8 | for val in nums: 9 | if h[val] == 1: 10 | return val 11 | -------------------------------------------------------------------------------- /python/hash-table/sort-characters-by-frequency.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def frequencySort(self, s): 3 | """ 4 | :type s: str 5 | :rtype: str 6 | """ 7 | d = {} 8 | l = [] 9 | for c in s: 10 | d[c] = d.get(c, 0) + 1 11 | 12 | for c in d: 13 | index = 0 14 | while index < len(l): 15 | if d[l[index]] < d[c]: 16 | break 17 | index += 1 18 | l.insert(index, c) 19 | 20 | res = "" 21 | for c in l: 22 | res += c * d[c] 23 | 24 | return res 25 | -------------------------------------------------------------------------------- /python/hash-table/sort-characters-by-frequency[1].py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def frequencySort(self, s): 3 | """ 4 | :type s: str 5 | :rtype: str 6 | """ 7 | return ''.join(c * t for c, t in collections.Counter(s).most_common()) 8 | -------------------------------------------------------------------------------- /python/hash-table/top-k-frequent-elements.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def topKFrequent(self, nums, k): 3 | """ 4 | :type nums: List[int] 5 | :type k: int 6 | :rtype: List[int] 7 | """ 8 | return [c for c, t in collections.Counter(nums).most_common(k)] 9 | -------------------------------------------------------------------------------- /python/hash-table/top-k-frequent-elements[1].py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def topKFrequent(self, nums, k): 3 | """ 4 | :type nums: List[int] 5 | :type k: int 6 | :rtype: List[int] 7 | """ 8 | d = {} 9 | for val in nums: 10 | d[val] = d.get(val, 0) + 1 11 | 12 | res = [] 13 | for val, count in sorted(d.items(), reverse=True, key=lambda x:x[1]): 14 | res.append(val) 15 | k -= 1 16 | if k == 0: 17 | break 18 | 19 | return res 20 | -------------------------------------------------------------------------------- /python/hash-table/two-sum.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def twoSum(self, nums, target): 3 | """ 4 | :type nums: List[int] 5 | :type target: int 6 | :rtype: List[int] 7 | """ 8 | d = {} 9 | for index, val in enumerate(nums): 10 | if target - val in d: 11 | return [d[target-val], index] 12 | d[val] = index 13 | 14 | return [] 15 | -------------------------------------------------------------------------------- /python/hash-table/valid-anagram.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def isAnagram(self, s, t): 3 | if len(s) != len(t): 4 | return False 5 | 6 | h = [0] * 26 7 | for i in range(len(s)): 8 | h[ord(s[i]) - ord('a')] = h[ord(s[i]) - ord('a')] + 1 9 | h[ord(t[i]) - ord('a')] = h[ord(t[i]) - ord('a')] - 1 10 | 11 | for val in h: 12 | if val != 0: 13 | return False 14 | 15 | return True 16 | -------------------------------------------------------------------------------- /python/hash-table/word-pattern.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def wordPattern(self, pattern, str): 3 | """ 4 | :type pattern: str 5 | :type str: str 6 | :rtype: bool 7 | """ 8 | ls = str.split() 9 | d1 = {} 10 | d2 = {} 11 | if(len(ls) != len(pattern)): 12 | return False 13 | for c1, c2 in zip(pattern, ls): 14 | if c1 not in d1: 15 | d1[c1] = c2 16 | if c2 not in d2: 17 | d2[c2] = c1 18 | if d1[c1] != c2 or d2[c2] != c1: 19 | return False 20 | 21 | return True 22 | -------------------------------------------------------------------------------- /python/hash-table/word-pattern[1].py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def wordPattern(self, pattern, str): 3 | """ 4 | :type pattern: str 5 | :type str: str 6 | :rtype: bool 7 | """ 8 | words = str.split() 9 | return map(pattern.find, pattern) == map(words.index, words) 10 | -------------------------------------------------------------------------------- /python/stack/binary-tree-inorder-traversal.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def inorderTraversal(self, root): 10 | if root is None: 11 | return [] 12 | return self.inorderTraversal(root.left) + [root.val] + \ 13 | self.inorderTraversal(root.right) 14 | -------------------------------------------------------------------------------- /python/stack/binary-tree-inorder-traversal[2].py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def inorderTraversal(self, root): 10 | st = [] 11 | list = [] 12 | 13 | while root or st: 14 | while root: 15 | st.append(root) 16 | root = root.left 17 | 18 | root = st.pop() 19 | list.append(root.val) 20 | root = root.right 21 | 22 | return list 23 | -------------------------------------------------------------------------------- /python/stack/binary-tree-postorder-traversal.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def postorderTraversal(self, root): 10 | if root is None: 11 | return [] 12 | return self.postorderTraversal(root.left) +\ 13 | self.postorderTraversal(root.right) + [root.val] 14 | -------------------------------------------------------------------------------- /python/stack/binary-tree-preorder-traversal[2].py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def preorderTraversal(self, root): 10 | if root: 11 | return [root.val] + self.preorderTraversal(root.left) + \ 12 | self.preorderTraversal(root.right) 13 | return [] 14 | -------------------------------------------------------------------------------- /python/stack/evaluate-reverse-polish-notation.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def evalRPN(self, tokens): 3 | ops = {'+': operator.add, '-': operator.sub, '*': operator.mul, '/': operator.div} 4 | st = [] 5 | opstr = '+-*/' 6 | for t in tokens: 7 | if t in opstr: 8 | right = st.pop() 9 | left = st.pop() 10 | if(t == '/'): 11 | st.append(int(ops[t](left * 1.0,right))) 12 | else: 13 | st.append(ops[t](left,right)) 14 | else: 15 | st.append(int(t)) 16 | 17 | return st[0]; 18 | -------------------------------------------------------------------------------- /python/stack/remove-duplicate-letters.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def removeDuplicateLetters(self, s): 3 | h = {} 4 | st = [] 5 | 6 | for ch in s: 7 | if ch in h.keys(): 8 | h[ch] += 1 9 | else: 10 | h[ch] = 1 11 | 12 | for ch in s: 13 | h[ch] -= 1 14 | if ch in st: 15 | continue 16 | 17 | while st and ch < st[-1] and h[st[-1]] > 0: 18 | st.pop() 19 | 20 | st.append(ch) 21 | 22 | return ''.join(st) 23 | -------------------------------------------------------------------------------- /python/stack/remove-duplicate-letters[2].py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def removeDuplicateLetters(self, s): 3 | count = collections.Counter(s) 4 | st = [] 5 | 6 | for ch in s: 7 | count[ch] -= 1 8 | if ch in st: 9 | continue 10 | while st and ch < st[-1] and count[st[-1]] > 0: 11 | st.pop() 12 | st.append(ch) 13 | 14 | return ''.join(st) 15 | -------------------------------------------------------------------------------- /python/stack/simplify-path[2].py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def simplifyPath(self, path): 3 | st = [] 4 | str_list = path.split('/') 5 | for str in str_list: 6 | if len(str) > 0: 7 | if str == '..': 8 | if st: 9 | st.pop() 10 | elif str != '.': 11 | st.append(str) 12 | 13 | if st == []: 14 | return '/' 15 | ret = '' 16 | for str in st: 17 | ret += '/' + str 18 | 19 | return ret 20 | -------------------------------------------------------------------------------- /python/stack/valid-parentheses.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def isValid(self, s): 3 | st = [] 4 | left_s = '({[' 5 | for c in s: 6 | if c in left_s: 7 | st.append(c) 8 | elif st and \ 9 | ((c == ')' and st[-1] == '(') \ 10 | or (c == '}' and st[-1] == '{') \ 11 | or (c == ']' and st[-1] == '[')): 12 | st.pop(); 13 | else: 14 | return False 15 | 16 | return not st 17 | -------------------------------------------------------------------------------- /python/tree/binary-tree-inorder-traversal.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def inorderTraversal(self, root): 10 | arr = [] 11 | st = [] 12 | cur = root 13 | while cur or st: 14 | while cur: 15 | st.append(cur) 16 | cur = cur.left 17 | arr.append(st[-1].val) 18 | cur = st.pop().right 19 | 20 | return arr 21 | -------------------------------------------------------------------------------- /python/tree/binary-tree-postorder-traversal.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def __init__(self): 10 | self.result = [] 11 | 12 | def postorderTraversal(self, root): 13 | if not root: 14 | return self.result 15 | 16 | self.postorderTraversal(root.left) 17 | self.postorderTraversal(root.right) 18 | self.result.append(root.val) 19 | 20 | return self.result 21 | -------------------------------------------------------------------------------- /python/tree/binary-tree-preorder-traversal.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def __init__(self): 10 | self.arr = [] 11 | 12 | def preorderTraversal(self, root): 13 | if root is None: 14 | return self.arr 15 | 16 | self.arr.append(root.val) 17 | self.preorderTraversal(root.left) 18 | self.preorderTraversal(root.right) 19 | return self.arr 20 | -------------------------------------------------------------------------------- /python/tree/invert-binary-tree.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def invertTree(self, root): 10 | if not root: 11 | return None 12 | 13 | node = self.invertTree(root.left) 14 | root.left = self.invertTree(root.right) 15 | root.right = node 16 | 17 | return root 18 | -------------------------------------------------------------------------------- /python/tree/lowest-common-ancestor-of-a-binary-search-tree.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def lowestCommonAncestor(self, root, p, q): 10 | if not root or root == p or root == q: 11 | return root 12 | 13 | left = self.lowestCommonAncestor(root.left,p,q) 14 | right = self.lowestCommonAncestor(root.right,p,q) 15 | 16 | if left and right: 17 | return root 18 | 19 | return left if left else right 20 | -------------------------------------------------------------------------------- /python/tree/lowest-common-ancestor-of-a-binary-search-tree[1].py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def lowestCommonAncestor(self, root, p, q): 10 | if min(p.val, q.val) > root.val: 11 | return self.lowestCommonAncestor(root.right, p, q) 12 | elif max(p.val, q.val) < root.val: 13 | return self.lowestCommonAncestor(root.left, p, q) 14 | else: 15 | return root 16 | -------------------------------------------------------------------------------- /python/tree/maximum-depth-of-binary-tree[1].py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def maxDepth(self, root): 10 | if root is None: 11 | return 0 12 | 13 | left = self.maxDepth(root.left) 14 | right = self.maxDepth(root.right) 15 | 16 | return max(left,right) + 1 17 | -------------------------------------------------------------------------------- /python/tree/path-sum.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def hasPathSum(self, root, sum): 10 | if root is None: 11 | return False 12 | 13 | if root.left is None and root.right is None: 14 | return root.val == sum 15 | 16 | bleft = self.hasPathSum(root.left, sum - root.val) 17 | 18 | return bleft if bleft else self.hasPathSum(root.right, sum - root.val) 19 | -------------------------------------------------------------------------------- /python/tree/same-tree.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def isSameTree(self, p, q): 10 | if p and q: 11 | if p.val != q.val: 12 | return False 13 | 14 | return self.isSameTree(p.left,q.left) and \ 15 | self.isSameTree(p.right,q.right) 16 | 17 | return p is None and q is None 18 | -------------------------------------------------------------------------------- /python/tree/sum-root-to-leaf-numbers.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def sum(self, root, cur_val): 10 | if root is None: 11 | return 0 12 | 13 | val = cur_val * 10 + root.val 14 | if root.left is None and root.right is None: 15 | return val 16 | 17 | return self.sum(root.left,val) + self.sum(root.right,val) 18 | 19 | def sumNumbers(self, root): 20 | return self.sum(root,0) 21 | -------------------------------------------------------------------------------- /python/tree/unique-binary-search-trees.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def numTrees(self, n): 3 | num = [0] * (n+1) 4 | num[0] = num[1] = 1 5 | for i in range(2,n+1): 6 | for j in range(i): 7 | num[i] += (num[j] * num[i-j-1]) 8 | 9 | return num[n] 10 | --------------------------------------------------------------------------------