Add files via upload

Author: alirezakhayyatian

Diff for: AP-HW3/Q1/Q1.html

@@ -0,0 +1,16 @@
+CXX = g++
+CXXFLAGS = -std=c++17 -Wall -c 
+LXXFLAGS = -std=c++17 
+OBJECTS = main.o maxheap.o
+TARGET = main
+
+$(TARGET): $(OBJECTS)
+	$(CXX) $(LXXFLAGS) $(OBJECTS) -o $(TARGET)
+main.o: main.cpp
+	$(CXX)	$(CXXFLAGS)	main.cpp
+maxheap.o: maxheap.cpp maxheap.h
+	$(CXX)	$(CXXFLAGS)	maxheap.cpp
+clean:
+	rm -f $(TARGET) $(OBJECTS)		
+
+	

Diff for: AP-HW3/Q1/asxz.html

@@ -0,0 +1,49 @@
+#include"maxheap.h"
+#include <iostream>
+
+int main()
+{
+	Maxheap h1{};
+	h1.add(25);
+	h1.add(32);
+	h1.add(17);
+	h1.add(23);
+	h1.add(101);  
+ 
+	std::cout << h1 << std::endl;  
+	/* 
+	101,
+	32, 17,
+	23, 25
+	*/
+	std::cout << h1.parent(2) << std::endl; // 101                
+	std::cout << h1.LeftChild(0) << std::endl;  // 32
+	std::cout << h1.RightChild(0) << std::endl;  // 17
+
+
+	int arr[7] {23, 1, 7, 52, 11, 10, 75};
+	Maxheap h2{arr, 7};
+	//h2.add(14);
+			
+	std::cout << h2 << std::endl;  
+	std::cout << h2.getHeight() << std::endl; // 2
+
+
+	Maxheap h3{h2};
+
+	h2.Heapsort();
+	h2.printArray(); // 75, 52, 23, 11, 10, 7, 1
+
+	
+	std::cout << h3.max(); //75
+
+	h3[0] = h3[0] - 25;                                      //////22222 
+
+	std::cout << h3.max(); //52
+	h3.Delete();                                              
+	std::cout << h3.max(); //50
+
+
+		
+	return 0;
+}

Diff for: AP-HW3/Q1/jquery-1.9.1.min.js

@@ -0,0 +1,212 @@
+#include "maxheap.h"
+#include  <cmath>
+
+Maxheap::Maxheap(int cap) 
+{ 
+    heap_size = 0; 
+    capacity = cap; 
+    harr = new int[cap]; 
+}
+//Defaule Constructor 
+Maxheap::Maxheap():Maxheap(10){ 
+    std::cout<<"Defaule Constructor"<<std::endl;
+}
+//Copy Constructor 
+Maxheap::Maxheap(const Maxheap& h){
+	std::cout<<"Copy Constructor"<<std::endl;
+	heap_size=h.heap_size;
+	capacity=h.capacity;
+	harr=new int[capacity];
+	for (int i = 0; i < heap_size; ++i)
+	{
+		harr[i]=h.harr[i];
+		
+
+	}
+	
+}
+
+Maxheap::Maxheap(int* arr,int num){
+	heap_size=num;
+	capacity=num;
+	harr=new int[capacity];
+	int i{};
+	for (int j = 0; j < heap_size; ++j)
+	{
+		harr[j]=arr[j];
+		i=j;
+		 while (i != 0 && harr[Parent(i)] < harr[i]) 
+        { 
+         swap(&harr[i], &harr[Parent(i)]); 
+         i = Parent(i); 
+        }
+		
+	}
+
+	
+}
+  
+// add a new key 'k' 
+void Maxheap::add(int k) 
+{ 
+	capacity++;
+    if (heap_size == capacity) 
+    { 
+        std::cout << "\nOverflow: Could not insertKey\n"; 
+        return; 
+    } 
+  
+    // First insert the new key at the end 
+    heap_size++; 
+    int i = heap_size - 1; 
+    harr[i] = k; 
+  
+    // Fix the min heap property if it is violated 
+    while (i != 0 && harr[Parent(i)] < harr[i]) 
+    { 
+       swap(&harr[i], &harr[Parent(i)]); 
+       i = Parent(i); 
+    } 
+} 
+  
+// Decreases value of key at index 'i' to new_val.  It is assumed that 
+// new_val is smaller than harr[i]. 
+void Maxheap::decreaseKey(int i, int new_val) 
+{ 
+    harr[i] = new_val; 
+    while (i != 0 && harr[Parent(i)] > harr[i]) 
+    { 
+       swap(&harr[i], &harr[Parent(i)]); 
+       i = Parent(i); 
+    } 
+} 
+  
+// Method to remove maximum element (or root) from min heap 
+int Maxheap::extractMax() 
+{ 
+    if (heap_size <= 0) 
+        return INT_MIN; 
+    if (heap_size == 1) 
+    { 
+        heap_size--; 
+        return harr[0]; 
+    } 
+  
+    // Store the maximum value, and remove it from heap 
+    int root = harr[0]; 
+    harr[0] = harr[heap_size-1]; 
+    heap_size--; 
+    Maxheapify(0); 
+  
+    return root; 
+} 
+  
+  
+// This function deletes key at index i. It first reduced value to minus 
+// infinite, then calls extractMin() 
+void Maxheap::Delete() 
+{ 
+    //decreaseKey(0, INT_MAX); 
+    //extractMax(); 
+    if (heap_size <= 0) 
+        return; 
+    if (heap_size == 1) 
+    { 
+        heap_size--; 
+        return; 
+    } 
+  
+    //remove maximuu from heap 
+    harr[0] = harr[heap_size-1]; 
+    heap_size--; 
+    Maxheapify(0); 
+}
+
+
+  
+// A recursive method to heapify a subtree with the root at given index 
+// This method assumes that the subtrees are already heapified 
+void Maxheap::Maxheapify(int i) 
+{ 
+	//std::cout<<"Heapify"<<std::endl;
+    int l = left(i); 
+    int r = right(i); 
+    int smallest = i; 
+    if (l < heap_size && harr[l] > harr[i]) 
+        smallest = l; 
+    if (r < heap_size && harr[r] > harr[smallest]) 
+        smallest = r; 
+    if (smallest != i) 
+    { 
+        swap(&harr[i], &harr[smallest]); 
+        Maxheapify(smallest); 
+    } 
+} 
+
+// A utility function to swap two elements 
+void swap(int *x, int *y) 
+{ 
+    int temp = *x; 
+    *x = *y; 
+    *y = temp; 
+} 
+
+std::ostream& operator<<(std::ostream& os,const Maxheap& h){
+	int a{};
+	int b{};
+	for (int i = 0; i < h.heap_size; ++i)
+	{ 
+		a++;
+		os<<h.harr[i]<<" ";
+		b=std::log(a+1) / std::log(2);
+		if(b == ( std::ceil( std::log(a+1)/std::log(2) )))
+			if(a !=(h.heap_size))
+				std::cout<<std::endl;
+
+	}
+	
+	return os;
+}
+
+int Maxheap::getHeight(){
+   return (std::ceil(std::log(heap_size+1)/log(2))-1);
+}
+
+void Maxheap::printArray(){
+	for (int i = 0; i < heap_size; ++i)
+	{
+		std::cout<<harr[i]<<" ";
+	}
+	std::cout<<std::endl;
+}
+
+
+void Maxheap::Heapsort(){
+	int* arr_new=new int[heap_size];
+	int temp= heap_size;
+	for (int i = 0; i < temp; ++i)
+	{
+		arr_new[i]=extractMax();
+		
+	}
+	harr=arr_new;
+	arr_new=nullptr;
+	heap_size=temp;
+	this->printArray();
+}
+
+
+
+
+
+int Maxheap::operator+(int a){
+	return 1;
+
+}
+int Maxheap::operator-(int a){
+	return 1;
+
+}
+
+
+

Diff for: AP-HW3/Q2/Makefile

@@ -0,0 +1,75 @@
+#ifndef MAXHEAP_H
+#define MAXHEAP_H
+
+#include <iostream>
+#include <climits>
+#include <vector>
+
+class Maxheap;
+std::ostream& operator<<(std::ostream& os,const Maxheap& h);
+
+
+void swap(int *x, int *y); 
+
+class Maxheap 
+{ 
+   /* int *harr; // pointer to array of elements in heap 
+    int capacity; // maximum possible size of max heap 
+    int heap_size; // Current number of elements in max heap*/ 
+public:
+    
+    int *harr; // pointer to array of elements in heap 
+    int capacity; // maximum possible size of max heap 
+    int heap_size; // Current number of elements in max heap 
+
+    // Constructor 
+    Maxheap(int capacity); 
+    Maxheap();
+    Maxheap(const Maxheap& ); 
+    Maxheap(int*,int num);
+  
+    // to heapify a subtree with the root at given index 
+    void Maxheapify(int ); 
+    int parent(int i){return harr[(i-1)/2];} //small 
+    int Parent(int i) { return (i-1)/2; }    //capital
+  
+    // to get index of left child of node at index i 
+    int LeftChild(int i){ return  harr[(2*(i) + 1)];}
+    int left(int i) { return (2*i + 1); } 
+  
+    // to get index of right child of node at index i 
+    int RightChild(int i){ return  harr[(2*(i) + 2)];}
+    int right(int i) { return (2*i + 2); } 
+  
+    // to extract the root which is the minimum element 
+    int extractMax(); 
+  
+    // Decreases key value of key at index i to new_val 
+    void decreaseKey(int i, int new_val); 
+  
+    // Returns the minimum key (key at root) from min heap 
+    int getMax() { return harr[0]; } 
+  
+    // Deletes a key stored at index i 
+    void Delete(); 
+    //int Delete();
+  
+    // add a new key 'k' 
+    void add(int k); 
+    int getHeight();
+    void printArray();
+    int max(){return harr[0];}
+    void Heapsort();
+
+    //operator
+    int& operator[](const int& i){return harr[i]; }
+    int operator+(int);
+    int operator-(int);
+
+
+
+
+
+};
+
+#endif

Diff for: AP-HW3/Q2/main

@@ -0,0 +1,16 @@
+CXX = g++
+CXXFLAGS = -std=c++17 -Wall -c 
+LXXFLAGS = -std=c++17 
+OBJECTS = main.o vec.o
+TARGET = main
+
+$(TARGET): $(OBJECTS)
+	$(CXX) $(LXXFLAGS) $(OBJECTS) -o $(TARGET)
+main.o: main.cpp
+	$(CXX)	$(CXXFLAGS)	main.cpp
+vec.o: vec.cpp vec.h
+	$(CXX)	$(CXXFLAGS)	vec.cpp
+clean:
+	rm -f $(TARGET) $(OBJECTS)		
+
+