TreeNode* makeBST(ListNode* list, int len){
if (len == 0){
return NULL;
}
if (len == 1){
return new TreeNode(list->val);
}
int sz = 0;
auto right = list;
for (int i = 0; i < len / 2; i++){
right = right->next;
sz++;
}
TreeNode *ans = new TreeNode(right->val);
while(right && right->next && right->val == right->next->val){
right = right->next;
sz++;
}
ans->left = makeBST(list, sz);
ans->right = makeBST(right->next, len - sz - 1);
return ans;
}
struct node *makeBST(int *arr, int i, int j)
{
if ((i > j)||i<0)return NULL;
int mid = (i + j) / 2;
struct node *temp = (struct node*)malloc(sizeof(struct node));
temp->data = arr[mid];
temp->right = makeBST(arr, mid + 1, j);
temp->left = makeBST(arr, i, mid - 1);
return temp;
}
void makeBST(TreeNode *&root, vector<int> &num, int left, int right){
if(left > right){
root = NULL;
return ;
}
if(left == right){
root = new TreeNode(num[left]);
return;
}
int mid = left + (right-left)/2;
root = new TreeNode(num[mid]);
makeBST(root->left, num, left, mid);
makeBST(root->right, num, mid+1, right);
}
TreeNode *makeBST(vector<int> &num, int start, int end)
{
if(start > end)
return NULL;
if(start == end)
return new TreeNode(num[start]);
else
{
int mid = (start + end)/2;
TreeNode* root = new TreeNode(num[mid]);
root->left = makeBST(num, start, mid - 1);
root->right = makeBST(num, mid + 1, end);
return root;
}
}
TreeNode* makeBST(int l, int r){
if (l > r){
return NULL;
}
if (l == r){
return new TreeNode((*vect)[l]);
}
int m = (l + r) / 2;
TreeNode *cur = new TreeNode((*vect)[m]);
auto it = upper_bound((*vect).begin(), (*vect).end(), (*vect)[m]);
cur->left = makeBST(l, it - (*vect).begin() - 2);
cur->right = makeBST(it - (*vect).begin(), r);
return cur;
}
int main()
{
Tree* tree;
printf("välkommen till skagettikåd\n\n");
printf("No.items, Sekvential, BinaryST, HashTable\n");
//loop
for (int numberOfitems = 50000; numberOfitems <= 5000000; numberOfitems = numberOfitems * 10)
{
int* arr = (int*)calloc(numberOfitems, sizeof(int));
FILE* fp;
fp = fopen("5 000 000 unika slumpade tal.txt", "r");
for (int i = 0; i < numberOfitems; i++)
{
fscanf(fp, "%d", &arr[i]);
}
fclose(fp);
//stuff
makeHashTable(arr, numberOfitems);
tree = makeBST(arr, numberOfitems);
//time variables
double timeSekventiall = 0;
double timeBST = 0;
double timeHash = 0;
//Genomför sköningen 100 gånger
for (int i = 0; i < 100; i++)
{
int searchfor = 1;
timeSekventiall += sekventiell(arr, searchfor, numberOfitems);
timeBST += searchBST(tree, searchfor, numberOfitems);
timeHash += searchHashTable(arr, searchfor, numberOfitems);
}
//dela på 100 för att få genomsnitt
timeSekventiall = timeSekventiall / 100;
timeBST = timeBST / 100;
timeHash = timeHash / 100;
//Print it!
printf("%8d%10Lf%12Lf%10Lf\n", numberOfitems, timeSekventiall, timeBST, timeHash);
//free
free(arr);
emptyTree(tree, tree->root);
}
system("pause");
return 0;
}
TreeNode* sortedListToBST(ListNode* head) {
auto tmp = head;
int len = 0;
while(tmp){
tmp = tmp->next;
len++;
}
return makeBST(head, len);
}
int main()
{
Node *root = makeBST();
displayPath(root,25);
cout << endl;
displayPath1(root,25);
return 0;
}
TreeNode* sortedArrayToBST(vector<int>& nums) {
vect = &nums;
return makeBST(0, nums.size() - 1);
}
struct node *convert_array_to_bst(int *arr, int len){
if (len <= 0 || arr == NULL)return NULL;
return makeBST(arr, 0, len-1);
}
TreeNode *sortedArrayToBST(vector<int> &num) {
int len = num.size();
if(len == 0)
return NULL;
return makeBST(num, 0, len - 1);
}
TreeNode *sortedArrayToBST(vector<int> &num) {
TreeNode *root;
if(!num.size()) return NULL;
makeBST(root, num, 0, num.size()-1);
return root;
}
int main(int argc, const char *argv[])
{
makeBST();
return 0;
}
