├── .gitignore ├── p1_search_and_sort ├── __init__.py ├── binary_search.py ├── bubble_sort.py ├── insert_sort.py ├── merge_sort.py ├── quick_sort.py ├── selection_sort.py └── shell_sort.py ├── p2_stack_and_queue ├── __init__.py ├── base_converter.py ├── hot_potato.py ├── linked_reverse.py ├── palindrome.py └── parentheses.py └── p3 ├── __init__.py └── traverse_tree.py /.gitignore: -------------------------------------------------------------------------------- 1 | # Created by .ignore support plugin (hsz.mobi) 2 | ### Python template 3 | # Byte-compiled / optimized / DLL files 4 | __pycache__/ 5 | *.py[cod] 6 | *$py.class 7 | 8 | # C extensions 9 | *.so 10 | 11 | # Distribution / packaging 12 | .Python 13 | build/ 14 | develop-eggs/ 15 | dist/ 16 | downloads/ 17 | eggs/ 18 | .eggs/ 19 | lib/ 20 | lib64/ 21 | parts/ 22 | sdist/ 23 | var/ 24 | wheels/ 25 | *.egg-info/ 26 | .installed.cfg 27 | *.egg 28 | MANIFEST 29 | 30 | # PyInstaller 31 | # Usually these files are written by a python script from a template 32 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 33 | *.manifest 34 | *.spec 35 | 36 | # Installer logs 37 | pip-log.txt 38 | pip-delete-this-directory.txt 39 | 40 | # Unit test / coverage reports 41 | htmlcov/ 42 | .tox/ 43 | .coverage 44 | .coverage.* 45 | .cache 46 | nosetests.xml 47 | coverage.xml 48 | *.cover 49 | .hypothesis/ 50 | 51 | # Translations 52 | *.mo 53 | *.pot 54 | 55 | # Django stuff: 56 | *.log 57 | .static_storage/ 58 | .media/ 59 | local_settings.py 60 | 61 | # Flask stuff: 62 | instance/ 63 | .webassets-cache 64 | 65 | # Scrapy stuff: 66 | .scrapy 67 | 68 | # Sphinx documentation 69 | docs/_build/ 70 | 71 | # PyBuilder 72 | target/ 73 | 74 | # Jupyter Notebook 75 | .ipynb_checkpoints 76 | 77 | # pyenv 78 | .python-version 79 | 80 | # celery beat schedule file 81 | celerybeat-schedule 82 | 83 | # SageMath parsed files 84 | *.sage.py 85 | 86 | # Environments 87 | .env 88 | .venv 89 | env/ 90 | venv/ 91 | ENV/ 92 | env.bak/ 93 | venv.bak/ 94 | 95 | # Spyder project settings 96 | .spyderproject 97 | .spyproject 98 | 99 | # Rope project settings 100 | .ropeproject 101 | 102 | # mkdocs documentation 103 | /site 104 | 105 | # mypy 106 | .mypy_cache/ 107 | 108 | # macos 109 | .idea/ 110 | 111 | -------------------------------------------------------------------------------- /p1_search_and_sort/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -- coding: utf-8 -- 3 | """ 4 | Copyright (c) 2018. All rights reserved. 5 | Created by C. L. Wang on 2018/10/17 6 | """ -------------------------------------------------------------------------------- /p1_search_and_sort/binary_search.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -- coding: utf-8 -- 3 | """ 4 | Copyright (c) 2018. All rights reserved. 5 | Created by C. L. Wang on 2018/10/15 6 | 7 | 二分查找，时间复杂度O(logn) 8 | 9 | 排序一次，查找多次，排序成本可以忽略； 10 | 只查找一次，则顺序查找比较好。 11 | """ 12 | 13 | 14 | def binary_search(alist, item): 15 | """ 16 | 二分查找，非递归 17 | 1. 2个参数，待查找alist和查找项item 18 | 2. 声明3个变量，first，last，found(返回值) 19 | 3. while条件，first小于等于last，found是false 20 | 4. mid是first和last的中值(整除)； 21 | 5. 三个if条件，相等alist[mid]=item，小于中值换last，大于中值换first； 22 | 6. 返回found，13行 23 | :param alist: 待查找alist 24 | :param item: 待查找项item 25 | :return: 是否找到 26 | """ 27 | first = 0 28 | last = len(alist) - 1 29 | while first <= last: 30 | mid = (first + last) // 2 31 | if alist[mid] == item: 32 | return True 33 | else: 34 | if alist[mid] > item: 35 | last = mid - 1 36 | else: 37 | first = mid + 1 38 | return False 39 | 40 | 41 | def binary_search_re(alist, item): 42 | """ 43 | 二分查找，递归 44 | 1. if终止条件，长度为0，返回False； 45 | 2. 中点是长度除2，中值判断； 46 | 3. 小于递归前半部分，大于递归后半部分，返回递归函数； 47 | 4. 11行 48 | :param alist: 待查找alist 49 | :param item: 待查找项item 50 | :return: 是否找到 51 | """ 52 | if len(alist) == 0: 53 | return False 54 | mid = len(alist) // 2 55 | if alist[mid] == item: 56 | return True 57 | else: 58 | if alist[mid] > item: 59 | return binary_search_re(alist[:mid], item) 60 | else: 61 | return binary_search_re(alist[mid + 1:], item) 62 | 63 | 64 | def test_of_binary_search(): 65 | test_list = [0, 1, 2, 8, 13, 17, 19, 32, 42] 66 | print(binary_search(test_list, 3)) 67 | print(binary_search(test_list, 13)) 68 | print(binary_search_re(test_list, 3)) 69 | print(binary_search_re(test_list, 13)) 70 | 71 | 72 | if __name__ == '__main__': 73 | test_of_binary_search() 74 | -------------------------------------------------------------------------------- /p1_search_and_sort/bubble_sort.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -- coding: utf-8 -- 3 | """ 4 | Copyright (c) 2018. All rights reserved. 5 | Created by C. L. Wang on 2018/10/15 6 | 7 | 冒泡排序，时间复杂度O(n^2) 8 | 9 | 冒泡排序，时间复杂度O(n^2)，冒泡排序通常被认为是低效的排序方式。 10 | 优势是：识别排序列表，和提前终止排序。 11 | 短冒泡排序就是提前终止的冒泡排序。 12 | 冒泡排序4行，短冒泡排序8行。 13 | """ 14 | 15 | 16 | def bubble_sort(alist): 17 | """ 18 | 冒泡排序 19 | 1. 两次遍历，第1次遍历长度，倒序逐渐减1，每遍历一次，排序一个； 20 | 2. 第2次，正常遍历，少1个值，因为i和i+1； 21 | 3. 当前位大于下一位，交换当前位和下一位； 22 | 4. 4行 23 | :param alist: 待排序列表 24 | :return: None，内部排序 25 | """ 26 | for p_num in range(len(alist) - 1, 0, -1): 27 | for i in range(p_num): 28 | if alist[i] > alist[i + 1]: 29 | alist[i], alist[i + 1] = alist[i + 1], alist[i] 30 | 31 | 32 | def bubble_sort_short(alist): 33 | """ 34 | 短冒泡排序，增加exchange，额外终止参数 35 | 1. 初始为True，当为False时终止； 36 | 2. 在第2次循环前，设置为False，交换一次就设置为True，一次未交换则触发终止； 37 | 3. 8行，增加5行的exchange操作 38 | :param alist: 39 | :return: 40 | """ 41 | for p_num in range(len(alist) - 1, 0, -1): 42 | exchange = False 43 | for i in range(p_num): 44 | if alist[i] > alist[i + 1]: 45 | alist[i], alist[i + 1] = alist[i + 1], alist[i] 46 | exchange = True 47 | if not exchange: 48 | # print('提前终止') 49 | return 50 | 51 | 52 | def test_of_bubble_sort(): 53 | alist = [54, 26, 93, 17, 77, 31, 44, 55, 20] 54 | # bubble_sort(alist) 55 | # print(alist) 56 | alist = [17, 20, 26, 93, 77, 31, 44, 55, 54] 57 | bubble_sort_short(alist) 58 | print(alist) 59 | 60 | 61 | if __name__ == '__main__': 62 | test_of_bubble_sort() 63 | -------------------------------------------------------------------------------- /p1_search_and_sort/insert_sort.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -- coding: utf-8 -- 3 | """ 4 | Copyright (c) 2018. All rights reserved. 5 | Created by C. L. Wang on 2018/10/15 6 | 7 | 插入排序，时间复杂度O(n^2) 8 | 用移位代替交换，移位操作的时间大约是交换时间的1/3。 9 | """ 10 | 11 | 12 | def insert_sort(alist): 13 | """ 14 | 插入排序，子序列逐渐有序 15 | 1. 遍历列表，存储当前值cur_val，设置游标pos 16 | 2. 游标大于0和游标的值大于当前值，则移位，同时游标减1； 17 | 3. 将当前值赋予游标的终止位置； 18 | 4. 7行 19 | :param alist: 待排序alist 20 | :return: None 21 | """ 22 | for i in range(1, len(alist)): 23 | cur_val = alist[i] 24 | pos = i # 游标 25 | while pos > 0 and alist[pos - 1] > cur_val: 26 | alist[pos] = alist[pos - 1] 27 | pos -= 1 28 | alist[pos] = cur_val # 最后游标的位置 29 | 30 | 31 | def test_of_insert_sort(): 32 | alist = [54, 26, 93, 17, 77, 31, 44, 55, 20] 33 | insert_sort(alist) 34 | print(alist) 35 | 36 | 37 | if __name__ == '__main__': 38 | test_of_insert_sort() 39 | -------------------------------------------------------------------------------- /p1_search_and_sort/merge_sort.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -- coding: utf-8 -- 3 | """ 4 | Copyright (c) 2018. All rights reserved. 5 | Created by C. L. Wang on 2018/10/16 6 | 7 | 归并排序，时间复杂度O(nlogn)，合并过程需要额外的空间，左右两个部分。 8 | """ 9 | 10 | 11 | def merge_sort(alist): 12 | """ 13 | 归并排序 14 | 1. 递归，结束条件，只有1个元素，return； 15 | 2. mid中心，左右两部分，递归调用merge_sort； 16 | 3. 遍历左右，添加较小的值；遍历其余部分； 17 | 4. 20行 18 | :param alist: 19 | :return: 20 | """ 21 | if len(alist) < 2: 22 | return 23 | mid = len(alist) // 2 24 | left = alist[:mid] 25 | right = alist[mid:] 26 | merge_sort(left) 27 | merge_sort(right) 28 | i, j, k = 0, 0, 0 29 | while i < len(left) and j < len(right): 30 | if left[i] < right[j]: 31 | alist[k] = left[i] 32 | i += 1 33 | else: 34 | alist[k] = right[j] 35 | j += 1 36 | k += 1 37 | if i < len(left): 38 | alist[k:] = left[i:] 39 | if j < len(right): 40 | alist[k:] = right[j:] 41 | 42 | 43 | def test_of_merge_sort(): 44 | alist = [54, 26, 93, 17, 77, 31, 44, 55, 20] 45 | merge_sort(alist) 46 | print(alist) 47 | 48 | 49 | if __name__ == '__main__': 50 | test_of_merge_sort() 51 | -------------------------------------------------------------------------------- /p1_search_and_sort/quick_sort.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -- coding: utf-8 -- 3 | """ 4 | Copyright (c) 2018. All rights reserved. 5 | Created by C. L. Wang on 2018/10/16 6 | 7 | 快速排序，时间复杂度O(nlogn)，不需要额外空间。 8 | """ 9 | 10 | 11 | def quick_sort(alist, fst, lst): 12 | """ 13 | 快速排序 14 | 1. 确定终止条件，起始大于等于终止； 15 | 2. 起始fst和终止lst的位置，枢轴值pivot是第1个值； 16 | 3. 遍历i和j，i是第2个，j是最后一个； 17 | 4. 循环交换，直到i和j交叉； 18 | 5. 枢轴索引取i和j最小的1个； 19 | 6. 交换枢轴位置的值与起始位置的值； 20 | 7. 递归调用左右两部分； 21 | 8. 16行 22 | :param alist: 待排序列表 23 | :param fst: 起始idx 24 | :param lst: 终止idx 25 | :return: None 26 | """ 27 | if fst >= lst: 28 | return 29 | pivot = alist[fst] 30 | i, j = fst + 1, lst 31 | while i <= j: # 增加等号，用于移动中心轴位置，最后交换使用 32 | while alist[i] < pivot: 33 | i += 1 34 | while alist[j] > pivot: 35 | j -= 1 36 | if i < j: 37 | alist[i], alist[j] = alist[j], alist[i] 38 | i, j = i + 1, j - 1 39 | p_idx = min(i, j) # 枢轴索引 40 | alist[fst], alist[p_idx] = alist[p_idx], alist[fst] 41 | quick_sort(alist, fst, p_idx - 1) 42 | quick_sort(alist, p_idx + 1, lst) 43 | 44 | 45 | def quick_sort_v2(alist): 46 | """ 47 | 快速排序，需要额外空间 48 | :param alist: 待排序列表 49 | :return: 排序列表 50 | """ 51 | if len(alist) <= 1: 52 | return alist 53 | pivot = alist[0] 54 | small = [i for i in alist if i < pivot] 55 | mid = [i for i in alist if i == pivot] 56 | large = [i for i in alist if i > pivot] 57 | return quick_sort_v2(small) + mid + quick_sort_v2(large) 58 | 59 | 60 | def test_of_quick_sort(): 61 | # alist = [54, 26, 93, 17, 77, 31, 44, 55, 20] 62 | alist = [54, 26, 93, 17, 77, 56, 26, 55, 20] 63 | quick_sort(alist, 0, len(alist) - 1) 64 | print(alist) 65 | # alist = quick_sort_v2(alist) 66 | # print(alist) 67 | 68 | 69 | if __name__ == '__main__': 70 | test_of_quick_sort() 71 | -------------------------------------------------------------------------------- /p1_search_and_sort/selection_sort.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -- coding: utf-8 -- 3 | """ 4 | Copyright (c) 2018. All rights reserved. 5 | Created by C. L. Wang on 2018/10/15 6 | 7 | 选择排序，时间复杂度O(n^2) 8 | 比较次数与冒泡排序相同，交换次数小于冒泡排序。 9 | """ 10 | 11 | 12 | def selection_sort(alist): 13 | """ 14 | 选择排序，即选择最大值再交换 15 | 1. 依然是2次遍历，第1次反序，第2次正序，注意起始为1，末尾+1； 16 | 2. max_loc存储最大值，默认第0位； 17 | 3. 当loc的值大于max_loc的值时，max_loc重新赋值； 18 | 4. 交换loc和max_loc 19 | 5. 6行 20 | :param alist: 待排序alist 21 | :return: None 22 | """ 23 | for p_num in range(len(alist) - 1, 0, -1): 24 | max_loc = 0 25 | for i in range(1, p_num + 1): 26 | if alist[i] > alist[max_loc]: 27 | max_loc = i 28 | alist[p_num], alist[max_loc] = alist[max_loc], alist[p_num] 29 | 30 | 31 | def tes_of_selection_sort(): 32 | alist = [54, 26, 93, 17, 77, 31, 44, 55, 20] 33 | selection_sort(alist) 34 | print(alist) 35 | 36 | 37 | if __name__ == '__main__': 38 | tes_of_selection_sort() 39 | -------------------------------------------------------------------------------- /p1_search_and_sort/shell_sort.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -- coding: utf-8 -- 3 | """ 4 | Copyright (c) 2018. All rights reserved. 5 | Created by C. L. Wang on 2018/10/15 6 | 7 | 希尔排序，时间复杂度，介于O(n)~O(n^2)，也可以认为是O(n^3/2) 8 | 插入排序的改进，比较和移位较少，每次遍历都会生成一个"更有序"的子列表 9 | """ 10 | 11 | 12 | def shell_sort(alist): 13 | """ 14 | 希尔排序 15 | 1. 两部分，第1部分，计算增量gap和起始位置s_pos； 16 | 2. 增量是累除2，s_pos是增量的遍历 17 | 3. 增量插入排序，额外传入起始位置和增量； 18 | 4. range的起始由起始位置+增量； 19 | 5. 循环条件为大于等于增量，差值为增量 20 | 6. 12行，增量部分5行，插入部分7行 21 | :param alist: 待排序alist 22 | :return: None 23 | """ 24 | gap = len(alist) // 2 25 | while gap > 0: 26 | for s_pos in range(gap): 27 | insert_sort_gap(alist, s_pos, gap) 28 | gap = gap // 2 29 | 30 | 31 | def insert_sort_gap(alist, s_pos, gap): 32 | """ 33 | 带增量的插入排序 34 | :param alist: 待排序alist 35 | :param s_pos: 起始位置 36 | :param gap: 增量 37 | :return: None 38 | """ 39 | for i in range(s_pos + gap, len(alist), gap): 40 | cur_val = alist[i] 41 | pos = i 42 | while pos >= gap and alist[pos - gap] > cur_val: 43 | alist[pos] = alist[pos - gap] 44 | pos -= gap 45 | alist[pos] = cur_val 46 | 47 | 48 | def test_of_shell_sort(): 49 | alist = [54, 26, 93, 17, 77, 31, 44, 55, 20] 50 | shell_sort(alist) 51 | print(alist) 52 | 53 | 54 | if __name__ == '__main__': 55 | test_of_shell_sort() 56 | -------------------------------------------------------------------------------- /p2_stack_and_queue/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -- coding: utf-8 -- 3 | """ 4 | Copyright (c) 2018. All rights reserved. 5 | Created by C. L. Wang on 2018/10/29 6 | """ -------------------------------------------------------------------------------- /p2_stack_and_queue/base_converter.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -- coding: utf-8 -- 3 | """ 4 | Copyright (c) 2018. All rights reserved. 5 | Created by C. L. Wang on 2018/10/29 6 | """ 7 | 8 | 9 | def base_converter(num, base): 10 | """ 11 | 将二进制转换为其他进制 12 | :param num: 数字 13 | :param base: 基数 14 | :return: 数字的字符串 15 | """ 16 | digs = '0123456789ABCDEF' # 支持16位 17 | base_stack = list() 18 | 19 | while num > 0: 20 | rem = num % base 21 | base_stack.append(rem) 22 | num //= base # 递减一直到0 23 | 24 | res_str = '' # 转换为str 25 | while base_stack: 26 | res_str += digs[base_stack.pop()] 27 | 28 | return res_str 29 | 30 | 31 | if __name__ == '__main__': 32 | print(base_converter(25, 2)) 33 | print(base_converter(25, 16)) 34 | -------------------------------------------------------------------------------- /p2_stack_and_queue/hot_potato.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -- coding: utf-8 -- 3 | """ 4 | Copyright (c) 2018. All rights reserved. 5 | Created by C. L. Wang on 2018/10/29 6 | """ 7 | from queue import Queue 8 | 9 | 10 | def hot_potato(name_list, num): 11 | """ 12 | 烫手的山芋，循环去除 13 | :param name_list: 名字列表 14 | :param num: 循环数 15 | :return: 最后剩下的人 16 | """ 17 | q = Queue() 18 | 19 | for name in name_list: 20 | q.put(name) 21 | 22 | while q.qsize() > 1: 23 | for i in range(num - 1): # 每次都死一个循环，最后一个死亡 24 | live = q.get() 25 | q.put(live) 26 | dead = q.get() # 输出死亡 27 | print('Dead: {}'.format(dead)) 28 | 29 | return q.get() 30 | 31 | 32 | def test_of_hot_potato(): 33 | name_list = ['Bill', 'David', 'Susan', 'Jane', 'Kent', 'Brad'] 34 | num = 3 35 | print(hot_potato(name_list, num)) 36 | 37 | 38 | if __name__ == '__main__': 39 | test_of_hot_potato() 40 | -------------------------------------------------------------------------------- /p2_stack_and_queue/linked_reverse.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -- coding: utf-8 -- 3 | """ 4 | Copyright (c) 2018. All rights reserved. 5 | Created by C. L. Wang on 2018/10/29 6 | """ 7 | 8 | 9 | class Node: 10 | def __init__(self, data=None): 11 | self.data = data 12 | self.next_node = None 13 | 14 | 15 | def reverse_list(node_head): 16 | """ 17 | 链表逆序，交换链表 18 | :param node_head: 链表头 19 | :return: 新的链表的头结点 20 | """ 21 | prev_node = None 22 | 23 | while node_head: 24 | next_node = node_head.next_node 25 | node_head.next_node = prev_node 26 | prev_node = node_head 27 | node_head = next_node 28 | 29 | return prev_node 30 | 31 | 32 | def init_list(): 33 | n1 = Node(1) 34 | n2 = Node(2) 35 | n3 = Node(3) 36 | n4 = Node(4) 37 | n5 = Node(5) 38 | n1.next_node = n2 39 | n2.next_node = n3 40 | n3.next_node = n4 41 | n4.next_node = n5 42 | return n1 43 | 44 | 45 | def show_list(node_head): 46 | head = node_head 47 | while head: 48 | print(head.data, end=' ') 49 | head = head.next_node 50 | 51 | 52 | def test_of_reverse_list(): 53 | head_node = init_list() 54 | show_list(head_node) 55 | print() 56 | head_node = reverse_list(head_node) 57 | show_list(head_node) 58 | 59 | 60 | if __name__ == '__main__': 61 | test_of_reverse_list() 62 | -------------------------------------------------------------------------------- /p2_stack_and_queue/palindrome.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -- coding: utf-8 -- 3 | """ 4 | Copyright (c) 2018. All rights reserved. 5 | Created by C. L. Wang on 2018/10/29 6 | 7 | 回文，deque 8 | """ 9 | from collections import deque 10 | 11 | 12 | def pal_checker(a_str): 13 | """ 14 | 回文，双端队列 15 | :param a_str: 输入字符串 16 | :return: 是否回文 17 | """ 18 | q_char = deque() 19 | 20 | for ch in a_str: 21 | q_char.append(ch) 22 | 23 | equal = True 24 | 25 | # while的终止条件长度或者Bool 26 | while len(q_char) > 1: 27 | first = q_char.pop() 28 | last = q_char.popleft() 29 | if first != last: 30 | equal = False 31 | break 32 | 33 | return equal 34 | 35 | 36 | def test_of_pal_checker(): 37 | print(pal_checker('lsdkjfskf')) 38 | print(pal_checker('radar')) 39 | 40 | 41 | if __name__ == '__main__': 42 | test_of_pal_checker() 43 | -------------------------------------------------------------------------------- /p2_stack_and_queue/parentheses.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -- coding: utf-8 -- 3 | """ 4 | Copyright (c) 2018. All rights reserved. 5 | Created by C. L. Wang on 2018/10/29 6 | """ 7 | 8 | 9 | def par_checker(symbol_str): 10 | """ 11 | 括号匹配，list包含栈的功能 12 | append是添加，pop是删除 13 | https://docs.python.org/2/tutorial/datastructures.html 14 | 14行 15 | :param symbol_str: 符号字符串 16 | :return: 是否 17 | """ 18 | s = list() # python的list可以实现stack功能 19 | idx = 0 20 | while idx < len(symbol_str): 21 | symbol = symbol_str[idx] 22 | if symbol == '(': 23 | s.append(symbol) 24 | elif symbol == ')': 25 | s.pop() 26 | idx += 1 27 | if not s: 28 | return True 29 | else: 30 | return False 31 | 32 | 33 | def test_of_par_checker(): 34 | print(par_checker('(())')) 35 | print(par_checker('((()')) 36 | print(par_checker('(a)()((()))')) 37 | 38 | 39 | if __name__ == '__main__': 40 | test_of_par_checker() 41 | -------------------------------------------------------------------------------- /p3/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -- coding: utf-8 -- 3 | """ 4 | Copyright (c) 2018. All rights reserved. 5 | Created by C. L. Wang on 2018/10/31 6 | """ -------------------------------------------------------------------------------- /p3/traverse_tree.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -- coding: utf-8 -- 3 | """ 4 | Copyright (c) 2018. All rights reserved. 5 | Created by C. L. Wang on 2018/10/31 6 | """ 7 | 8 | 9 | class TreeClz(object): 10 | def __init__(self, data): 11 | self.left = None 12 | self.right = None 13 | self.data = data 14 | 15 | 16 | def traverse_order(tree_head): 17 | """ 18 | 遍历二叉树 19 | 前序: 0134256 20 | 中序: 3140526 21 | 后序: 3415620 22 | :param tree_head: 树的头结点 23 | :return: None 24 | """ 25 | if not tree_head: 26 | return 27 | # print(tree_head.data, end='') # 前序遍历 28 | traverse_order(tree_head.left) 29 | # print(tree_head.data, end='') # 中序遍历 30 | traverse_order(tree_head.right) 31 | # print(tree_head.data, end='') # 后序遍历 32 | 33 | 34 | def init_tree(): 35 | """ 36 | 初始化二叉数 37 | 0 38 | 1 2 39 | 3 4 5 6 40 | :return: 二叉树的根节点 41 | """ 42 | root = TreeClz(0) 43 | node1 = TreeClz(1) 44 | node2 = TreeClz(2) 45 | node3 = TreeClz(3) 46 | node4 = TreeClz(4) 47 | node5 = TreeClz(5) 48 | node6 = TreeClz(6) 49 | 50 | root.left = node1 51 | root.right = node2 52 | node1.left = node3 53 | node1.right = node4 54 | node2.left = node5 55 | node2.right = node6 56 | 57 | return root 58 | 59 | 60 | def test_tree(): 61 | tree_head = init_tree() 62 | traverse_order(tree_head) 63 | 64 | 65 | if __name__ == '__main__': 66 | test_tree() 67 | --------------------------------------------------------------------------------