Reference: [Notes] "lying Data Structure" https://blog.csdn.net/jianbinzheng/article/details/79858736
EDITORIAL
Chapter 1 Introduction data structure
Chapter 2 Algorithm
Chapter Table 3 Linear
Chapter 4 stacks and queues
Chapter 5 string
Chapter 6 Tree
Chapter 7 of FIG.
Chapter 8 Finding
Chapter 9 Sort
EDITORIAL
fast over again, for beginners, I said very thin, very helpful in understanding; for people who have some basic narrative may feel too ink. . .
Chapter 1 Introduction data structure
Programming Algorithms + data structures =
Data: descriptor is objective things, is the object can be manipulated in the computer, the computer can be identified is, and input to the set of symbols processed by a computer.
Element: is of some significance basic units of data, is typically treated as a whole, also referred to in the computer recorded
data items: a data element may be composed of a plurality of data items, the data is indivisible minimum unit of
data objects : is of the same nature (of the same number of types of data items) of the collection of data elements, the data is a subset of
data structures: the presence of one or more data elements of the particular relationship between each set of
logical structure: refers to data objects the relationship between data elements. Collection structure, linear structure, a tree structure, the structure pattern
physical structure: storage means in the form of a logical structure of data in a computer. Sequential storage structure, Storage Structure
Data Type: refer to the same set of values and a defined set of properties then this generic term for a number of operations on a set of
abstract data types (Abstract Data Type, ADT): it refers to the definition of a mathematical model and in the model a set of operations
Chapter 2 algorithm
algorithm describing solve a specific problem solution step, expressed as a finite sequence of instructions in a computer, and each represents one or more instruction operations
characteristic algorithm: O (input> = 0, the output of> = 1); finite nature; uncertainty; the feasibility of
the design requirements of the algorithm: correctness, readability, robustness,
efficiency metric algorithm: statistical afterwards, ex-ante estimation
time complexity of the algorithm is defined: when algorithm analysis, statement the total number of executions T (n) is a function of n scale of the problem, and then analyze T (n) with the change of n and determine the time complexity T (n) of the order of magnitude algorithm, which is the time of the algorithm measure, meter for T (n) = O (f (n)) T (n) = O (f (n)). N represents a problem which increases with the size, execution time of the algorithm is the same growth rates and f (n) growth, called progressive time complexity of the algorithm, referred to as time complexity. Where f (n) is a function of problem size n.
The method of derivation of a large O-order: replaced with adder; retain only the highest order term; highest order coefficient is an
O (1) <O (logN) <O (n-) <O (nlogn) <O (N2) <O (n3) <O (2n) <O (n!) <O (nn) O (1) <O (logn) <O (n) <O (nlogn) <O (n2) <O ( ! n3) <O (2n) <O (n) <O (nn)
Chapter 3 linear table
linear table (List): a finite sequence of zero or more data elements (the order)
of abstract data type linear form Operation: InitList / ListEmpty / ClearList / getElem / LocateElem / ListInsert / ListDelete / ListLength
sequential storage structure of linear form: refers to the use of addresses are successive data elements stored in the storage unit in this linear form - one dimensional array; indels is O (n), the query is O (1)
Storage Structure linear form: data field, a pointer field, nodes, head pointer, subsequent pointer address;
each node contains only a single linked list pointer is called domain; insertion and deletion is O (. 1), the query is O ( n)
Static lists: lists an array described. Each data element is stored and the index point to the next location
circular list: a single linked list to-tail chain called Robin, built circular list (circular linked list)
doubly linked list: each node point to a linked list of predecessor and successor - space for time
Chapter 4 stack queue
stack (stack) is defined only for insertions and deletions in the tail of linear form; stack (top), the stack bottom (bottom), LIFO (Last in first out , the LIFO); stack, the pull
stack abstract data types Operation: InitStack / DestroyStack / ClearStack / StackEmpty / getTop / push / Pop / StackLength
sequential storage structure stack - sequence of stack
Two shared stack space, top1 + 1 = top2 the stack is full, for the same type, the opposite relationship space requirements
Storage Structure of the stack - the first node link stack, a single list as a stack
Application stack - recursion: Fibonacci number
stack application - four arithmetic expression: 1) forwarding postfix infix expression; 2) postfix (RPN, RPN) seek operation result;
9+ (3-1) × 10 ÷ + 29. 3 + (3-1) +. 3 × 10 ÷ 2
. 9. 3. 1 -. 3 + 10 × 2 ÷ +. 1. 3. 9 -. 3 + 10 × 2 ÷ +
queue (queue) is only one end of the insertion operation, a delete operation on the other end of the linear table; FIFO (FIrst in First Out, FIFO)
abstract data types queue
operation: InitQueue / DestroyQueue / clearQueue / QueueEmpty / GetHead / EnQueue / DeQueue / QueueLength
circular queue, sequential storage structure end to end, to solve the storage space problem, front HOL represents, rear indicates the tail;
QueueLen = (REAR-QueueSize Front +) QueueSizeQueueLen% = (REAR-QueueSize Front +)% QueueSize
queue the storage structure - chain queue
Chapter 5 string
string (string) is a finite sequence of zero or more characters, also known as string
abstract data type string Operation: StrAssign / StrCopy / ClearString / StringEmpty / StrLength / StrCompare / Concat / SubString / Index / Replace / StrInsert / StrDelete
string Program storage structure, the chain storage structure (a plurality of characters each node)
String pattern matching algorithm - positioning operation substrings. 1) simple method, each time a frame advance; 2) KMP pattern matching substring skip the first few inconsistent with the first character; 3) KMP improved pattern matching, then skip itself with the first substring consistent string
Chapter 6 Tree
Tree (Tree) is n (n≥0) a finite set of nodes. n = 0, called null tree. In a non-null any species: (1) one and only one specific called the root (Root) nodes; (2) when n> 1, the remaining nodes can be divided into m (M> 0) a disjoint finite sets T1, T2, ..., TmT1, T2, ..., Tm, in each set, in turn, is a tree, and the subtree rooted called (subTree)
of: the node has It referred to the number of sub-tree nodes (degree). Degree of the node is called a leaf node 0 (Leaf) or the terminating node; of not called non-terminal node or a branch node 0 to the node. In addition to the root node, the branch node can be an internal node. Tree degree is the maximum degree of each node within the tree.
Children (Child) sub-tree root node called the node, and accordingly, the node is called the child's parent (Parent)
call each other brothers and fathers (Sibling), the junction between the children of the same parents all nodes from the root through to the node on the branch.
Any one of the nodes in the subtree rooted at a node are called descendants of the node
-level node (Level) is defined from the start from the root, the root of the first layer, the second child root layer.
Then the parent node with each other cousins layer
depth (Depth) is called the maximum level of the nodes in the tree or tree height
of forest (Forest) is m (m≥0) disjoint trees tree set
abstract tree data type Operation: InitTree / DestroyTree / CreateTree / ClearTree / TreeEmpty / TreeDepth / Root / Value / Assign / parent / LeftChild / RightSibling / insertChild / DeleteChild
storage structure tree: parents notation, notation children, child brothers representation
Binary Tree (Binary Tree) is a finite set of nodes n (n≥0), the set or a null set (called null binary), or consists of a root and two disjoint, called the root binary tree nodes left subtree and right subtree composed of
five basic binary tree structure
Oblique tree, all nodes are only left subtree right subtree or have only binary tree
full binary tree, binary tree nodes are present all left subtree and right subtree, all leaf nodes are at the same level, known as full binary tree
complete binary tree, a binary tree of n nodes having the sequence number by, if the number i (≦ i ≦ n) is a full binary tree with the nodes of the same depth as the node number i is again the same as the position of the binary tree , the binary tree is called a complete binary tree
binary nature 1: i-th layer in the binary tree has at most 2i-12i-1 nodes (i ≧ 1)
binary tree nature 2: a binary tree of depth k at most 2k-12k- a node (k ≧ 1)
binary nature of 3: any binary tree T, if the terminal nodes with which n0n0, the number of nodes of degree 2 is n2n2, then n0 = n2 + 1n0 = n2 + 1
binary nature 4 : complete binary tree of n nodes having a depth of ⌊log2n⌋ + 1⌊log2n⌋ + 1
binary nature 5: If there is a complete binary tree node n nodes according to the sequence number of any of there node i:
. 1) i =. 1, the root node; i> 1, the parent node is ⌊i2⌋⌊i2⌋
2) If 2i> n2i> n, the i Left child; otherwise, the left child of 2i2i
. 3) If 2i + 1> n2i + 1> n, i without the right child; otherwise the right child is 2i + 12i + 1
binary sequence storage structure, generally used for complete binary tree
binary tree traversal (traversing binary tree) refers to from the root node, according to a certain order of access all of the nodes in the binary tree such that each node is visited only once or once access
order traversal: left and right; preorder: left the right; postorder traversal: right and left; traversal sequence: from left to right by layer;
preorder traversal order is known and rear, can not be determined a binary tree
According to some order traversal, points to the predecessor or successor pointers are called leads, plus a binary tree list referred clue clue list, the corresponding binary tree is called binary cue; the binary sequence has been changed from a process called binary tree clue clue of
threaded binary binary becomes equal to a doubly linked list, as described in preorder
tree binary rotation: plus line to line, the level adjustment
Forest transfer binary tree: per revolution binary tree, respectively, as a front right subtree of the root
from the tree to a node between the branch node constituting another path between two nodes on the path the number of branches called path length. Is the path length from the root of the tree to each node, and the path length.
WPL minimum weighted path length Huffman tree is a binary tree called
a frequency from small to large, between two merged to form a new binary tree nodes, and finally merged into the Huffman tree. The left branch is 0, the right branch is 1, the corresponding coding is Huffman coding
Chapter 7 of FIG.
FIG. (Graph) there is a collection of vertices between the vertices and poor non-empty, usually expressed as: G (V, E), where, G represents a graph, V is the set of vertices, E is the set of edges
without the edges: edges between the vertices of no direction, represented by (), the composition of FIG no
directed edge: yES direction between vertices , also known as the arc, indicated by <>, composed of digraphs
there any two edges to the graph undirected complete graph, no. Total n × (n-1) 2n × (n-1) 2 sides
directed complete graph, between any two vertices opposite to each other in the presence of two arcs
with few edges is called a sparse graph, otherwise known as FIG dense
weighted graph is called network
submap
mutually adjacent two points with a point of the edge; side attached / connected to the two points; is the number of vertices associated edges; penetration is directed to FIG. the number of sides of the point; is the number of emitted;
path is a sequence of vertices from point to point; path length of a path is the number of upper / arc; a first bit and a last vertex of the same path is called loop / ring; vertices do not overlap the path along simple paths; simply referred to as a simple loop / ring is a simple end-point of the loop will not be repeated;
undirected graph, there is a path between two points is called point to point communication, FIG referred to any two communicating FIG communication; referred to as the maximum communication component connected subgraph; have strong graph called directed graph, strongly connected components
No communication with n vertices, and the n-1 Bianjiao spanning tree, a directed graph is a vertex of the vertex 0 to rest of the degree of the tree are called a directed graph, a directed graph by a number of trees have to forest tree configuration generates
abstract data types Operation of FIG: CreateGraph / DestroyGraph / LocateVex / GetVex / PutVex / FirstAdjVex / NextAdjVex / InsertVex / DeleteVex / InsertArc / DeleteArc / DFSTraverse / HFSTraverse
memory structure of FIG.
1) the adjacency matrix: a two-dimensional array of points + matrix
2) adjacency table: array list +
3) cross list: FIG directed Nice
. 4) adjacent multi table:
5) edge of arrays
graph traversal: starting from the vertex traversal FIG remaining figures a vertex, and that each vertex is accessed only once
depth-first traversal, DFS; for a precisely target;
breadth-first traversal, BFS; find suitable relative optimal solution;
minimum spanning tree: the minimum cost spanning tree configuration Unicom network called the minimum spanning tree
Prim's algorithm: assuming N = (P, {E} ) N = (P, {E}) is a communication network, TE is set in the minimum spanning tree on the N side. The algorithm starts repeatedly performed from U = {u0} (u0∈V) , TE = {} U = {u0} (u0∈V), TE = {}: all u∈U, v∈V-Uu∈U , v∈V-U edge (u, v) ∈E (u , v) ∈E find a minimum cost of the edge (u0, v0) (u0, v0) set incorporated TE, while v0v0 incorporated U, U = up until the VU = V. In this case there must TE n-1 edges, then T = (V, TE) T = (V, TE) is a minimum spanning tree of N; O (n2) O (n2 )
Kruskal's algorithm: Suppose N = (V, {E} ) N = (V, {E}) is a communication network, so that the initial state of the minimum spanning tree is only boundless unconnected graph with n vertices T = {V, {}} T = {V, {}}, self-contained vertices in the graph for each connected component. Select the smallest E side cost if the vertices fall on different sides of the attachment connected components T, then this was added to the T side, otherwise this edge rounding and choose the smallest cost of a lower side. T until all vertices in the same connected component in so far; O (eloge) O (eloge )
Kruskal algorithm for sparse FIG less side; FIG dense Prim's algorithm for
shortest path: through between two vertices the edge of the right value and minimal path, and we call the first vertex on the path is the source point, when the end of the last vertex
Dijkstra's algorithm: solving the shortest distance from point to point. And the distance D is represented by an array of array P represents a precursor, by iteratively updating the shortest distance points to the beginning of the implementation. Complexity of O (n2) O (n2)
Floyd Algorithms: Solving the shortest distance between any two points in all, with three iterations of the loop update shortest distance between point and point. Complexity of O (N3) O (N3)
, represented by the vertices represent a directed graph engineering activities, the activities represented by the relationship between a limited arc, such Digraph vertices represent the activities of the network, referred AOV net (Activity On Vertex network). Net midpoint sequence with vertex V1 to vertex V2 from the path, V1 V2 will be at the front, such a sequence is called a vertex of topological
topological sort, it is directed to a process sequence of FIG topology structure, including vertex may result all output - AOV wire loop does not exist; not all vertices output ring is present, non-AOV network. Method: From the beginning of the output vertex is 0, and delete this point and the associated arc, until the absence of 0 degree up point.
There are weighted, with the apex indicating the event to the drawing, showing the side with the active there, with the duration of the activity represents the weight of the edge, indicating that the active side of the network of FIG referred AOE network (Activity On Edge Network)
Each path on the path of the duration of activity and is called the path length has a maximum length from the source point to sink point is called the critical path, activities on the critical path is called critical activities. Must shorten the period from the start step of shortening the critical path
to find Chapter 8
Finding (Searching) is given a value according to a keyword is determined from a value equal to a given data element (or recorded) in a lookup table
lookup table (Searching Table) is a collection of data elements of the same type (or record) made
key (Key) is a value of a data item in the data elements, also called key; if keywords can uniquely identify a record called master keyword, keyword identifying a plurality of times is referred to as
static lookup tables (static Search table) only for the lookup table lookup operation of
a dynamic lookup table (dynamic Search table) in the process of finding data elements simultaneously inserted into lookup table does not exist, or delete an existing data element from the lookup table in
order to find (sequential Search) known as a linear search, i.e. find one by one, the time complexity of best / worst / average: O (1) / O ( n) / O (n) O (1) / O (n) / O (n)
ordered list - binary search (Binary Search), also known as binary search: in each dividing narrow midpoint; time complexity O (logn ) O (logn)
ordered list - Find interpolation (interpolation Search), determined according to interpolation formula dividing points, interpolation formula key-a [low] a [ high] -a [low] key-a [low] a [high] -a [low]; time complexity O (logn) O (logn); for table imams and key distribution
ordered list - Find Fibonacci (Fibonacci Search), column dividing point is determined in accordance with that deed Fibonacci number; time complexity O (logn) O ( logn)
Index: the process is a key record corresponding to its associated index composed by a number of index entries, the index entry should contain the keywords and the corresponding position recorded in the memory of
the linear indexing is to index items organized as a set of linear structure, also called an index table
dense index: refers to a linear index, each record corresponding to a data set index item; data may be random, ordered index entry
Block index: order of sub-blocks of data sets, each corresponding to an index entry; wherein the random block, inter-block ordered; key index entry includes a maximum, the number of records within a block, the block header pointer
Inverted index: index entry includes a secondary key, record number in the table; record number table stores all records having the same number of times a keyword records (which may be a pointer to the record or a record keyword master)
Binary sort tree (Binary Sort Tree), also known as a binary search tree, having properties: left subtree root is smaller than the value of all the nodes or null; right subtree root of a value greater than or empty all the nodes point; the left and right subtrees are binary sort tree
traversal sequence binary sort tree that is an ordered sequence of
binary sort tree if it is balanced, with a binary search efficiency; severe if the swash tree, to find the same sequence
balanced binary tree ( Self-Balancing Binary Search tree), a binary sort tree, wherein each node of the left subtree and right subtree height difference of at most 1, also known as an AVL tree
depth minus the right subtree of the left subtree depth called balance factor BF (balance factor)
balance the need to adjust the tree after inserting the new value; recent absolute values from the insertion point, and the balance factor is greater than the root node of a subtree, called the minimum unbalance subtree sex
Multiple search tree (multi-way search tree) tree, each child node can be more than two, and each node may store a plurality of elements
2-3 tree: Each node consists of two (2 junction point), or three (three nodes) the child, there is a junction element 2, 3 has two node elements; and all leaf nodes in the same layer
2-3-4 tree: 2-3 compared tree, 4 includes node - four children three elements
B-tree (B-tree) is a balanced search tree multiplexer, 2-3 and 2-3-4 tree tree is a special case, the maximum B-tree node the number of children is the order of the B-tree (order)
Application of the B-tree: the page size of the large amount of data processing can not be loaded into memory only once, the order of the B-tree matches the disk storage; root node may be stored in memory, when looking only to read both hard times can; B-tree data structure is stored data exchange within and outside the preparation of
B + tree, B-tree traversal solve the problem, we also face jump back and forth, and look for a suitable range; save the value of the parent node of the leaf node ( leaf node contains all the information); leaf node points to the next leaf node
Hashing is established between the storage position and its record keyword determining a correspondence relationship F, such that each key corresponds to a memory location key f (key); f is called a hash function, also known as hashing (the hash) function; hashing technique employed, the records are stored in a contiguous storage space, this storage space is called continuous hash or a hash table (hash table)
hashing technique is a method of storage, but also a searching method, the logical relationship between the recording does not exist, and is adapted to find a given value equal to the record; not suitable for a key corresponding to a plurality of lookup records, does not find a suitable range
if the two key key1 ≠ key2, f (key1 synonyms) = f (key2) key1 ≠ key2, f (key1) = f (key2), such field called a collision (Collision) the key1 and key2 hash function called
a hash function configured - direct addressing method, suitable small lookup tables and continuous, linear function takes a hash value of the key address to do, such as
f (key) = a × key + bf (key) = a × key + b
hash function construction - digital analysis, suitable for handling a large number of bits and a number of bits keywords uniform distribution, extraction Hash keys as part of a storage location of
a hash function configuration - middle-square method, is adapted to the distribution of a keyword, and do not know the number of bits is not, taken squared in some keywords, such as 1234, 1,522,756 square, taking 227
hash function configured - folding process, and a suitable distribution of keywords does not know the number of bits is larger, the folding summation, summed divided into four groups as 9876543210 987 + 654 + 0 + 321 = 1962
a hash function construction - in addition to the remaining number of methods, the most commonly used, often taking P m is not greater than the maximum prime number
f (key) = key mod p (p≤m) f (key) = key mod p (p≤m)
hash function is configured - random method for varying the length of the keyword
Hash conflict management - Open-addressable, conflict, looking at an empty hash address, also known as linear probing method. Likely to cause accumulation phenomenon (non-synonymous with an address scramble), the second detection method may be employed; random detection method or
fi (key) = (f ( key) + di) mod m (di = 1,2,3, .. .,. 1-m) Fi (Key) = (F (Key) + DI) m MOD (DI = l, 2,3, ...,. 1-m)
Fi (Key) = (F (Key) + DI ) mod m (di = 12, -12,22, -22, ..., q2, -q2, q≤m / 2) fi (key) = (f (key) + di) mod m (di = 12 , -12,22, -22, ..., Q2, -Q2, q≤m / 2)
Fi (Key) = (F (Key) + DI) m MOD (DI random number sequence) fi (key) = (f (key) + di) mod m (di random number sequence)
hash collision process - then the hash function method, performed by a plurality of hash functions, a conflict for a
Hash collision process - chain address method, the position of connection with the conflict chain
Hash collision process - an overflow area of public law, the conflict resumes a public key to store the overflow area for conflict less data
if there is no conflict, hash lookup time is O (1)
Chapter 9 Sort
assumptions contained sequence of n recording is {r1, r2, ..., rn } {r1, r2, ..., rn}, the corresponding keywords are {k1, k2, ..., kn } {k1, k2, ..., kn}, to be determined 1,2, ..., n of an arrangement p1, p2, ..., pnp1, p2, ..., pn, it satisfies the keyword kp1≤kp2 ≤ ... ≤kpnkp1≤kp2≤ ... ≤kpn (non-increasing or decreasing) the relationship, even if the sequence is called a press key to obtain an ordered sequence {rp1, rp2, ..., rpn } {rp1, rp2, ..., rpn}, such operation is called a sort
stability Sort: the same keyword two records, that is, after the sort order unchanged stable, unstable or
the entire sorting process in sorting for memory; external sorting is performed a plurality of times to exchange data between the inner and outer re-sorting process village
substantially ordered: keyword substantially smaller front, rear substantially large, substantially in the middle of the sort
ordering categorical within:
1 ) insertion sort: directly inserted into the discharge Hill sorting
2) exchange Sort: bubble sort, quick sort
3) Select the sort: simple selection sort, heap sort
4) merge sort
Bubble sort
1) thinking: compare two adjacent recording, reverse the exchange, until there is no Reverse order record;
2) optimization: If an iteration, not over the subsequent exchange occurs, then all stopped;
3) complexity: the average O (n2) O (n2) , preferably O (n) O (n) , worst O (n2) O (n2) , the space O (1) O (1) , stabilizing
simple selection sort
1) Thought: find the smallest value from each remaining sequence, the substitution to the front
2) Complexity: The average O (n2) O (n2) , preferably O (n2) O (n2) , the worst O (n2 ) O (n2), the space O (1) O (1) , a stable
direct insertion sort
1) Thought: gradual expansion ordered list, each record looking for the insertion positions, i.e., backward sequentially ordered in large numbers in table
2 ) complexity: The average O (n2) O (n2) , preferably O (n) O (n) , the worst O (n2) O (n2) , the space O (1) O (1) , stabilizing
Hill sorting
1) Thought: step 1 is longer than the insertion sort, and gradually decreased to 1 step
2) complexity: the average O (nlogn) ~ O (n2 ) O (nlogn) ~ O (n2), preferably O ( n1.3) (n1.3) O, worst O (n2) O (n2) , the space O (1) O (1) , an unstable
stack: complete binary tree; the value of each node is less than or equal to left and right child node value, a large stack top; each node values are less than or equal to its left child node value, small top heap
sort heap
1) thought: the large top stack, each element of the top of the stack removing (or exchange and end), re-configuration of the remaining elements stack is repeatedly executed until the ordered sequence
2) complexity: The average O (nlogn) O (nlogn) , preferably O (nlogn) O (nlog n), the worst O (nlogn) O (nlogn) , space O (1) O (1) , unstable
3) Analysis: Construction stack requires O (n), after each adjustment requires O (logi)
merge Sort
1) Thought: splitting the sequence into two subsequences of the size of a pairwise merge sort, regained until the ordered sequence length n
2) complexity: the average O (nlogn) O (nlogn) , most good O (nlogn) O (nlogn) , the worst O (nlogn) O (nlogn) , space O (n) O (n) , stable
Quicksort
1) Thought: each sorting records into two parts, than the small portion of the other part, the two parts then were sorted
2) Complexity: The average O (nlogn) O (nlogn) , preferably O ( nlogn) O (nlogn), the worst O (n2) O (n2) , the space O (nlogn) ~ O (n2 ) O (nlogn) ~ O (n2), unstable
3) optimization: three number take in the tail recursive
summary sorted:
1) the best situation, if the column to be sorted substantially ordered, complex algorithms 4 is not considered, and bubble insertion consider
2) the worst situation, heap sort and merge sort more good
3) to see the spatial complexity, memory use when care, and should not be selected fast row merge
4) stability See, when care stability, good merging
5) Quantitatively, n-smaller and more simple, the more improved the larger n-
6 ) to reduce the number of movements, simply select it better
---------------------
Author: Pancakes certificate
Source: CSDN
Original: https: //blog.csdn.net/jianbinzheng/article/details/79858736
Copyright: This article is a blogger original article, reproduced, please attach Bowen link!