python数据结构

一.排序结构
1.线性表

date = [20,52,85]
found = False
for i in range(len(date)):
    if date[i]==52:
    print(i)
    found=True
    break
    
if not found:
    print("not found")

线性查找的函数

def lines_search(date,value):
    for i in range(len(date)):
        if date[i]== value:
            return i
    return -1
data=[10,20,30,40,50,60,70]
print(lines_search(data,50))

2.选择排序
选择排序是找到列表中最小的元素与列表开头的元素交换位置，循序渐进。

#选择排序
def select(data):
    for i in range(len(data)):
        min = i
        for j in range(i+1,len(data)):
            if data[min]>data[j]:
                min =j
        data[i],data[min]= data[min],data[i]#注意这里缩进的地方，
                                            #是比完整个列表之后才替换最小值
    return data
d=[1,5,2,9,0,7,3,10]
print(select(d))

3.插入排序
插入排序是在排序过的列表中，将需要添加的数据从头进行比较，找到保存的位置并将数据插入此位置

#插入排序
def insertion_sorting(data):
    for i in range(1,len(data)):
        temp = data[i] #临时记录当前的元素
        j=i-1
        while(j>=0) and (data[j]>temp):
            data[j+1]=data[j]#元素往后移一位
            j-=1      
        data[j+1]=temp   #从临时保存的区域中回复
    return data
data=[5,6,1,0,9,8,6,3]
print(insertion_sorting(data)) 

4.冒泡算法
列表中利用元素位置的交换实现的排序算法，与冒泡现象相似，越往上气泡元素越大

#冒泡排序
def bubble_sort(data):
    for i in range(len(data)):
        for j in range(len(data)-i-1):
            if(data[j]>data[j+1]):
                data[j],data[j+1]= data[j+1],data[j]
    return data
data=[9,2,0,5,4,8,6,7]
print(bubble_sort(data))
  

二.一般结构
1.链表
（1）

#链表之节点的实现
class SingleNode(object):
    def  __init__(self,item):#单链表节点
        self.item=item       #item 存放数据
        self.next=Node       #Node 下一节点的标识

链表的操作包括

is_empty()链表是否为空
length()链表的长度
trave()遍历整个链表
add((item)在链表头部添加元素
append(item)在链表尾部添加元素
insert(pos,item)在指定位置插入元素
remove(item)删除节点
search(item)查找节点是否存在

单链表的实现代码（完整，可接待套用）

#定义一个单链表及其函数
class SingleLinkList(object):
    
    def  __init__(self,item):#单链表节点
       self.head=None
        
    def is_empty(self):#判断链表是否为空
        return self.head==None
    
    def lenth(self):#链表长度
        cur = self.head
        count = 0
        while cur!=None:
            count+=1
            cur=cur.next#cur 后移一个节点
        return count
    
    def trave(self):#遍历链表
        cur=self.head
        while cur!=None:
            print(cur.item)
            cur=cur.next
        print(' ')
    
    def add(self,item):#从头部添加元素
        node= SingleNode(item) #创建一个保存item的节点
        node.next = self.head  #将新节点的next指向头节点，作为新的head
        self.head=node     #将链表的头head指向新节点
        
        
    def append(item):#从部添加元素
        node = SingleNode(item)#创建一个节点
        if self.is_empty():    #先判断链表是否为空，为空则将head指向新节点
            self.head = node
        else:                  #若不为空，则找到尾节点，为节点的next指向新节点
            cur = self.head
            while cur.next != None:
                cur = cur.next
            cur.next =node
            
    def insert(self, pos, item):
        """指定位置添加元素"""
        # 若指定位置pos为第一个元素之前，则执行头部插入
        if pos <= 0:
            self.add(item)
        # 若指定位置超过链表尾部，则执行尾部插入
        elif pos > (self.length()-1):
            self.append(item)
        # 找到指定位置
        else:
            node = SingleNode(item)
            count = 0
            # pre用来指向指定位置pos的前一个位置pos-1，初始从头节点开始移动到指定位置
            pre = self._head
            while count < (pos-1):
                count += 1
                pre = pre.next
            # 先将新节点node的next指向插入位置的节点
            node.next = pre.next
            # 将插入位置的前一个节点的next指向新节点
            pre.next = node
            
    def remove(self,item):
        """删除节点"""
        cur = self._head
        pre = None
        while cur != None:
            # 找到了指定元素
            if cur.item == item:
                # 如果第一个就是删除的节点
                if not pre:
                    # 将头指针指向头节点的后一个节点
                    self._head = cur.next
                else:
                    # 将删除位置前一个节点的next指向删除位置的后一个节点
                    pre.next = cur.next
                break
            else:
                # 继续按链表后移节点
                pre = cur
                cur = cur.next
            
    def search(self,item):
        """链表查找节点是否存在，并返回True或者False"""
        cur = self._head
        while cur != None:
            if cur.item == item:
                return True
            cur = cur.next
        return False

2.双链表
双链表是双向单链表，最后一个节点的next指向有节点而不是None
操作包含

		is_empty() 判断链表是否为空
		length() 返回链表的长度
		travel() 遍历
		add(item) 在头部添加一个节点
		append(item) 在尾部添加一个节点
		insert(pos, item) 在指定位置pos添加节点
		remove(item) 删除一个节点
		search(item) 查找节点是否存在