SEMINAR – KËRKIMI

1. Tregoni dallimet mes kërkimit linear dhe kërkimit binar.

a. Në cilin rast duhet që të dhënat të jenë të rradhitura?
b. Cili është kompleksiteti në kohë për secilin nga këto algoritma?
c. A mund të zbatohen të dy këto tipe kërkimi në vektorë shumë dimensional?
d. Cili prej këtyre dy algoritmave performon më shpejt?
e. Cili është kompleksiteti në hapësirë për secilin prej këtyre algoritmave?

2. Në një PBK veprimet e kërkimit, shtimit dhe fshirjes veprojnë zakonisht në kohë O(d).
Çfarë përfaqëson d në këtë rast?
a. Numrin total të nyjeve në pemë
b. Thellësinë e kësaj nyje në pemë
c. Numrin e ndarjeve në çdo nivel
d. Numrin e nyjeve gjethe

3. Shkruani një funksion rekursiv BSTsmallcount i cili duke pasur të dhënë një PBK dhe
një vlerë key, kthen numrin e nyjeve që kanë vlerë më të vogël se key. Funksioni duhet
të vizitoj sa më pak nyje të jenë të nevojshme.

public int BSTsmallcount(Node root, int key)

{

4. Ndërtoni një metodë që kontrollon nëse një pemë binare është një pemë binare kërkimi
apo jo.

5. Në momentin që duam të fshijmë një nyje nga një pemë binare kërkimi mund të
zgjedhim si metodë atë që cilësohet si ‘lazy-deletion’. Kjo nënkupton që nyjet që
fshihen thjesht etiketohen sit ë fshira, por qëndrojnë në pemë. Cilat mendoni se janë
avantazhet dhe disavantazhet e kësaj metode?
Implementoni ndryshimet e duhura ne klasen Node:
- Shtimin e variablit etiketë fshirë/jo_fshirë
- Shtimin e dy variablave numri_total (numri i elementeve) dhe numri_fshire (numri
i elementeve te fshire)
- Arsyetoni si do të ndryshonin metodat e tjera të lidhura me PBK në këtë mënyrë
implementimi.
6. Supozoni se vlerat e ruajtura në një PBK janë midis 1 dhe 10, dhe ne po kërkojmë për
vlerën 5. Cilat nga sekuencat e mëposhtme nuk mund të ketë ndodhur?
a. 10, 9, 8, 7, 6, 5
b. 4, 10, 8, 7, 5, 3
c. 1, 10, 2, 9, 3, 8, 4, 7, 6, 5
d. 2, 7, 3, 8, 4, 5
e. 1, 2, 10, 4, 8, 5

7. Një tip tjetër algoritmi kërkimi është algoritmi ‘jump search’. Ky algoritëm në mënyrë
të ngjashme me ‘binary search’ vepron mbi bashkësitë e rradhitura të të dhënave. Idea
bazë është të kontrollohen më pak elementë (sesa në rastin e kërkimit linear) duke
kërcyer me një numër të caktuar hapash. Në momentin që gjendet një element më i
madh se elementi që po kërkojmë atëherë zbatohet kërkimi linear në intervalin e fundit
të kontrolluar.

Konsideroni vektorin e mëposhtëm:

(0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610)
Gjatësia e vektorit është 16. Tregoni hap pas hapi si do të kryhej kërkimi sipas
algoritmit jump search në këtë vektor nëse hapi i kërcimit do të jetë 4 dhe elementi që
po kërkojmë është 55.
Analizoni ndikimin e ekzekutimit në kohë të këtij algoritmi në varësi të madhësisë së
vektorit n/ hapit të kërcimit m.

8. Cila është lartësia maksimale e një peme AVL me 7 nyje? Supozoni se lartësia e një
peme me një nyje të vetme është 0.
a. 2
b. 3
c. 4
d. 5

9. Duke u bazuar në kompleksitetin e shtimit, fshirjes dhe kërkimit në një pemë AVL
cila nga shprehjet e mëposhtme është e vërtetë:
a. Kosto e kërkimit në një pemë AVL është O(logn) ndërsa ajo në një pemë binare
kërkimi është O(n)
b. Kosto e kërkimit në një pemë AVL është O(logn) ndërsa ajo në një pemë binare
komplete është O(nlogn)
c. Kosto e kërkimit në një pemë binare kërkimi është O(logn) ndërsa ajo në një
pemë AVL është O(n)
d. Kosto e kërkimit në një pemë AVL është O(nlogn) ndërsa ajo në një pemë binare
kërkimi është O(n)

10. Cila është koha me e keqe e ekzekutimit për të kërkuar një element në një pemë binare
të balancuar me n*2n elementë:
a. O(nlogn)
b. O(n*2n)
c. O(n)
d. O(logn)
11. Konsideroni pemën e mëposhtme AVL.

Cila nga figurat e mëposhtme paraqet pemën AVL të modifikuar pas shtimit të 70?

a.

b.

c.
d. Asnjëra

12. Jepet një pemë binare kërkimi. Gjeni pasuesin në rradhitjen inorder (ndërrendore) të një
vlere key. Nëse kjo vlerë key nuk ndodhet në PBK atëherë ktheni si vlerë nyjen me
vlerë pas tij që gjendet në PBK.

Shembull:
Pasuesi në inorder i vlerës 8 do të ishte 10.
Pasuesi në inorder i vlerës 12 do të ishte 15.
Pasuesi në inorder i vlerës 15 do të ishte 16.
BINARY SEARCH TREES
class Node1 {
int value;
Node1 left;
Node1 right;

Node1(int value) {
this.value = value;
right = null;
left = null;
}
}

public class BinarySearchTree {

Node1 root;

private Node1 addRecursive(Node1 current, int value) {

if (current == null) {
return new Node1(value);
}

if (value < current.value) {

current.left = addRecursive(current.left, value);
}
else if (value > current.value) {
current.right = addRecursive(current.right, value);
}
else {
// value exist
return current;
}

return current;
}

//Start from this node

public void add(int value) {
root = addRecursive(root, value);
}

private boolean Search(Node1 current, int value) {

if (current == null) {
return false;
}
if (value == current.value) {
return true;
}

return value < current.value

 ? Search(current.left, value)
: Search(current.right, value);
}

public boolean containsNode(int value) {

return Search(root, value);
}

private Node1 delete(Node1 current, int value) {

if (current == null) {
return null;
}

if (value == current.value) {
//Kontrollon nese nyja qe do te fshijme ka zero femije
if (current.left == null && current.right == null) {
return null;
}

//Kontrollon nese nyja qe do te fshihet nuk ka femije te djathte

if (current.right == null) {
return current.left;
}

//Kontrollon nese nyja qe do te fshihet nuk ka femije te majte

if (current.left == null) {
return current.right;
}

//Merr parasysh nese nyja qe do te fshijme ka dy femije

//Gjejme vleren minimale ne nenpemen e djathte
int LargestValue = findLargestValue(current.left);

//Vlera e nyjes qe duhet te fshijme behet e barabarte me vleren minimale te

nennpemes se djathte
current.value = LargestValue;

//Fshijme nyjen minimale te cilen zevendesuam me pare

current.left = delete(current.left, LargestValue);

}
else if (value < current.value)
{
current.left = delete(current.left, value);
}
else
current.right = delete(current.right, value);

return current;
}
 public void deleteNode(int value) {
root = delete(root, value);
}

private int findLargestValue(Node1 root) {

if(root.right==null)
{
return root.value;
}
else
{
return findLargestValue(root.right);
}
}

private static int findSmallestValue(Node1 root) {

if(root.left==null)
{
return root.value;
}
else
{
return findLargestValue(root.left);
}
}
// Print the nodes: Breadth First Traversal
public void printLevelOrder()
{
int h = height(root);
int i;
for (i=1; i<=h; i++)
printGivenLevel(root, i);
}

// Print nodes at the given level

void printGivenLevel (Node1 root ,int level)
{
if (root == null)
return;
if (level == 1)
System.out.print(root.value + " ");
else if (level > 1)
{
printGivenLevel(root.left, level-1);
printGivenLevel(root.right, level-1);
}
}

// Calculate the height of a tree.

 int height(Node1 root)
{
if (root == null)
return 0;
else
{
// compute height of each subtree
int lheight = height(root.left);
int rheight = height(root.right);

// use the larger one

if (lheight > rheight)
return (lheight+1);
else
return (rheight+1);
}
}

public static void main(String[] args)

{
BinarySearchTree bt = new BinarySearchTree();
bt.add(6);
bt.add(4);
bt.add(8);
bt.add(3);
bt.add(5);
bt.add(7);
bt.add(9);

/*
6
/ \
4 8
/\ /\
3 5 7 9

*/

bt.printLevelOrder(); //Breadth First Traversal

//6 4 8 3 5 7 9
}
}