python常用算法

1.无序表查找：是数据不排序的线性查找，遍历数据元素

 

1. def sequential_search(slist, key):

2. for i in xrange(len(slist)):

3. if slist[i] == key:

4. return i

5. return -1

6.  

7. sindex = sequential_search([1,3,4,7,5,8,2,9,6], 3)

8. print sindex

2.二分查找：查找表中不断取中间元素与查找值进行比较，以二分之一的倍率进行表范围的缩小

1. def middle_search(mlist,value):

2.     if value > mlist[-1] or value < mlist[0]:

3.         return -1

4.     else:

5.         start,end = 0,len(mlist)

6.         while start < end:

7.             middle = (start+end)/2

8.             if mlist[middle] == value:

9.                 return middle

10.             elif mlist[middle] > value:

11.                 end = middle

12.             else:

13.                 start = middle

14.         return -1

15.  

16. mindex = middle_search([1,2,3,4,5,6,7,8,9], 1)

17. print mindex

3.二叉排序树：二叉排序树又称为二叉查找树；若它的左子树不为空，则左子树上所有节点的值均小于它的根结构的值；若它的右子树不为空，则右子树上所有节点的值均大于它的根结构的值；它的左、右子树也分别为二叉排序树

1. # -*- coding:utf-8 -*-

2.  

3. class BSTNode:

4. """

5. 定义一个二叉树节点类。

6. 以讨论算法为主，忽略了一些诸如对数据类型进行判断的问题。

7. """

8. def __init__(self, data, left=None, right=None):

9. """

10. 初始化

11. :param data: 节点储存的数据

12. :param left: 节点左子树

13. :param right: 节点右子树

14. """

15. self.data = data

16. self.left = left

17. self.right = right

18.  

19. class BinarySortTree:

20. """

21. 基于BSTNode类的二叉排序树。维护一个根节点的指针。

22. """

23. def __init__(self):

24. self._root = None

25.  

26. def is_empty(self):

27. return self._root is None

28.  

29. def search(self, key):

30. """

31. 关键码检索

32. :param key: 关键码

33. :return: 查询节点或None

34. """

35. bt = self._root

36. while bt:

37. entry = bt.data

38. if key < entry:

39. bt = bt.left

40. elif key > entry:

41. bt = bt.right

42. else:

43. return entry

44. return None

45.  

46. def insert(self, key):

47. """

48. 插入操作

49. :param key:关键码

50. :return: 布尔值

51. """

52. bt = self._root

53. if not bt:

54. self._root = BSTNode(key)

55. return

56. while True:

57. entry = bt.data

58. if key < entry:

59. if bt.left is None:

60. bt.left = BSTNode(key)

61. return

62. bt = bt.left

63. elif key > entry:

64. if bt.right is None:

65. bt.right = BSTNode(key)

66. return

67. bt = bt.right

68. else:

69. bt.data = key

70. return

71.  

72. def delete(self, key):

73. """

74. 二叉排序树最复杂的方法

75. :param key: 关键码

76. :return: 布尔值

77. """

78. p, q = None, self._root # 维持p为q的父节点，用于后面的链接操作

79. if not q:

80. print("空树！")

81. return

82. while q and q.data != key:

83. p = q

84. if key < q.data:

85. q = q.left

86. else:

87. q = q.right

88. if not q: # 当树中没有关键码key时，结束退出。

89. return

90. # 上面已将找到了要删除的节点，用q引用。而p则是q的父节点或者None（q为根节点时）。

91. if not q.left:

92. if p is None:

93. self._root = q.right

94. elif q is p.left:

95. p.left = q.right

96. else:

97. p.right = q.right

98. return

99. # 查找节点q的左子树的最右节点，将q的右子树链接为该节点的右子树

100. # 该方法可能会增大树的深度，效率并不算高。可以设计其它的方法。

101. r = q.left

102. while r.right:

103. r = r.right

104. r.right = q.right

105. if p is None:

106. self._root = q.left

107. elif p.left is q:

108. p.left = q.left

109. else:

110. p.right = q.left

111.  

112. def __iter__(self):

113. """

114. 实现二叉树的中序遍历算法,

115. 展示我们创建的二叉排序树.

116. 直接使用python内置的列表作为一个栈。

117. :return: data

118. """

119. stack = []

120. node = self._root

121. while node or stack:

122. while node:

123. stack.append(node)

124. node = node.left

125. node = stack.pop()

126. yield node.data

127. node = node.right

1. lis = [62, 58, 88, 48, 73, 99, 35, 51, 93, 29, 37, 49, 56, 36, 50]

2. bs_tree = BinarySortTree()

3. for i in range(len(lis)):

4. bs_tree.insert(lis[i])

5.  

6. for i in bs_tree:

print i