udacity algorithms and data structures

symbols table ( symbol table) This series of articles mainly introduces the commonly used algorithms and data structure knowledge, recorded is "Algorithms i/ii" the content of the course, using the "algorithm (4th edition)" This red scroll as a learning material, language is java. I needn't say much about the fame of the book. Watercress score 9.4, I also think

Algorithm Graph Search (breadth first, depth first) depth first special important sequencing dynamic programming matching algorithm and network flow algorithm regular expression and string matching Data structure diagram (tree is especially important) map stack/Queue Tries | Dictionary Tree Additional recommended greedy algorithm approximate algorithm of probability method above is the recommendation of Arjun Nayini, the following is Ken George's r

simple; An ordered array can be found using two points; The logarithm of base a of B (probably) is the number of times the B is removed before the result of drizzle 1; The time required for linear lookups is proportional to the number of data items in the array; The time required for binary lookup is proportional to the logarithm of the number of data items in the array; The large O not

is too small, may be back overflow, if too large, but also cause a waste of performance, and the list is dynamically allocated, there is no problem. Therefore, generally do not use barrels.6. SummaryA hash table is based on an array, similar to the storage form of a key-value, where the keyword value is mapped to an array subscript by a hash function, which is called a conflict if a keyword is Hashiha to an occupied cell. There are two ways to resolve conflicts: The Open Address method and the

of red-Haishi. But they can't all be full, so the height of the 2-3-4 tree is roughly log2 (n+1) and log2 (n+1)/2. Reducing the height of the 2-3-4 tree makes it shorter to find than red-Haishi.On the other hand, each node has more data items to view, which increases the lookup time. Because a linear search is used in a node to view data items, the multiple of the lookup time is proportional to M, which is

when the display, but, The next time the element is inserted, the new element will replace the position of the last element.3) Find optimization--two points to findpublic int find (int value) { int start = 0; int end = Number-1; while (End>start) { int index = (end + start)/2; if (array[index]==value) { return index; } else if (Array[index] >value) { end = index-1; } else { start = in

　　 Packagecom.test.sort.insertion; Public classBinaryinsertsort {/** * @paramargs*/ Public Static voidMain (string[] args) {//TODO auto-generated Method StubSYSTEM.OUT.PRINTLN ("Binary Insert sort sort function implementation")); int[] arr = {23, 54, 6, 2, 65, 34, 2, 67, 7, 9, 43 }; Binaryinsertsort Sort=NewBinaryinsertsort (); System.out.println ("Sort before sequence:"); Sort.printarr (arr); Sort.bininsertsort (arr,0, Arr.length-1); System.out.println ("Sort after sequence:");;

Data structure: The way in which it is arranged in the computer's storage space.Algorithms: Software programs manipulate the data processes of these structures.Data structure Type1. Arrays:Advantages: Fast insertion, direct subscript can be accessed quickly.Cons: Find slow, delete slow, fixed size.2. Ordered arrays:Pros: Faster than no need for array lookups.Cons: Delete and insert slow, fixed size.3. Stack

-operation Traversal, we first recursively use the post-traversal to access the Saozi right subtree, the last access to the root node root node, right subtree, left dial hand tree def postorder (self, Root): "" " recursive implementation of subsequent traversal" " if root = = None: return self.postorder (root.lchild) Self.postorder (root.rchild) print (Root.elem)Breadth-first traversal (hierarchical traversal)From the root of the tree, from top to bottom, from l

obtained through the "predictive component", but we need to be more intuitive to verify the accuracy of the experiment, so we selected the "Two classification evaluation component" to evaluate the results.News text Analysis1. Data preprocessing and word segmentation, adding serial numbers, participle2. Keyword extract Word frequency statistics component3. Article classification. "Ternary group to KV component" is a common algorithm for text vectoriza

simple class of students to save data, with the number of groups can not solve the problem? There is a tree in Java, but it is not the principle of the use of trees?All kinds of down, you will find that the original real problems and language inside the package, are related to these, whenever you learn a kind, it will suddenly dawned, this is not the West Lake River of Summer Rain lotus, is this feeling. The students do not think about these problems

describe a problem in data form? --to abstract an appropriate mathematical model from the problemL The amount of data involved in the problem and the relationship between the dataL how to store data and reflect the relationship between data in a computerL What do you need to do with your

Java data structures and algorithms (iii) -- simple sorting Data alone is not enough. Data presentation often needs to be arranged in a certain order. The higher the requirement, the more complicated the sorting. This article only introduces three simple sorting types. 1) B

observers, that is, dependent objects, each time data changes, these 2 view will changeclassHexviewer (object):defUpdate (self, subject):Print 'hexviewer:subject%s has data 0x%x'%(Subject.name, Subject.data)classDecimalviewer (object):defUpdate (self, subject):Print 'decimalviewer:subject%s has data%d'%(Subject.name, Subject.data)if __name__=='__main__': Data1=

detection and re-hashing;2), Di = 12,-12,22,-22,32,..., ±k2 (K≤M/2), called two-time detection and re-hashing;3), Di = pseudo-random number sequence, called pseudo-random detection re-hash.(2), re-hash methodhi = RHI (key) i =,..., kRHI are different hash functions.(3), Chain address methodStores all the data elements of a synonym in the same linear list. Assuming that the hash address produced by a hash function is on the interval [0,m-1], a pointer

Algorithm Figure Search (breadth first, depth first) depth first is especially important Sort Dynamic planning Matching algorithm and network flow algorithm Regular expressions and string matching Data Figure (tree is particularly important) Map Heap Stack/queue Tries | Dictionary Tree Additional recommendations Greedy algorithm Probability method Approximate algorithm Algorithm: Three-way di

Today we will talk about how to calculate the complexity of time.The concept of Time complexity: (Baidu version)The same problem can be solved by different algorithms, and the quality of an algorithm will affect the efficiency of the algorithm and even the program.The purpose of the algorithm analysis is to select the suitable algorithm and the improved algorithm.In computer science, the time complexity of the algorithm is a function, which quantitati

fastest in the complexity of O (n^2);(2) Choose Sort, bubble sort is slow, usually appear in the interview question.Complexity of O (N*LOGN):(1) Quick sorting: Based on the comparison of the fastest in the ranking;(2) Merge sort: Less use in practice, often in interview;(3) Heap sorting: The actual use is less, but the heap is very common;The complexity is O (n), and only positive integers can be sorted:(1) Cardinal rank-complexity O (n+r), R as Radix;(2) Counting sort-complexity O (n+k), K for

Back to think of their own computer method surface knowledge system, can only be summed up with disunity. Decided to start from this blog, the accumulation of knowledge to do a comprehensive summary, re-think of their career planning and development.First, the basic data structure begins to comb.This is the first line of the plan.1. Work and project knowledge carding and summary(Sum up what you've done and what you've been doing these days)2. Individu

) Unordered array Delete (query + fill hole) O (N) Ordered array deletion (query + fill hole) O (N) Why not use data to solve everythingAn unordered array is inserted (O (1) time), and the query spends (O (N) time). An ordered array query spends (O (logn) time), but inserts a missing cost (O (N) time). And the deletion takes (O (N) time). So a data structur