python之 算法和数据结构

什么是计算机科学?

　　--首先明确的一点就是计算机科学不仅仅是对计算机的研究,虽然计算机在科学发展的过程中发挥了重大的作用,但是它只是一个工具,一个没有灵魂的工具而已,所谓的计算机科学实际上是对问题,解决问题以及解决问题的过程中产生的解决方案的研究.

意义:

　　--数据结构和算法思想的通常性异常的强大,在任何语言中都被使用,它们将会是我们编程生涯张伴随我们最长久利器.

　　--数据结构和算法思想也可以帮助我们扩展和历练编码的思想,可以让我们更好的融入到编程世界的角角落落.

数据结构

栈

　　--特性:先进后出的数据结构

　　--栈顶,栈尾

Stack() 创建一个空的新栈。 它不需要参数，并返回一个空栈。
push(item)将一个新项添加到栈的顶部。它需要 item 做参数并不返回任何内容。
pop() 从栈中删除顶部项。它不需要参数并返回 item 。栈被修改。
peek() 从栈返回顶部项，但不会删除它。不需要参数。 不修改栈。
isEmpty() 测试栈是否为空。不需要参数，并返回布尔值。
size() 返回栈中的 item 数量。不需要参数，并返回一个整数

关键字

class Stack():
    def __init__(self):
        self.items=[]
    def push(self,item):
        self.items.append(item)
    def isEmpty(self):
        return self.items==[]
    def pop(self):
        if self.isEmpty():
            return '空'
        else:
            return self.items.pop()
    def peek(self):
        return self.items[len(self.items)-1]
    def size(self):
        return  len(self.items)

a=Stack()
a.push(1)
a.push(2)
print(a.peek())
print(a.pop())
print(a.size())

队列

　　--特性:先进先出

Queue() 创建一个空的新队列。 它不需要参数，并返回一个空队列。
enqueue(item) 将新项添加到队尾。 它需要 item 作为参数，并不返回任何内容。
dequeue() 从队首移除项。它不需要参数并返回 item。 队列被修改。
isEmpty() 查看队列是否为空。它不需要参数，并返回布尔值。
size() 返回队列中的项数。它不需要参数，并返回一个整数。

关键字

class Queue():
    def __init__(self):
        self.items=[]
    def enqueue(self,item):
        self.items.insert(0,item)
    def isEmpty(self):
        return self.items==[]
    def dequeue(self):
        if self.isEmpty():
            return '空'
        else:
            return self.items.pop()
    def size(self):
        return  len(self.items)
    def travel(self):
        print(self.items)
q=Queue()
q.enqueue(1)
q.enqueue(2)
print(q.size())
print(q.travel())

双端队列

　　--同列相比,两个头部和尾部.可以在双端进行数据的插入和删除,提供了单数据结构中栈和队列的特性

Deque() 创建一个空的新 deque。它不需要参数，并返回空的 deque。
addFront(item) 将一个新项添加到 deque 的首部。它需要 item 参数 并不返回任何内容。
addRear(item) 将一个新项添加到 deque 的尾部。它需要 item 参数并不返回任何内容。
removeFront() 从 deque 中删除首项。它不需要参数并返回 item。deque 被修改。
removeRear() 从 deque 中删除尾项。它不需要参数并返回 item。deque 被修改。
isEmpty() 测试 deque 是否为空。它不需要参数，并返回布尔值。
size() 返回 deque 中的项数。它不需要参数，并返回一个整数。

关键字

class Dequeue():
    def __init__(self):
        self.items = []
    def addFont(self,item):
        self.items.append(item)
    def addRear(self,item):
        self.items.insert(0,item)
    def isEmpty(self):
        return self.items == []
    def removeFont(self):
        if self.isEmpty():
            return None
        else:
            return self.items.pop()

    def removeRear(self):
        if self.isEmpty():
            return None
        else:
            return self.items.pop(0)
    def size(self):
        return len(self.items)

算法

冒泡排序

list=[1,4,6,5,2,3]

# def sort(alist):
#     length = len(alist)
#     for i in  range(0,length-1):
#         for j in range(0,length-1-i):  #6-1
#             print(list)
#             print(alist[j+1])
#             if alist[j] >alist[j+1]:
#                 alist[j],alist[j+1]=alist[j+1],alist[j]
#
# sort(list)
#
#
# print(list)
#思想:每次比较来年各个相邻的元素,如果他们的顺序错误就把他们的位置交换
#缺点:冒泡排序解决了桶排序浪费空间的问题,但是冒泡排序的效率特别低

选择排序

list=[1,4,6,5,2,3]
# def sort(alist):
#     length=len(alist)
#     for j in range(length-1,0,-1):
#         max_index= 0
#         for i in range(1,j+1):
#             if alist[max_index] < alist[i]:
#                 max_index = i
#                 print(alist[max_index] )
#         alist[max_index], alist[j] = alist[j], alist[max_index]
#
# sort(list)
# print(list)
#总结:先从列表中,第一个值的后面必需都比他小,,这个位置的值就会与最后一个最小的值交换位置

插入排序

list=[1,4,6,5,2,3]
# def sort(alist):
#     length =len(alist)
#     for j in range(1,length):
#         i=j
#         while i>0 :
#             if alist[i] < alist[i - 1]:
#                 alist[i], alist[i - 1] = alist[i - 1], alist[i]
#                 i -= 1
#                 print(list)
#             else:
#                 break
# sort(list)
# print(list)
#结论:每回都是两个相邻的值对比,如果前面的值大于后面的值就交换,否则不交换,知道循环完

快排

def sort(alist,start,end):
    low = start
    high = end
    if low >= high:
        return
    mid = alist[low]
    while low < high:
        while low < high:
            if alist[high] >= mid:
                high -= 1
            else:
                alist[low] = alist[high]
                break

        while low < high:
            if alist[low] < mid:
                low += 1
            else:
                alist[high] = alist[low]
                break

    alist[low] = mid  ####
    #在mid左侧列表中递归调用该函数
    sort(alist,start,low-1)
    #mid右侧
    sort(alist,high+1,end)

sort(list,0,len(list)-1)
print(list)