Sword finger offer note 8: summary of data structure (p37-72)
- Representation of one dimensional array
- Representation of two dimensional array
- Basic operation of array
- Character string
- Linked list
- Two fork tree
- Node type of binary tree
- Basic operation of binary tree
- Deformation of binary tree
- Other tree structure
- Stack and queue
- Knowledge map of data structure
An array is the data that occupies a block of continuous memory and is stored sequentially. In Python, arrays are usually represented by lists. The array can be read and written in O(1) time, and the array represented by list in Python also saves the trouble of moving other elements when inserting / deleting. In addition, we can use the relationship between array subscripts and elements to implement a simple hash table.
One dimensional array represented by list
>>>arr1 = [1, 2, 3, 4, 5] >>>arr1 [1, 2, 3, 4, 5]
One dimensional array represented by numpy
>>>import numpy as np >>>arr2 = np.asarray(arr1) >>>arr2 array([1, 2, 3, 4, 5])
You can see the difference between arrays represented by lists and arrays represented by numpy
>>>print(arr1) [1, 2, 3, 4, 5] >>>print(arr2) [1 2 3 4 5]
It is not allowed to use numpy, such as leetCode, so the following is not an example of numpy. For the usage of numpy, please refer to NumPy tutorial | rookie tutorial
The following is an array with two rows and three columns
>>>arr3 = [[1, 2, 3], [4, 5, 6]] >>>arr3 [[1, 2, 3], [4, 5, 6]]
Here are some basic operations about arrays, which are basically the basic operations of lists in python. For more information, please refer to Python 3 list - rookie tutorial
For example, one-dimensional array is used. If the operation of two-dimensional array is similar, it is not written
Two dimensional array rows
Number of columns in 2D array
>>>arr1 3 >>>arr1 = 0 >>>arr1 [1, 2, 0, 4, 5]
Last element in array
>>>arr1.insert(2, 9) >>>arr1 [1, 2, 9, 0, 4, 5]
Array tail insertion
>>>arr1.append(8) >>>arr1 [1, 2, 9, 0, 4, 5, 8]
>>>arr1 [1, 2, 9, 0, 4, 5, 8] >>>del arr1 >>>arr1 [1, 2, 0, 4, 5, 8]
Take the last element of the array and delete it
>>>arr1 [1, 2, 0, 4, 5, 8] >>>a = arr1.pop() >>>a 8 >>>arr1 [1, 2, 0, 4, 5]
There is no end mark for strings in Python, and the operation is not as complicated as c language. Here is a complete Python 3 string tutorial Python 3 string rookie tutorial , I won't write more.
A linked list is a chain structure that links many single nodes with a pointer. In Python, you need to construct the node type of a linked list.
The node type of single chain table only needs two parts, one is the node value, the other is the pointer to the next node.
class ListNode: # Link list node definition def __init__(self, x): self.val = x self.next = None
Here is the code that initializes the list into a single chain table and returns the header pointer of the single chain table.
class LinkList(object): # Initialization of linked list def __init__(self): self.head = 0 # Initialize list as linked list def initlist(self, items): self.head = ListNode(items) # Define the header pointer first, that is, its value is the first element in items p = self.head # Set a move pointer to add the next elements of items in a single chain table for item in items[1:]: # Traverse the remaining elements in items node = ListNode(item) # Create a new listNode type for the element p.next = node # Move p pointer p = p.next return self.head
In a binary tree, each node has at most two children. In Python, you need to construct a node type of binary tree.
The node type of binary tree includes three parts: node value and pointer of left and right child nodes.
class TreeNode: def __init__(self, x): self.val = x self.left = None self.right = None
There are many contents of binary tree, I intend to brush the whole book to make a systematic summary of binary tree. Only a brief overview is given here.
- Preorder traversal: root → left → right
- Middle order traversal: left → root → right
- Backward traversal: left → right → root
- Breadth first traversal (breadth first traversal): from top to bottom, from left to right
Here are the previous notes, which include the code to build a binary tree according to the middle order traversal and the first order traversal and the code to build a binary tree according to the middle order traversal and the second order traversal.
Sword finger offer note 4: rebuilding a binary tree (Python)
Balanced binary tree, binary search tree, binary sort tree, Huffman tree, large and small top heap
B tree and B+ tree
The stack is characterized by last in, first out, like a tube for badminton. In Python, use lists to mimic stacks. The stack pressing operation is to insert at the end of the list, and the pop-up operation is to delete the last element of the list (I've seen the operation in the list header, but I think it's easier to operate at the end of the list).
class Stack: # Definition of stack def __init__(self): self.items =  # Stack, equivalent to inserting at the end of the list def push(self, item): self.items.append(item) # Pop stack, same as pop() method of list def pop(self): return self.items.pop() # Judge whether the stack is empty def is_empty(self): return self.size() == 0 # Stack size def size(self): return len(self.items) # Returns the top element of the stack, the last element in the list def peak(self): return self.items[-1]
The characteristics of queues are first in, first out. In Python, lists are used to simulate the operation of queues. To join a team is to insert after the list, and to leave a team is to delete the list header.
class Queue: # Definition of queue def __init__(self): self.items =  # Team entry, equivalent to inserting at the end of the list def en_que(self, item): self.items.append(item) # Out of line, i.e. delete the first element in the list and return it def un_que(self): elem = self.items self.items = self.items[1:] return elem # Judge whether the queue is empty def is_empty(self): return self.size() == 0 # Size of the queue def size(self): return len(self.items) # Returns the last element in the list def tail(self): return self.items[-1]
Here is a summary based on the undergraduate textbook (below)