四川大学数据结构复习

Review of Data Structures and AlgorithmsChapter 1 Data structures and algorithmsConceptType: A type is a collection of values.Simple type: Its values contain no subparts.Composite type/Aggregate type: Its values contain subparts called data item or member. Data type: A data type is a type together with a collection of operations to manipulate the type.ADT: An abstract data type (ADT) is the realization of a data type as a software component. The interface of the ADT is defined in terms of a type and a set of operations on that type. The behavior of each operation is determined by its inputs and outputs.Data structure: A data structure is the physical implementation for an ADT.Problems: A problem is a task to be performed.Function: A function is a matching between inputs (the domain) and outputs (the range). Algorithm: An algorithm is a recipe for solving a problem whose steps are concrete and unambiguous. Algorithms must be correct, of finite length, and must terminate for all inputs.Programs: A program is an instantiation of an algorithm in a programming language. Chapter 2 Mathematical preliminariesConceptSet: A set is a collection of distinguishable members or elements.Recursion: An algorithm is recursive if it calls itself to do part of its work.Chapter 3 Algorithm AnalysisConceptAsymptotic algorithm analysis(对资源消耗进行评估，对同一程序算法进行分析): Asymptotic analysis attempts to estimate the resource consumption of an algorithm.It allows us to compare the relative costs of two or more algorithms for solving the same problem. Asymptotic analysis also gives algorithm designers a tool for estimating whether a proposed solution is likely to meet the resource constraints for a problem before they implement an actual program.Growth rate（算法随着输入增长导致整体花费增长的比重）: the rate at which the cost of the algorithm grows as the size of its input grows.Best/worst/average case: They express what the resource usage is at least, at most and on average, respectively.Upper/Lower bound: It indicates the upper/lower or highest/least growth rate that the algorithm can have.Big-Oh/Big-Omega notation（最大最小增长率，最多最少资源消耗）: It describes an upper/lower bound to its growth rate of f(n). It states a claim about the greatest/least amount of some resource that is required by an algorithm for some class of inputs of size n. Theta notation: When the upper and lower bounds are the same within a constant factor, we indicate this by using it.Space/time tradeoff（时间和空间的平衡）: One can often achieve a reduction in time if one is willing to sacrifice space or vice versa.Chapter 4 Lists, Stacks and QueuesConceptList: list is a finite, ordered sequence of data items known as elements.Array-based/Linked list: Implement lists make use of arrays/pointers.Ordered/Unordered list：A list that the elements in it are stored in ascending order.Singly/Doubly linked list:Each list node has a single pointer to the next node on the list.A doubly linked list allows convenient access from a list node to the next node and also to the preceding node on the list.Stack: The stack is a list-like structure in which elements may be inserted or removed from only one end.Array-based/Linked stack: Implement stacks make use of arrays/pointersQueue:The queue is a list-like structure that provides restricted access to its elements. Queue elements may only be inserted at the back and removed from the front.Array: A contiguous block of memory locations, where each memory location stores one fixed-length data item.Array-based/Linked queue: Implement queues make use of arrays/pointers.Circular queue: The first position of the storage space are connected to the last position, so this form a loop in the queue.AlgorithmInsert and deleteChapter 5 Binary TreesBST：Binary Search Tree.A binary tree that conforms to the following condition, known as the Binary Search Tree Property: All nodes stored in the left subtree of a node whose key value is K have key values than K. All nodes stored in the right subtree of a node whose key value is K have key values greater than or equal to K.Huffman treeFull binary tree: Each node is either a leaf or internal node with exactly two non-emptychildren.(叶节点数为内节点数加1，删除一个内部节点的两个叶节点则内部节点数减1，空指针数= 非空指针数+1)Complete binary tree: If the height of the tree is d, then all leaves except possibly level d-1are completely full. The bottom level has all nodes to the left side.Height/depth of a binary treeThe depth of a node M in the tree is the length of the path from the root of the tree to M.（指单独一个点）The height of a tree is one more than the depth of the deepest node in the tree.Preorder traversal（前）: Visit each node before visiting its children.template <typename E> // Good implementationvoid preorder(BinNode<E>* root) {if (root == NULL) return; // Emptyvisit(root); // Perform some actionpreorder(root->left());preorder(root->right());}Postorder traversal（后）: Visit each node after visiting its children. LRVRLVtemplate <typename E>void postorder(BinNode<E>* root) {if (root == NULL) return; // Emptypostorder(root->left());postorder(root->right());visit(root); // Perform some action}Inorder traversal（中）: Visit the left subtree, then the node, then the right subtree. template <typename E>void inorder(BinNode<E>* root) {if (root == NULL) return;inorder(root->left());visit(root);inorder(root->right());}BST插入：template <typename Key, typename E>BSTNode<Key,E>* BST<Key,E>::inserthelp(BSTNode<Key,E>* root,const Key& k, const E& it) {if (root == NULL) // Empty: create nodereturn new BSTNode<Key, E>(k,it,NULL,NULL);if (k < root->key())root->setLeft(inserthelp(root->left(), k, it));else root->setRight(inserthelp(root->right(), k, it));// Return tree with node insertedreturn root;}BST删除：template <typename Key, typename E>BSTNode<Key,E>* BST<Key, E>::deletemin(BSTNode<Key,E>* rt) {if (rt->left() == NULL)return rt->right();else { // Continue leftrt->setLeft(deletemin(rt->left()));return rt;}}Heap（堆）：Complete binary tree with the heap property（partially ordered）Priority queue：When a collection of objects is organized by importance or priority Heap: 构造堆时按编号一个一个插入（不比较大小），比较时从最后一个非叶子树开始与自己的子节点进行对比。