计算机代写|CS3114 Data Structure

MY-ASSIGNMENTEXPERT™可以为您提供mines.edu CS3114 Data Structure数据结构课程的代写代考和辅导服务！

CS3114课程简介

Choose the data structures that effectively model the information in a problem.
Judge efficiency tradeoffs among alternative data structure implementations or combinations.
Apply algorithm analysis techniques to evaluate the performance of an algorithm and to compare data structures.
Implement and know when to apply standard algorithms for searching and sorting.
Design, implement, test, and debug programs using a variety of data structures including buffer pools, hash tables, and advanced tree structures.
Select appropriate methods for organizing data files and implement file-based data structures.
Prerequisites: Math2534, C or better in CS2104 (previously CS2984) Introduction to Problem Soving, C or better in CS2114 (CS2984) Software Engineering and Data Structures, C or better in CS2505 (CS2984) Introduction to Computer Organization I.

Prerequisites 

Description
Advanced data structures and analysis of data structure and algorithm performance. Sorting, searching, hashing, and advanced tree structures and algorithms. File system organization and access methods. Ethical issues in the context of data analysis and software performance. Course projects require advanced problem-solving, design, and implementation skills.

Credits
3

CS3114 Data Structure HELP（EXAM HELP， ONLINE TUTOR）

Sure, here’s an implementation of an algorithm to perform a range search in a BST based on the provided interface:

import java.util.*;

public class BST> {
private Node root;

// other methods and classes omitted for brevity

public Vector<T> rangesearch(T lower, T upper) {
    Vector<T> matches = new Vector<T>();
    rangeSearchHelper(lower, upper, root, matches);
    return matches;
}

private void rangeSearchHelper(T lower, T upper, Node<T> node, Vector<T> matches) {
    if (node == null) {
        return;
    }
    if (node.key.compareTo(lower) >= 0) {
        rangeSearchHelper(lower, upper, node.left, matches);
    }
    if (node.key.compareTo(lower) >= 0 && node.key.compareTo(upper) <= 0) {
        matches.add(node.key);
    }
    if (node.key.compareTo(upper) <= 0) {
        rangeSearchHelper(lower, upper, node.right, matches);
    }
}

private static class Node<T> {
    T key;
    Node<T> left, right;

    Node(T key) {
        this.key = key;
    }
}

}

n this implementation, the rangesearch method takes two arguments, lower and upper, which define the range of keys we want to search for. The method creates a new Vector object to store the matching keys, and then calls the rangeSearchHelper method to perform the actual search. The rangeSearchHelper method takes four arguments: the lower and upper bounds of the search, the current node being examined, and the matches vector to store the keys that fall within the specified range.

The rangeSearchHelper method is a recursive helper method that performs a depth-first search of the tree. At each node, the method checks whether the node’s key falls within the range defined by lower and upper. If so, it adds the key to the matches vector. It then recursively calls itself on the node’s left and right children, but only if the node’s key is greater than or equal to lower (for the left child) or less than or equal to upper (for the right child). This ensures that we only search the parts of the tree that could potentially contain keys within the specified range.

Note that the rangesearch method returns a Vector object, which is not the most efficient data structure for this purpose. Depending on the size of the tree and the number of matching keys, it might be better to use a different data structure such as an array or a linked list. However, the Vector class is simple to use and provides a convenient way to store a variable number of elements.

Sure, here’s an implementation of the rangeSearchHelper method that searches a binary search tree for keys falling within a specified range, and adds any matching keys to a Vector object:

private void rangeSearchHelper(T lower, T upper, BinaryNode sroot, Vector matches) {
if (sroot == null) {
return;
}
if (sroot.element.compareTo(lower) >= 0 && sroot.element.compareTo(upper) <= 0) { matches.add(sroot.element); } if (sroot.element.compareTo(lower) > 0) {
rangeSearchHelper(lower, upper, sroot.left, matches);
}
if (sroot.element.compareTo(upper) < 0) {
rangeSearchHelper(lower, upper, sroot.right, matches);
}
}

In this implementation, the rangeSearchHelper method takes four arguments: lower and upper, which define the range of keys we want to search for, sroot, which is the root of the current subtree being searched, and matches, which is the Vector object we will use to store any matching keys we find.

The method begins by checking whether the current node’s key falls within the range defined by lower and upper. If so, it adds the key to the matches vector.

The method then recursively calls itself on the left and/or right subtrees, depending on whether there could potentially be matching keys in those subtrees. Specifically, if the current node’s key is greater than lower, there may be matching keys in the left subtree, so the method is recursively called on the left child. Similarly, if the current node’s key is less than upper, there may be matching keys in the right subtree, so the method is recursively called on the right child.

Note that the method returns void, and instead adds any matching keys to the matches vector passed in as an argument. This allows the rangesearch method to return a vector containing all the matching keys, and avoids the need to create a new vector object for each recursive call.

Also note that this implementation operates as efficiently as possible by only searching the parts of the tree that could potentially contain keys within the specified range. Specifically, it only searches the left subtree if the current node’s key is greater than lower, and only searches the right subtree if the current node’s key is less than upper. This ensures that the algorithm runs in O(log n) time on a balanced tree, and O(n) time on a skewed tree.

MY-ASSIGNMENTEXPERT™可以为您提供UNIVERSITY OF ILLINOIS URBANA-CHAMPAIGN MATH2940 linear algebra线性代数课程的代写代考和辅导服务！ 请认准MY-ASSIGNMENTEXPERT™. MY-ASSIGNMENTEXPERT™为您的留学生涯保驾护航。