# preface

Data structure is the way that computer stores and organizes data. A data structure is a collection of data elements that have one or more specific relationships with each other. In general, carefully selected data structures can bring higher operation or storage efficiency. Data structure is often related to efficient retrieval algorithm and index technology.

# I Parent class Struct

## 1. Why implement this class

1. It specifies the basic concept of data structure, which can standardize some basic functions and functions of various data

2. In order to look good (in fact, it's more normative)

## 2. Code

class Struct(): def __len__(self):pass def __contains__(self,item):pass def Clear(self):pass def IsNull(self):pass

## 3. Interpretation

Naturally, needless to say, the len attribute is a data structure that stores data. Len can obtain the amount of data internally

Contents is implemented in the contents of the list. You can also write your own search algorithm

The Clear function is used to Clear

IsNull determines whether it is empty

# II Stack stack

## 1. Definition of stack

Stack, also known as stack, is a linear table with limited operation. Limit linear tables to insert and delete only at the end of the table. This end is called the top of the stack, and the other end is called the bottom of the stack. Inserting a new element into a stack is also called stack entry, stack entry or stack pressing. It puts the new element above the top element of the stack to make it a new top element; Deleting an element from a stack is also called out of stack or out of stack. It deletes the top element of the stack and makes its adjacent elements become new top elements.

## 2. Code

import Struct class Stack(Struct.Struct): StackSpace=1024 def __init__(self): self.__index=-1 #Integer, pointer self.__datas=[None]*Stack.StackSpace #Data pool def __len__(self): if(self.__index<0):return 0 else:return self.__index+1 def __contains__(self,item): return self.__datas.__contains__(item) def IsNull(self): return self.__index<0 def Clear(self): self.__index=-1 self.__datas.clear() def Push(self,obj): self.__index+=1 self.__datas[self.__index]=obj def Pop(self): if(self.__index==-1):return False else: data=self.__datas[self.__index] del(self.__datas[self.__index]) self.__index-=1 return data def Top(self): if(self.__index==-1):return None else:return self.__datas[self.__index]

## 3. Interpretation

1. The push function is used to press the stack, and the list feature in Python determines that the stack is a multi-type structure. There is no limit on the data of pressing the stack, but the initial StackSpace specifies the maximum capacity of the stack. In fact, list is used Append to add elements is a better solution, but StackSpace also plays the role of data specification

2.Pop function is used to return the stack and return the value of the exited element

3. The top function is used to obtain the top element of the stack

# III Queue queue

## 1. Definition of queue

Queue is a special linear table, which only allows deletion at the front of the table and insertion at the back of the table. Like stack, queue is a linear table with limited operation. The end that performs the insertion operation is called the tail of the queue, and the end that performs the deletion operation is called the head of the queue.

## 2. Code

import Struct class Queue(Struct.Struct): QueueSpace=1024 def __init__(self): self.__datas=[None]*Queue.QueueSpace self.__end=-1 def __len__(self): if(self.__end<0):return 0 else: return self.__end+1 def __contains__(self, item): return self.__datas.__contains__(item) def IsNull(self): return self.__end<0 def Clear(self): self.__datas=[None]*Queue.QueueSpace self.__end=-1 def Add(self,obj): self.__end+=1 self.__datas[self.__end]=obj def Delete(self): if(self.__end<0):return False data=self.__datas[0] del(self.__datas[0]) #Delete this element self.__end-=1 #Moving tail index return data def GetHead(self): if(self.__end<0):return None return self.__datas[0]

## 3. Interpretation

1. The add function is similar to the Push function in Stack, but the difference is that the data nodes for adding data and deleting data in Queue are different

2. The delete function is similar to the Pop function in Stack, but by observing the code, you can find that the added element is at the end, the deleted element is at the beginning, and the storage arrangement is moving forward in memory

3.GetHead function gets the first element because the built-in del function is used in the Delete function. After calling the Delete function, self__ Data [0] is the location of the latter element

# IV Tree tree

## 1. Definition of tree

Tree is a kind of data structure. It is a set with hierarchical relationship composed of n(n ≥ 1) finite nodes. It is called "tree" because it looks like an upside down tree, that is, it has its roots up and its leaves down. It has the following characteristics:

Each node has zero or more children; A node without a parent node is called a root node; Each non root node has only one parent node; In addition to the root node, each child node can be divided into multiple disjoint subtrees.

## 2. Code

import Struct class TreeNode(Struct.Struct): def __init__(self, value, son): self.__son = [] self.__value = value for i in son: self.__son.append(i) def __len__(self): tmp = TreeNode.GetAllNode(self) return len(tmp) def __contains__(self, item): tmp = TreeNode.GetAllNode(self) return tmp.__contains__(item) def IsNull(self): return len(self.__son) == 0 def Clear(self): self.__son = [] def AddSon(self, obj): self.__son.append(obj) def DeleteSon(self, obj): self.__son.remove(obj) def GetSon(self): return self.__son def GetValue(self): return self.__value def GetFirstSon(self): if (len(self.__son) == 0): return None else: return self.__son[0] def GetLastSon(self): if (len(self.__son) == 0): return None else: return self.__son[len(self.__son) - 1] def GetAllNode(point): all = [] if (len(point.GetSon()) == 0): all.append(point) return all else: all.append(point) for i in point.GetSon(): for j in TreeNode.GetAllNode(i): all.append(j) return all def GetAllLeaf(point): all = [] if (len(point.GetSon()) == 0): all.append(point) return all else: for i in point.GetSon(): for j in TreeNode.GetAllLeaf(i): all.append(j) return all

## 3. Interpretation

1. When addson function is called, a specified child node can be added to this node

2.GetSon function is used to obtain all child nodes of this node

3.GetValue function is used to obtain the weight of this node

4.GetFirstSon function is used to get the first child node added

5.GetLastSon function is used to get the last child node added

6. The static function GetAllNode recursively obtains all child nodes

7. The static function GetAllLeaf recursively obtains all the child leaf nodes

------More content is constantly updated------