基本数据结构的定义及实现

算法的复杂程度

最好情况、最坏情况和平均情况，用O()表示计算的复杂程度

平均运行时间是最有意义的，因为它是期望的运行时间，一般没有说明特殊情况说明下，都是指最坏时间复杂度

算法的空间复杂度指通过计算算法所需要的存储空间实现

基本的数据结构

线性表

零个或多个数据元素的有限序列，每个元素只有一个前驱和一个后驱元素。Python中的数组就是一个无限大容量的线性表

线性表链式存储结构

为解决线性表存储空间问题，使用节点（Node）进行存储数据本身信息，还存储一个指示后继的信息。
n个节点链接成一个链表，即为线性表（a1,a2,a3············an）
我们把第指向第一个节点的存储位置叫做头指针（一定有），线性链表的最后一个位置指针为空（NULL或^表示）

链表的查找需要从头开始，直到i个节点为止

# -*- coding: utf-8 -*-
"""
Created on Mon Nov 18 21:47:52 2019

@author: ZYS
"""
# =============================================================================
#生成一个单链表
# =============================================================================
class Node():      
    """创建一个节点的类"""
    def __init__(self,data):
        self.data = data
        self.next = None
        
    def getData(self):
        return self.data
    
    def getNext(self):
        return self.next
    
    def setData(self,newdata):
        self.data = newdata
    
    def setNext(self,newnext):
        self.next = newnext
             
class signalList():
    def __init__(self):
        self.head = None
    
    def is_empty(self):
        return self.head == None
    
    def add(self,ele):
        temp = Node(ele)            #self.head是指向一个节点的指针
        temp.setNext(self.head)     #把刚插入的节点作为原来的头节点
        self.head = temp            #列表头部head指向这个新的节点
        
    def size(self):
        current = self.head
        count = 0
        while current != None:
            count += 1
            current = current.getNext()
        return count
    def search(self,item):          #搜索指定元素，并返回所在位数
        current = self.head
        count = 0
        Found = False
        while current != None and not Found:
            if current.getData() == item:
                Found = True
            else:
                current = current.getNext()
                count += 1
        return Found, count
    
    def remove(self,item):
        current = self.head
        previous = None
        Found = False
        while not Found:
            if current.getData() == item:
                Found = True
            else:
                previous = current
                current = current.getNext()
        if previous == None:                #如果元素是开头的
            self.head = current.getNext()
        else:
            previous.setNext(current.getNext())
                
    def append(self,item):
        """在列表末端添加一个新的元素"""
        temp = Node(item)
        current = self.head
        while current != None:              #这里是为了找到最后的节点，这里的复杂程度是O(n)
            current = current.getNext()
        current.setNext(temp)
        
    def index(self,item):
        """返回元素在列表中的位置"""
        current = self.head
        count = 0
        while current.getData() != item:
            current = current.getNext()
            count += 1
        return count
    
    def insert(self,pos,item):
        current = self.head
        count = 0
        previous = None
        while count != pos:
            previous = current
            current = current.getNext()
            count += 1
        temp = Node(item)
        if previous == None:
            self.head = temp
        else:
            previous.setNext(temp)
            temp.setNext(current)
        
    def pop(self):
        current = self.head
        previous = None
        while current.getNext != None:
            previous = current
            current = current.getNext()
        if previous = None:
            return("there is no enough number to delete")
        else:
            previous.setNext(None)
        return current.getData()

栈（stack）

是限定仅在表尾进行插入和删除操作的线性表，是一种后进先出的一种数据结构(Last in first out)。
把允许插入和删除的一端称为栈顶（top）,另外一端称为栈底（bottom）;

# =============================================================================
# 栈
# =============================================================================
class Stack():
    def __init__(self):
        self.items = []
        
    def isEmpty(self):
        return self.items == []
    
    def Push(self,item):
        self.items.append(item)
        
    def pop(self):
        return self.items.pop()
        
    def peek(self):
        return self.items[-1]
    
    def size(self):
        return len(self.items)

队列（Queue）

只允许在一段进行插入操作，而在另一端进行删除操作的线性表，是一种（First in first out）的线性表。
插入的一端称为队尾（rear），删除的一端称为队首(front)

class Queue():
    """
    队列
    """
    def __init__(self):
        self.items = []
        
    def isEmpty(self):
        return self.items == []
    
    def enqueue(self,item):
        return self.items.insert(0,item)
    
    def dequeue(self):
        return self.items.pop()
    
    def size(self):
        return len(self.items)

"""
双端队列
"""
# =============================================================================
#         双端队列
# =============================================================================
class Deque():
    def __init__(self):
        self.items = []
        
    def isEmpty(self):
        return self.items == []
    def addFront(self, item):
        self.items.append(item)
    def addRear(self, item):
        self.items.insert(0,item)
    def removeFront(self):
        return self.items.pop()
    def removeRear(self):
        return self.items.pop(0)
    def size(self):
        return len(self.items)
    
# =============================================================================
# 回文词的判定
# =============================================================================
def palchecker(aString):
    checkeque = Deque()
    for ch in aString:
        checkeque.addRear(ch)
    stillEqual = True
    while checkeque.size()>1 and stillEqual:
        first = checkeque.removeFront()
        last = checkeque.removeRear()
        if first != last:
            stillEqual = False
    return stillEqual