what is a decision tree and how can it be used?
816874
In decision analysis, a "decision tree" ---- and a closely related model form, an influence diagram ---- is used as a visual and analytical decision support tool, where the expected values (or expected utility) of competing alternatives are calculated.\n\nIn operations research, and decision analysis specifically, a decision tree is an idea generation tool that generally refers to a graph or model of decisions and their possible consequences, including chance event outcomes, resource costs, and utility. A decision tree is a decision support tool, used to identify the strategy most likely to reach a goal. Another use of trees is as a descriptive means for calculating conditional probabilities.\n\nIn data mining, on the other hand, a decision tree is a predictive model; that is, a mapping of observations about an item to conclusions about the item's target value. More descriptive names for such tree models are classification tree or reduction tree. In these tree structures, leaves represent classifications and branches represent conjunctions of features that lead to those classifications. The machine learning technique for inducing a decision tree from data is called decision tree learning, or (colloquially) decision trees.
894119
Well... the easiest and most general approach is to  traverse the tree in preorder depth-first manner, writing the nodes to the file, and inserting a special separator (a centinel) at the end of each branch - just before the traversal process is about to move up:\n\nvoid write_node (struct node *root, FILE *out)\n{\n    root ? fprintf (out, "%s&#92;n", node_to_string (root, buffer)) :\n    fprintf (out, "%c&#92;n", SENTINEL);\n}\n       \nvoid read_tree (struct node *root, FILE *out)\n{\n   write_node (root);\n    if (!root) return;     \n    save_tree (root->left, out);\n    save_tree (root->right, out);\n}\n\nthen you can read this structure back in  in the same order:\nstruct node* read_node (FILE *in)\n{\n    char buffer[1024];\n    if (!fgets(in, buffer, 1024) || buffer[0] == SENTINEL) return 0;\n   return parse_node (buffer);\n}\n    \nstruct node *read_tree (FILE *out)\n{\n    struct node *root = read_node (out);\n    if (!root) return 0;\n    root->left = read_tree (out);\n    root->right= read_tree(out);\n}
314761
Data base management system by F.Korte.
251583
a method for decision making
137543
If we don't plan on modifying a search tree, and we know exactly how often each item will be accessed, we can construct an optimal binary search tree, which is a search tree where the average cost of looking up an item (the expected search cost) is minimized.\n\nAssume that we know the elements and that for each element, we know the proportion of future lookups which will be looking for that element. We can then use a dynamic programming solution, detailed in section 15.5 of Introduction to Algorithms, to construct the tree with the least possible expected search cost.\n\nEven if we only have estimates of the search costs, such a system can considerably speed up lookups on average. For example, if you have a BST of English words used in a spell checker, you might balance the tree based on word frequency in text corpuses, placing words like "the" near the root and words like "agerasia" near the leaves. Such a tree might be compared with Huffman trees, which similarly seek to place frequently-used items near the root in order to produce a dense information encoding; however, Huffman trees only store data elements in leaves.
590072
Make a tree that shows all possibilities you have.\nOn the first level there is the choice of the box with 0.5 probability each. On the next level, box A, you have two choices again, with the prob. is 3/7 to find a red ball, 4/7 to find a white ball, etc.\n\nWhen you have finished to tree, use it to make a list and\ncalculate the prob. for picking red-red, red-white, etc.
300641
In Counting or Probability-\nA tree diagram consists of clusters or line segments, or branches, constructed as follows: A cluster of branches is drawn for each decision to be made such that the number of branches in each cluster equals the number of choices for each decision.
1159892
Sequential search:\n\nhttp://cprogramming.com/discussionarticles/sorting_and_searching.html
831305
Ever heard of trees? They are just one example of a dynamic memory structure, although don't be mistaken - they don't populate themselves, it's your job as the programmer to make them do that.\n\nRawlyn.
898314
Here are some general data structures:\n\n- Set\n- List\n- Map\n- Tree\n- Table\n- Stack\n- Queue
245731
We can classify sorting techniques according to their underlying structure.\n\nSwap-based sorts begin conceptually with the entire list, and exchange particular pairs of elements (adjacent elements or elements with certain step like in  Shell sorts) moving toward a more sorted list. \nMerge-based sorts creates initial "naturally" or "unnaturally" sorted sequences, and then add either one element (insertion sort) or merge two already sorted sequences. \nTree-based sorts store the data, at least conceptually, in a binary tree; there are two different approaches, one based on heaps, and the other based on search trees. \nFinally, the other category catches sorts which use additional key-value information, such as radix or bucket sort. \n We can also classify sorting algorithms by several other criteria:\n\nComputational complexity (worst, average and best number of comparisons for several typical test cases, see below) in terms of the size of the list (n). Typically, good average number of comparisons is O(n log n) and bad is O(n2). Note that asymptotic analysis does not tell about algorithms behavior on small lists or worst case behavior. Worst case behavior is probably more important then average. For example "plain-vanilla" quicksort requires O(n2) comparisons in case of already sorted arrays: a very important in practice case.  Sort algorithms which only use an abstract key comparison operation always need at least O(n log n) comparisons on average; while sort algorithms which exploit the structure of the key space cannot sort faster than O(n log k) where k is the size of the keyspace.  Please note that the number of comparison is just convenient theoretical metric. In reality both moves and comparisons matter and on short keys the cost of move is comparable to the cost of comparison (even if pointers are used). \n  \nStability: stable sorting algorithms maintain the relative order of records with equal keys. If all keys are different the this distinction does not make any sense. But if there are equal keys, then  a sorting algorithm is stable if whenever there are two records R and S with the same key and with R appearing before S in the original list, R will appear before S in the sorted list. \n  \nMemory usage (and use of other computer resources). One large class of algorithms are "in-place sorting. They are generally slower than algorithms that use additional memory: additional memory can be used for mapping of keyspace.  Most fast stable algorithms use additional memory.  With the current 4G of memory of more of  memory and virtual memory used in all major OSes, the old emphasis on algorithms that does not require additional memory should be abandoned.  Speedup that can be achieved by using of a small amount of additional memory is considerable and it is stupid to ignore it.  Moreover you can use pointers and then additional space of the size N actually becomes size of N pointers. In real life when the records usually have size several times bigger then the size of a pointers (4 bytes in 32 bit CPUs) that makes huge difference and make those methods much more acceptable then they look form purely theoretical considerations. \n  \nThe difference between worst case and average behavior (quicksort is efficient only on the average, and its worst case in to order n2, while heapsort has an interesting property that the worst case is not much different form the an average case.  Behaviors on practically important data sets (completely sorted, inversely sorted and 'almost sorted' (1 to K permutations, where K is less then N/10) has tremendous practical implications that are often not addressed or addressed incorrectly in textbooks other then Knuth. \nAmong non-stable algorithms Shellsort is probably the most underappreciated and quicksort  is one of the most overhyped. Please note the quicksort is a fragile algorithm because the choice of pivot is equal to guessing an important proper
578799
pick a company - lets say a shoe store. use a paragraph telling what goes on in a shoe store - keeping an inventory -making sails - keeping books - paying staff etc. Then show how each of these activities could be improved by the use of a computer - speed - accuracy - ability to handle large amounts of data. Then finish it by talking about how a relational data base like Access would handle all of it.
322643
Its of or relating to the computer language, prolog, which is commonly used for AI programs.  Its a very flexible language.
113769
It's an Entity Relationship diagram. It is a graphical representation of data models and is typically used when designing a database or other information system.
965114
I think you mean that you want to verify that your search is a binary search? Because binary trees don't search. \n\nIn order to verify the correctness of the search, print out the memory contents at each iteration of your search and review the results.
372021
goto \n\nhttp://oak.cats.ohiou.edu/~aw200200/esp/assessment.htm
1159096
The best open-source data mining tool is definitely WEKA.\n\nIt is possible to run 50 million (1 M records x 50 attributes) attribute values in WEKA. But you have to set maximum heap size for RAM to run it.\n\nPolyanalyst is probably for user-friendly for new data miners, but if become experienced, statistical packages like MATLAB (commerical) and R (open source) are much more flexible and better.\n\nI think it is always better to use free and well-known stuff before considering paying money for commercial ones :) My bet is on WEKA if you are going to do some form of classification.