python中的数据结构与算法

语言:python3.4

一、排序算法
1.冒泡排序

def bubblesort(l):
    print(l)
    for i in range(len(l)-1,0,-1):
        flag = 1
        for j in range(i):
            if l[j] > l[j+1]:
                l[j],l[j+1] = l[j+1],l[j]
                #上面的表达式相当于c中的
                #temp=l[j+1]
                #l[j+1]=l[j]
                #l[j]=temp
                flag = 0
        if flag:
            break
    print(l)

总体评价：
1).平均时间复杂度：O(N²)
2).对数组有序性敏感

2.插入排序

def insertsort(l):
    print(l)
    for i in range(1,len(l)):
        temp=l[i]
        for j in range(i-1,-1,-1):
            if temp >= l[j]:
                break
            else:
                l[j+1] = l[j]
                l[j] = temp
    print(l)

总体评价:
1).平均时间复杂度O(N²)
2).对数组有序性敏感
3).数据不进行交换，优于冒泡

3.选择排序

def selectionSort(l):
    print(l)
    for i in range(len(l)):
        for j in range(i+1,len(l)):
            if l[i] > l[j]:
                l[i],l[j] = l[j],l[i]
    print(l)

总体评价：
1).平均时间复杂度O(N²)
2).对数组的有序性不敏感
3).交换次数少，由于冒泡

4.快速排序

import sys
sys.setrecursionlimit(10000)
#手动设置递归次数10000次，默认为900次
def subSort(l,left,right):
    start = left
    end = right
    flag = l[right]
    while left < right:
        if l[left] > flag:
            l[left],l[right] = l[right],l[left]
            right-=1
        else:
            left+=1
            continue
        if left < right:
            if l[right] <= flag:
                l[left],l[right] = l[right],l[left]
                left+=1
            else:
                right-=1
    if left-start>1:
        subSort(l,start,left-1)
    if end-left>1:
        subSort(l,left+1,end)

总体评价：
1).平均时间复杂度O(NlogN)
2).对样本的有序性敏感

5 堆排序

def fixUpToDown(l,t,n): #从上往下堆化，从t开始
    while 2*t < n:
        i = 2*t #表示t结点的左子节点
        if i < n-1 and l[i] < l[i+1]:
            i += 1
        if l[i] > l[t]:
            l[i],l[t] = l[t],l[i]
            t = i
        else:
            break

def heapSort(l):
    n = len(l)-1 
    for i in range(n//2,0,-1):
        fixUpToDown(l,i,len(l))
    #此时root结点为最大值，交换最大值与最后一个元素
    while n>1:
        l[1],l[n] = l[n],l[1]
        fixUpToDown(l,1,n)
        n-=1
    return l[1:]

二、查找算法
1.线性查找

在序列中从一端开始逐个检查每个元素是否为要查找的元素，直到找到为止。实现比较简单，不列出了

2.二分查找
注意：二分查找的前提是序列必须有序

def BinarySearch(l,element):
    left = 0
    right = len(l) - 1

    while left <= right:
        mid = (left + right) // 2 # //表示整除
        if l[mid] < element:
            left = mid + 1
        elif l[mid] > element:
            right = mid - 1
        else:
            return l[mid]

    print("未找到")

三、数据结构
1.栈的实现

class Stack:
    def __init__(self,size=10):
        self.stack = []
        self.top = -1
        self.size = size

    def isEmpty(self):
        if not self.stack:
            return True
        else:
            return False

    def isFull(self):
        if self.top+1 == self.size:
            return True
        else:
            return False

    def top(self):
        if self.isEmpty():
            print("The Stack is empty")
        else:
            return self.stack[self.top]

    def push(self,element):
        if self.isFull():
            print("The Stack is Full")
        else:
            self.stack.append(element)
            self.top += 1

    def pop(self):
        if self.isEmpty():
            print("The Stack is empty")
        else:
            return self.stack.pop()
            self.top -= 1

    def display(self):
        print(self.stack)

2.队列的实现:

class Queue:
    def __init__(self):
        self.queue = []
        self.front = 0
        self.rear = -1
        self.size = 0

    def isEmpty(self):
        if not self.size:
            return True
        else:
            return False

    def getSize(self):
        return self.size

    def push(self,element):
        self.queue.append(element)
        self.rear += 1
        self.size += 1

    def pop(self):
        if self.isEmpty():
            print("The Queue is empty")
        else:
            self.rear -= 1
            self.size -= 1
            return self.queue.pop(self.front)

    def topData(self):
        if self.isEmpty():
            print("The Queue is empty")
        else:
            return self.queue[self.front]

    def display(self):
        print(self.queue)

#python每个函数都有一个默认的返回值None

3.二叉树的实现

class TreeNode(object):
    def __init__(self,data=None,left=None,right=None):
        self.data = data
        self.left = left
        self.right = right

class BinaryTree(object):
    def __init__(self,data):
        self.root = data

    def isEmpty(self):
        if not self.root:
           return True 
        else:
            return False

    def preOrder(self,treenode):
        if not treenode:
            return
        print(treenode.data)
        self.preOrder(treenode.left)
        self.preOrder(treenode.right)

    def inOrder(self,treenode):
        if not treenode:
            return
        self.inOrder(treenode.left)
        print(treenode.data)
        self.inOrder(treenode.right)

    def postOrder(self,treenode):
        if not treenode:
            return
        self.postOrder(treenode.left)
        self.postOrder(treenode.right)
        print(treenode.data)

数据结构和算法就先列这么多，后续继续添加