data-sts31 1.0.0

package/dist/AVL/AvlNode.d.ts

@@ -0,0 +1,8 @@
+declare class avlNode {
+    val: number;
+    left: avlNode | null;
+    right: avlNode | null;
+    height: number;
+    constructor(val: number);
+}
+export default avlNode;

package/dist/AVL/AvlNode.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class avlNode {
+    constructor(val) {
+        this.val = 0;
+        this.val = val;
+        this.left = null;
+        this.right = null;
+        this.height = 1;
+    }
+}
+exports.default = avlNode;

package/dist/AVL/AvlTreeOperation.d.ts

@@ -0,0 +1,9 @@
+import avlNode from "./AvlNode";
+export default class AvlTreeOperation {
+    insert(root: avlNode | null, key: number): avlNode | null;
+    rightRotation(root: avlNode | null): avlNode | null;
+    leftRotation(root: avlNode | null): avlNode | null;
+    balancedFactor(root: avlNode | null): number;
+    getHeight(root: avlNode | null): number;
+    preorder(root: avlNode | null): void;
+}

package/dist/AVL/AvlTreeOperation.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AvlNode_1 = require("./AvlNode");
+class AvlTreeOperation {
+    insert(root, key) {
+        var _a;
+        // if root does not exist
+        if (!root) {
+            return new AvlNode_1.default(key);
+        }
+        // if key is less than root value
+        else if (key < root.val) {
+            root.left = this.insert(root.left, key);
+        }
+        // if key is greater than root value
+        else if (key > root.val) {
+            root.right = this.insert(root.right, key);
+        }
+        // if key is equal to root value
+        else {
+            return root;
+        }
+        // update height of node
+        root.height = 1 + Math.max(this.getHeight(root.left), this.getHeight(root.right));
+        // check balance factor
+        let balance = this.balancedFactor(root);
+        // LL rotation
+        if (balance > 1 && root.left && key < root.left.val) {
+            return this.rightRotation(root);
+        }
+        // RR rotation
+        else if (balance < -1 && root.right && key > root.right.val) {
+            return this.leftRotation(root);
+        }
+        // LR rotation
+        else if (balance > 1 && root.left && key > root.left.val) {
+            console.log("LR");
+            root.left = this.leftRotation(root.left);
+            return this.rightRotation(root);
+        }
+        // RL rotation
+        else if (balance < -1 && root.right && key < ((_a = root.right) === null || _a === void 0 ? void 0 : _a.val)) {
+            root.right = this.rightRotation(root.right);
+            return this.leftRotation(root);
+        }
+        else {
+            return root;
+        }
+        return root;
+        // not unbalanced
+    }
+    rightRotation(root) {
+        if (!root || !root.left) {
+            return root;
+        }
+        let newRoot = root.left;
+        let leftRootChild = newRoot.right;
+        newRoot.right = root;
+        root.left = leftRootChild;
+        // Update heights
+        root.height = 1 + Math.max(this.getHeight(root.left), this.getHeight(root.right));
+        newRoot.height = 1 + Math.max(this.getHeight(newRoot.left), this.getHeight(newRoot.right));
+        return newRoot;
+    }
+    leftRotation(root) {
+        if (!root || !root.right) {
+            return null;
+        }
+        let newNode = root.right;
+        let newNodeRightChild = newNode.left;
+        newNode.left = root;
+        root.right = newNodeRightChild;
+        root.height = 1 + Math.max(this.getHeight(root.left), this.getHeight(root.right));
+        newNode.height = 1 + Math.max(this.getHeight(root.left), this.getHeight(root.right));
+        return newNode;
+    }
+    balancedFactor(root) {
+        if (!root) {
+            return 0;
+        }
+        return this.getHeight(root.left) - this.getHeight(root.right);
+    }
+    getHeight(root) {
+        if (!root) {
+            return 0;
+        }
+        return root.height;
+    }
+    preorder(root) {
+        if (!root) {
+            return;
+        }
+        console.log(root.val);
+        this.preorder(root.left);
+        this.preorder(root.right);
+    }
+}
+exports.default = AvlTreeOperation;

package/dist/Heap/maxHeap.d.ts

@@ -0,0 +1,14 @@
+export default class MaxHeap {
+    private size;
+    private ArraySize;
+    private heap;
+    constructor(n: number);
+    insert(val: number): void;
+    delete(): void;
+    private heapify;
+    private swap;
+    private leftChild;
+    private rightChild;
+    private getParent;
+    print(): void;
+}

package/dist/Heap/maxHeap.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class MaxHeap {
+    constructor(n) {
+        this.heap = new Array(n);
+        this.ArraySize = n;
+        this.size = 0;
+    }
+    insert(val) {
+        if (this.size === this.ArraySize) {
+            console.log("Heap Overflow");
+            return;
+        }
+        this.heap[this.size] = val;
+        let index = this.size;
+        this.size++;
+        while (index > 0 &&
+            this.heap[this.getParent(index)] < this.heap[index]) {
+            this.swap(index, this.getParent(index));
+            index = this.getParent(index);
+        }
+    }
+    delete() {
+        if (this.size === 0) {
+            console.log("Heap Underflow");
+            return;
+        }
+        this.heap[0] = this.heap[this.size - 1];
+        this.size--;
+        this.heapify(0);
+    }
+    heapify(index) {
+        let largest = index;
+        let left = this.leftChild(index);
+        let right = this.rightChild(index);
+        if (left < this.size && this.heap[left] > this.heap[largest]) {
+            largest = left;
+        }
+        if (right < this.size && this.heap[right] > this.heap[largest]) {
+            largest = right;
+        }
+        if (largest !== index) {
+            this.swap(index, largest);
+            this.heapify(largest);
+        }
+    }
+    swap(i, j) {
+        [this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]];
+    }
+    leftChild(i) {
+        return 2 * i + 1;
+    }
+    rightChild(i) {
+        return 2 * i + 2;
+    }
+    getParent(i) {
+        return Math.floor((i - 1) / 2);
+    }
+    print() {
+        console.log(this.heap.slice(0, this.size));
+    }
+}
+exports.default = MaxHeap;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { default as MaxHeap } from "./Heap/MaxHeap";
+export { default as AvlTree } from "./AVL/AvlTreeOperation";

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvlTree = exports.MaxHeap = void 0;
+var MaxHeap_1 = require("./Heap/MaxHeap");
+Object.defineProperty(exports, "MaxHeap", { enumerable: true, get: function () { return MaxHeap_1.default; } });
+var AvlTreeOperation_1 = require("./AVL/AvlTreeOperation");
+Object.defineProperty(exports, "AvlTree", { enumerable: true, get: function () { return AvlTreeOperation_1.default; } });

package/dist/test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+const heap = new index_1.MaxHeap(5);
+heap.insert(10);
+heap.insert(40);
+heap.insert(30);
+heap.insert(50);
+heap.print(); // [50, 40, 30, 10]
+heap.delete();
+heap.print(); // [40, 10, 30]

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "data-sts31",
+  "version": "1.0.0",
+  "description": "Max Heap implementation in TypeScript",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "node dist/test.js"
+  },
+  "files": ["dist"],
+  "keywords": ["max-heap", "heap", "dsa", "typescript"],
+  "author": "Shubham Shrivastwa",
+  "license": "MIT"
+}