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())

View Code

隊列

　　--特性:先進先出

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())

View Code

雙端隊列

　　--同列相比,兩個頭部和尾部.能夠在雙端進行數據的插入和刪除,提供了單數據結構中棧和隊列的特性

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)

View Code

算法

冒泡排序

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)