Sign upLogin

JoeKarlsson/data-structures

View on GitHub
Star

Showing 50 of 50 total issues

Function remove has a Cognitive Complexity of 44 (exceeds 5 allowed). Consider refactoring.
Open

  remove(value) {
    let found = false;
    let childCount;
    let replacement;
    let replacementParent;
Severity: Minor
Found in search/binary-search-tree.js - About 6 hrs to fix

Function search has a Cognitive Complexity of 29 (exceeds 5 allowed). Consider refactoring.
Open

  search: (graph, start, end, options) => {
    graph.cleanDirty();
    options = options || {};
    const heuristic = options.heuristic || astar.heuristics.manhattan;
    const closest = options.closest || false;
Severity: Minor
Found in shortest-path/aStar.js - About 4 hrs to fix

Similar blocks of code found in 2 locations. Consider refactoring.
Open

  breadthFirstRTL() {
    let node = this.root;
    const queue = [node];
    const result = [];
    while (node) {
Severity: Major
Found in search/binary-search-tree.js and 1 other location - About 4 hrs to fix
search/binary-search-tree.js on lines 276..287

Similar blocks of code found in 2 locations. Consider refactoring.
Open

  breadthFirstLTR() {
    let node = this.root;
    const queue = [node];
    const result = [];
    while (node) {
Severity: Major
Found in search/binary-search-tree.js and 1 other location - About 4 hrs to fix
search/binary-search-tree.js on lines 289..300

File binary-search-tree.js has 281 lines of code (exceeds 250 allowed). Consider refactoring.
Open

const LinkedList = require('../linked-list/linkedList');
 
// Private Helper functions
const makeNode = ( value ) => {
  const node = {};
Severity: Minor
Found in search/binary-search-tree.js - About 2 hrs to fix

    Function remove has 62 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

      remove(value) {
        let found = false;
        let childCount;
        let replacement;
        let replacementParent;
    Severity: Major
    Found in search/binary-search-tree.js - About 2 hrs to fix

      Function shortestPath has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.
      Open

        shortestPath(start, finish) {
          const nodes = new PriorityQueue();
          const distances = {};
          const previous = {};
          const path = [];
      Severity: Minor
      Found in shortest-path/dijkstra.js - About 2 hrs to fix

      Function sinkDown has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.
      Open

        sinkDown: function(n) {
          // Look up the target element and its score.
          const length = this.content.length,
          element = this.content[n],
          elemScore = this.scoreFunction(element);
      Severity: Minor
      Found in binary-heap/binaryHeap.js - About 2 hrs to fix

      Function search has 50 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

        search: (graph, start, end, options) => {
          graph.cleanDirty();
          options = options || {};
          const heuristic = options.heuristic || astar.heuristics.manhattan;
          const closest = options.closest || false;
      Severity: Minor
      Found in shortest-path/aStar.js - About 2 hrs to fix

        Function neighbors has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
        Open

          neighbors(node) {
            const ret = [];
            const x = node.x;
            const y = node.y;
            const grid = this.grid;
        Severity: Minor
        Found in graph/gridGraph.js - About 1 hr to fix

        Function nodeAverages has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
        Open

          nodeAverages() {
            const node = this.root;
            const result = {};
            const depthAverages = [];
         
         
        Severity: Minor
        Found in search/binary-search-tree.js - About 1 hr to fix

        Function shortestPath has 40 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

          shortestPath(start, finish) {
            const nodes = new PriorityQueue();
            const distances = {};
            const previous = {};
            const path = [];
        Severity: Minor
        Found in shortest-path/dijkstra.js - About 1 hr to fix

          Function mergeModule has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
          Open

          const mergeModule = ( () => {
            // used to merge all of our pieces back together after recursively separating the array
            const merge = ( left, right ) => {
              // initialize array to return
              const result = [];
          Severity: Minor
          Found in sorting/mergesort.js - About 1 hr to fix

          Similar blocks of code found in 3 locations. Consider refactoring.
          Open

                if (grid[x - 1] && grid[x - 1][y + 1]) {
                  ret.push(grid[x - 1][y + 1]);
                }
          Severity: Major
          Found in graph/gridGraph.js and 2 other locations - About 1 hr to fix
          graph/gridGraph.js on lines 71..73
          graph/gridGraph.js on lines 76..78

          Similar blocks of code found in 3 locations. Consider refactoring.
          Open

                if (grid[x + 1] && grid[x + 1][y - 1]) {
                  ret.push(grid[x + 1][y - 1]);
                }
          Severity: Major
          Found in graph/gridGraph.js and 2 other locations - About 1 hr to fix
          graph/gridGraph.js on lines 71..73
          graph/gridGraph.js on lines 81..83

          Similar blocks of code found in 3 locations. Consider refactoring.
          Open

                if (grid[x - 1] && grid[x - 1][y - 1]) {
                  ret.push(grid[x - 1][y - 1]);
                }
          Severity: Major
          Found in graph/gridGraph.js and 2 other locations - About 1 hr to fix
          graph/gridGraph.js on lines 76..78
          graph/gridGraph.js on lines 81..83

          Function FFT_Recursive has 37 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

          function FFT_Recursive(input, inverse) {
            const n = input.length;
           
            if (n === 1) {
              return input;
          Severity: Minor
          Found in fast-fourier-transforms/fft.js - About 1 hr to fix

            Function quickModule has 36 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

            const quickModule = (() => {
              // Private Methods and variables
             
              // swap method because its used multiple times
              const swap = ( array, index1, index2 ) => {
            Severity: Minor
            Found in sorting/quicksort.js - About 1 hr to fix

              Function selectionModule has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
              Open

              const selectionModule = (() => {
                // swap method because its used multiple times
                const swap = (array, index1, index2) => {
                  // store a tmp variable at pos index2
                  const tmp = array[index2];
              Severity: Minor
              Found in sorting/selectionsort.js - About 1 hr to fix

              Similar blocks of code found in 2 locations. Consider refactoring.
              Open

                findMin() {
                  const node = this.root;
                  const traverse = ( node ) => {
                    return !node.left ? node.value : traverse( node.left );
                  };
              Severity: Major
              Found in search/binary-search-tree.js and 1 other location - About 1 hr to fix
              search/binary-search-tree.js on lines 194..200
              Severity
              Category
              Status
              Source
              Language