數組

數組的設計

數組設計之初是在形式上依賴內存分配而成的，所以必須在使用前預先請求空間。這使得數組有以下特性：

???? 1、請求空間以后大小固定，不能再改變（數據溢出問題）；

???? 2、在內存中有空間連續性的表現，中間不會存在其他程序需要調用的數據，為此數組的專用內存空間；

???? 3、在舊式編程語言中（如有中階語言之稱的C），程序不會對數組的操作做下界判斷，也就有潛在的越界操作的風險（比如會把數據寫在運行中程序需要調用的核心部分的內存上）。

因為簡單數組強烈倚賴電腦硬件之內存，所以不適用于現代的程序設計。欲使用可變大小、硬件無關性的數據類型，Java等程序設計語言均提供了更高級的數據結構： ArrayList 、 Vector 等動態數組。

Python的數組

從嚴格意義上來說:Python里沒有嚴格意義上的數組。

List 可以說是Python里的數組，下面這段代碼是CPython的實現 List 的結構體:

            
typedef struct {
 PyObject_VAR_HEAD
 /* Vector of pointers to list elements. list[0] is ob_item[0], etc. */
 PyObject **ob_item;

 /* ob_item contains space for 'allocated' elements. The number
  * currently in use is ob_size.
  * Invariants:
  *  0 <= ob_size <= allocated
  *  len(list) == ob_size
  *  ob_item == NULL implies ob_size == allocated == 0
  * list.sort() temporarily sets allocated to -1 to detect mutations.
  *
  * Items must normally not be NULL, except during construction when
  * the list is not yet visible outside the function that builds it.
  */
 Py_ssize_t allocated;
} PyListObject;
          

當然，在Python里它就是數組。
后面的一些結構也將用 List 來實現。

堆棧

什么是堆棧

堆棧（英語：stack），也可直接稱棧，在計算機科學中，是一種特殊的串列形式的數據結構，它的特殊之處在于只能允許在鏈接串列或陣列的一端（稱為堆疊頂端指標，英語：top）進行加入資料（英語：push）和輸出資料（英語：pop）的運算。另外堆疊也可以用一維陣列或連結串列的形式來完成。堆疊的另外一個相對的操作方式稱為佇列。

由于堆疊數據結構只允許在一端進行操作，因而按照后進先出 （LIFO, Last In First Out） 的原理運作。

特點

???? 1、先入后出，后入先出。

???? 2、除頭尾節點之外，每個元素有一個前驅，一個后繼。

操作

從原理可知，對堆棧(棧)可以進行的操作有:

???? 1、 top() :獲取堆棧頂端對象

???? 2、 push() :向棧里添加一個對象

???? 3、 pop() :從棧里推出一個對象

實現

            
class my_stack(object):
 def __init__(self, value):
  self.value = value
  # 前驅
  self.before = None
  # 后繼
  self.behind = None

 def __str__(self):
  return str(self.value)


def top(stack):
 if isinstance(stack, my_stack):
  if stack.behind is not None:
   return top(stack.behind)
  else:
   return stack


def push(stack, ele):
 push_ele = my_stack(ele)
 if isinstance(stack, my_stack):
  stack_top = top(stack)
  push_ele.before = stack_top
  push_ele.before.behind = push_ele
 else:
  raise Exception('不要亂扔東西進來好么')


def pop(stack):
 if isinstance(stack, my_stack):
  stack_top = top(stack)
  if stack_top.before is not None:
   stack_top.before.behind = None
   stack_top.behind = None
   return stack_top
  else:
   print('已經是棧頂了')
          

隊列

什么是隊列

和堆棧類似，唯一的區別是隊列只能在隊頭進行出隊操作，所以隊列是是先進先出 （FIFO, First-In-First-Out） 的線性表

特點

????? 1、先入先出,后入后出

???? ?2、除尾節點外,每個節點有一個后繼

????? 3、（可選）除頭節點外,每個節點有一個前驅

操作

????? 1、 push（） :入隊

????? 2、 pop（） ：出隊

實現

普通隊列

            
class MyQueue():
 def __init__(self, value=None):
  self.value = value
  # 前驅
  # self.before = None
  # 后繼
  self.behind = None

 def __str__(self):
  if self.value is not None:
   return str(self.value)
  else:
   return 'None'


def create_queue():
 """僅有隊頭"""
 return MyQueue()


def last(queue):
 if isinstance(queue, MyQueue):
  if queue.behind is not None:
   return last(queue.behind)
  else:
   return queue


def push(queue, ele):
 if isinstance(queue, MyQueue):
  last_queue = last(queue)
  new_queue = MyQueue(ele)
  last_queue.behind = new_queue


def pop(queue):
 if queue.behind is not None:
  get_queue = queue.behind
  queue.behind = queue.behind.behind
  return get_queue
 else:
  print('隊列里已經沒有元素了')

def print_queue(queue):
 print(queue)
 if queue.behind is not None:
  print_queue(queue.behind)
          

鏈表

什么是鏈表

鏈表（Linked list）是一種常見的基礎數據結構，是一種線性表，但是并不會按線性的順序存儲數據，而是在每一個節點里存到下一個節點的指針(Pointer)。由于不必須按順序存儲，鏈表在插入的時候可以達到O(1)的復雜度，比另一種線性表順序表快得多，但是查找一個節點或者訪問特定編號的節點則需要O(n)的時間，而順序表相應的時間復雜度分別是O(logn)和O(1)。

特點

使用鏈表結構可以克服數組鏈表需要預先知道數據大小的缺點，鏈表結構可以充分利用計算機內存空間，實現靈活的內存動態管理。但是鏈表失去了數組隨機讀取的優點，同時鏈表由于增加了結點的指針域，空間開銷比較大。

操作

????? 1、 init() :初始化

????? 2、 insert() : 插入

????? 3、 trave() : 遍歷

????? 4、 delete() : 刪除

??????5、 find() : 查找

實現

此處僅實現雙向列表

            
class LinkedList():
 def __init__(self, value=None):
  self.value = value
  # 前驅
  self.before = None
  # 后繼
  self.behind = None

 def __str__(self):
  if self.value is not None:
   return str(self.value)
  else:
   return 'None'


def init():
 return LinkedList('HEAD')


def delete(linked_list):
 if isinstance(linked_list, LinkedList):
  if linked_list.behind is not None:
   delete(linked_list.behind)
   linked_list.behind = None
   linked_list.before = None
  linked_list.value = None
          

總結

以上就是利用Python實現基本線性數據結構的全部內容，希望這篇文章對大家學習Python能有所幫助。如果有疑問可以留言討論。