排序，数据结构-python

一、几种基本排序算法

1、冒泡

<span style="font-size:18px;"><span style="font-size:18px;">class pop:
    def __init__(self,val):
        self.val=list(val)
    def getpop(self):
        val=list(self.val)
        for i in range(len(val)-1):
            for j in range(i+1,len(val)):
                if val[i]>val[j]:
                    val[i],val[j]=val[j],val[i]
        return val


if __name__=="__main__":
    p=pop((5,4,3,6,1))
    print p.getpop()
</span></span>

2、选择

<span style="font-size:18px;">class sel:
    def __init__(self,val):
        self.val=list(val)
    def getsel(self):
        a=self.val
        for i in range(len(a)-1):
            k=i
            for j in range(i+1,len(a)):
                if a[k]>a[j]:
                    k=j
            a[k],a[i]=a[i],a[k]
        print  a

if __name__=="__main__":
    s=sel((5,4,3,6,1,7))
    s.getsel()
</span>

3、插入

<span style="font-size:18px;">class inst:
    def __init__(self,val):
        self.val=list(val)

    def getinst(self):
        val=self.val
        for i in range(1,len(val)):
            j=i-1
            while j>=0 and val[j]>val[i]:
                val[i],val[j]=val[j],val[i]
                j-=1
                i-=1
        print val

if __name__=="__main__":
    ins=inst((5,4,3,6,7,1))
    ins.getinst()
</span>

4、快排

<span style="font-size:18px;">import random
def QuickSort(num):
    if len(num)<=1:
        return num
    greater=[]
    less=[]
    p=num.pop(random.randint(0,len(num)-1))
    for item in num:
        if item < p:
            less.append(item)
        else:
            greater.append(item)
    return QuickSort(less)+[p]+QuickSort(greater)


print QuickSort([5,4,3,6,7])
</span>

 

5、归并

 

 

<span style="font-size:18px;">def MergerSort(num):
    if len(num)<=1:
        return num
    left=MergerSort(num[:len(num)/2])
    right=MergerSort(num[len(num)/2:])
    print left
    print right
    result=[]
    while len(left)>0 and len(right)>0:
        if left[0]>right[0]:
            result.append(right.pop(0))
        else:
            result.append(left.pop(0))
    if len(left)>0:
        result.extend(MergerSort(left))
    else:
        result.extend(MergerSort(right))
    return result
MergerSort([5,4,3,6,1,7])
</span>

 

 

 

二、数据结构

 

 

1、树（前序遍历、中序遍历、后序遍历）

<span style="font-size:18px;"># -*- coding: utf-8 -*-
class Treenode:
    def __init__(self):
        self.val='*'
        self.left=None
        self.right=None

class Tree:
    def create_tree(self,treenode):
        data=raw_input('输入结点值：')
        if data=='*':treenode=None
        else:
            treenode.val=data
            treenode.left=Treenode()
            self.create_tree(treenode.left)
            treenode.right=Treenode()
            self.create_tree(treenode.right)

    def visit(self,treenode):
        if treenode is not '*':
            print str(treenode.val)+'\t',
    def pre(self,treenode):
        if treenode is not None:
            self.visit(treenode)
            self.pre(treenode.left)
            self.pre(treenode.right)

    def mid(self,treenode):
        if treenode is not None:
            self.mid(treenode.left)
            self.visit(treenode)
            self.mid(treenode.right)

    def post(self,treenode):
        if treenode is not None:
            self.post(treenode.left)
            self.post(treenode.right)
            self.visit(treenode)
if __name__=="__main__":
    t=Treenode()
    tree=Tree()
    tree.create_tree(t)
    tree.pre(t)
    print '\n'
    tree.mid(t)
    print '\n'
    tree.post(t)
</span>

由前序遍历+中序遍历重建二叉树：

<span style="font-size:18px;">class  Node:
    def __init__(self,val):
        self.val=val
        self.left=None
        self.right=None
class retree:
    def rebulid(self,pre,mid):
        pre=list(pre)
        mid=list(mid)
        if not pre or not mid:return
        root=Node(pre[0])
        i=mid.index(root.val)
        root.left=self.rebulid(pre[1:i+1],mid[:i])
        root.right=self.rebulid(pre[i+1:],mid[i+1:])
        return root

if __name__=="__main__":
    a=[5,4,3,6,1,7]
    b=[3,4,5,1,7,6]
    test=retree()
    n=test.rebulid(a,b)   
</span>

2、链表（遍历）

<span style="font-size:18px;">class Node:
    def __init__(self):
        self.val='*'
        self.next=None

class List:
    def create_list(self,node):
        data=raw_input('please input some numbers: \n')
        if data=='*':
            node=None
        else :
            node.val=data
            node.next=Node()
            self.create_list(node.next)
    def get_list(self,node):
        while( node is not None):
            print node.val
            node=node.next
if __name__=="__main__":
    t=Node()
    ls=List()
    ls.create_list(t)
    ls.get_list(t)
</span>

链表的全部：

<span style="font-size:18px;">#!/usr/bin/python
# -*- coding: utf-8 -*-

class Node(object):
    def __init__(self,val,p=0):
        self.data = val
        self.next = p

class LinkList(object):
    def __init__(self):
        self.head = 0

    def __getitem__(self, key):

        if self.is_empty():
            print 'linklist is empty.'
            return

        elif key <0  or key > self.getlength():
            print 'the given key is error'
            return

        else:
            return self.getitem(key)



    def __setitem__(self, key, value):

        if self.is_empty():
            print 'linklist is empty.'
            return

        elif key <0  or key > self.getlength():
            print 'the given key is error'
            return

        else:
            self.delete(key)
            return self.insert(key)

    def initlist(self,data):

        self.head = Node(data[0])

        p = self.head

        for i in data[1:]:
            node = Node(i)
            p.next = node
            p = p.next

    def getlength(self):

        p =  self.head
        length = 0
        while p!=0:
            length+=1
            p = p.next

        return length

    def is_empty(self):

        if self.getlength() ==0:
            return True
        else:
            return False

    def clear(self):

        self.head = 0


    def append(self,item):

        q = Node(item)
        if self.head ==0:
            self.head = q
        else:
            p = self.head
            while p.next!=0:
                p = p.next
            p.next = q


    def getitem(self,index):

        if self.is_empty():
            print 'Linklist is empty.'
            return
        j = 0
        p = self.head

        while p.next!=0 and j <index:
            p = p.next
            j+=1

        if j ==index:
            return p.data

        else:

            print 'target is not exist!'

    def insert(self,index,item):

        if self.is_empty() or index<0 or index >self.getlength():
            print 'Linklist is empty.'
            return

        if index ==0:
            q = Node(item,self.head)

            self.head = q

        p = self.head
        post  = self.head
        j = 0
        while p.next!=0 and j<index:
            post = p
            p = p.next
            j+=1

        if index ==j:
            q = Node(item,p)
            post.next = q
            q.next = p


    def delete(self,index):

        if self.is_empty() or index<0 or index >self.getlength():
            print 'Linklist is empty.'
            return

        if index ==0:
            q = Node(item,self.head)

            self.head = q

        p = self.head
        post  = self.head
        j = 0
        while p.next!=0 and j<index:
            post = p
            p = p.next
            j+=1

        if index ==j:
            post.next = p.next

    def index(self,value):

        if self.is_empty():
            print 'Linklist is empty.'
            return

        p = self.head
        i = 0
        while p.next!=0 and not p.data ==value:
            p = p.next
            i+=1

        if p.data == value:
            return i
        else:
            return -1


l = LinkList()
l.initlist([1,2,3,4,5])
print l.getitem(4)
l.append(6)
print l.getitem(5)

l.insert(4,40)
print l.getitem(3)
print l.getitem(4)
print l.getitem(5)

l.delete(5)
print l.getitem(5)

l.index(5)</span>