C++

Forum

 
Searching and Sorting a Unsorted Array! C++

Pandaman427 (9)
Hello y'all!
I am working on this program for school and it is doing some weird things.
The compiler is not registering the cin and cout functions, and there are some more errors that i am working on:

15:6: error: variable or field 'bubbleSort' declared void
16:6: error: variable or field 'selectionSort' declared void
In function 'int main()':
28:2: error: 'bubbleSort' was not declared in this scope
29:1: error: expected '}' before 'else'
30:2: error: 'selectionSort' was not declared in this scope
At global scope:
78:1: error: 'cout' does not name a type
79:1: error: 'cin' does not name a type
80:1: error: expected unqualified-id before 'if'
In function 'int binarySearch(int*, int, int)':
115:32: error: expected primary-expression before '/' token
At global scope:
132:1: error: expected declaration before '}' token

If y'all have time please give this code a look through! I am going to keep tinkering with it until it compiles smoothly. It's always somthing so small that stumps me. I am new at this so please give me your feed back!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
 

#include <iostream>
#include <cmath>
#include <string>
#include <cstdlib>
#include <ctime>
using namespace std;

int answer;
int answer2;
int size;
void bubbleSort;
void selectionSort;

int value;


int main()
{

cout << "Which algorithm should be used to sort? (0: Bubble Sort,1:Selection Sort) " << endl;
cin >> answer;
if (answer == 0)
{
	bubbleSort;
else 
	selectionSort;
}
	
int unsorted [] = { 85, 64, 16, 18, 1, 88, 48, 63, 54, 83, 79, 50, 0, 55, 17, 99,
69, 53, 65, 22, 93, 86, 9, 37, 56, 23, 21, 52, 78, 29, 14, 58, 35, 47, 68, 87, 3,
34, 5, 74, 4, 45, 41, 49, 67, 89, 92, 60, 72, 20, 8, 15, 42, 71, 31, 36, 90, 84,
70, 51, 28, 32, 81, 10, 82, 40, 57, 24, 25, 91, 44, 66, 30, 62, 94, 6, 7, 46, 43,
38, 75, 11, 39, 80, 98, 27, 12, 76, 96, 2, 77, 19, 26, 59, 33, 73, 13, 61, 95, 97
}; 

// Bubble Sort Function
void bubbleSort(int unsorted[],int size)
{
	bool swap;
	int temp;
	
	do
	{
		swap = false;
		for (int count = 0;count < (size - 1);count++)
		{
			temp = unsorted[count];
			unsorted[count] = unsorted[count + 1];
			unsorted[count + 1] = temp;
			swap = true;
		}
	} while (swap);
}

// Selection Sort Function
void selectionSort(int unsorted[],int size)
{
	int startScan, minIndex,minValue;
	for (startScan = 0; startScan <(size - 1);startScan++)
	{
		minIndex = startScan;
		minValue = unsorted[startScan];
		for (int index = startScan + 1;index < size;index++)
		{
			minValue = unsorted [index];
			minIndex = index;
		}
	unsorted[minIndex] = unsorted[startScan];
	unsorted[startScan] = minValue;
	}
}

// Sorting completed
cout << "Which algorithm should be used to search? (0:Linear Search, 1: Binary Search) " << endl;
cin >> answer2;
if (answer == 0)
{
	answer == linearSearch;
else 
	answer == binarySearch;
}
// Linear Search Function
int linearSearch(int unsorted[],int numElements,int value)
{
int index = 0; 						// Subscript to search array
int pos = -1;  						// Record postion of search value
bool found = false; 				// To indicate if value was found

while (index < numElements && !found)
{
	if (unsorted[index] == value) 	// If value was found
	{
		found = true;
		pos = index; 			// record value
	}
	index++; 						// Move onto next element in array
}
return pos; 					// Return the postion, or -1
}


// Binary Search Function
int binarySearch(int unsorted[],int size,int value)
{
	int first = 0,
		last = size - 1,
		middle,
		position = -1;
	bool found = false;
	
	while(!found && first + last) / 2;  	// Calcualte the middle element
	{
		if (unsorted[middle] == value)  	// If value is the middle element
		{
		found = true;
		position = middle;
		}
		else if (unsorted[middle] > value)	// If value is in lower part
			last = middle - 1;
		else
			first = middle - 1;				// If value is in upper part
	}
	return position;
}



}
closed account (48T7M4Gy)
Your function declarations at the head of the program must match the corresponding function description at the bottom of the listing.

eg void bubbleSort(int [],int );

the corresponding 2 braces at lines 28 etc are not right.

Last edited on
Pandaman427 (9)
Thank you, i fixed those problems! Now it is seems to have a bunch of warnings and some type of bracket errors im not to sure about. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
 
#include <iostream>
#include <cmath>
#include <string>
#include <cstdlib>

using namespace std;

int answer;
int answer2;
int size;
void bubbleSort(int[],int);
void selectionSort(int[],int);

int value;


int main()
{

cout << "Which algorithm should be used to sort? (0: Bubble Sort,1:Selection Sort) " << endl;
cin >> answer;
if (answer == 0)
{
	bubbleSort;
}
else
{
	selectionSort;
}
	
int unsorted [] = { 85, 64, 16, 18, 1, 88, 48, 63, 54, 83, 79, 50, 0, 55, 17, 99,
69, 53, 65, 22, 93, 86, 9, 37, 56, 23, 21, 52, 78, 29, 14, 58, 35, 47, 68, 87, 3,
34, 5, 74, 4, 45, 41, 49, 67, 89, 92, 60, 72, 20, 8, 15, 42, 71, 31, 36, 90, 84,
70, 51, 28, 32, 81, 10, 82, 40, 57, 24, 25, 91, 44, 66, 30, 62, 94, 6, 7, 46, 43,
38, 75, 11, 39, 80, 98, 27, 12, 76, 96, 2, 77, 19, 26, 59, 33, 73, 13, 61, 95, 97
}; 

// Bubble Sort Function
void bubbleSort(int unsorted[],int size)

{
	bool swap;
	int temp;
	
	do
	{
		swap = false;
		for (int count = 0;count < (size - 1);count++)
		{
			temp = unsorted[count];
			unsorted[count] = unsorted[count + 1];
			unsorted[count + 1] = temp;
			swap = true;
		}
	} while (swap);
}

// Selection Sort Function
void selectionSort(int unsorted[],int size)
{
	int startScan, minIndex,minValue;
	for (startScan = 0; startScan <(size - 1);startScan++)
	{
		minIndex = startScan;
		minValue = unsorted[startScan];
		for (int index = startScan + 1;index < size;index++)
		{
			minValue = unsorted [index];
			minIndex = index;
		}
	unsorted[minIndex] = unsorted[startScan];
	unsorted[startScan] = minValue;
	}
}

// Sorting completed
cout << "Which algorithm should be used to search? (0:Linear Search, 1: Binary Search) " << endl;
cin >> answer2;
if (answer == 0)
{
	answer == linearSearch;
else 
	answer == binarySearch;
}
// Linear Search Function
int linearSearch(int unsorted[],int numElements,int value)
{
int index = 0; 						// Subscript to search array
int pos = -1;  						// Record postion of search value
bool found = false; 				// To indicate if value was found

while (index < numElements && !found)
{
	if (unsorted[index] == value) 	// If value was found
	{
		found = true;
		pos = index; 			// record value
	}
	index++; 						// Move onto next element in array
}
return pos; 					// Return the postion, or -1
}


// Binary Search Function
int binarySearch(int unsorted[],int size,int value)
{
	int first = 0,
		last = size - 1,
		middle,
		position = -1;
	bool found = false;
	
	while(!found && first + last) / 2; 	// Calcualte the middle element
	{
		if (unsorted[middle] == value)  	// If value is the middle element
		{
		found = true;
		position = middle;
		}
		else if (unsorted[middle] > value)	// If value is in lower part
			last = middle - 1;
		else
			first = middle - 1;				// If value is in upper part
	}
	return position;
}



}


The compiler spits out:

In function 'int main()':
24:12: warning: statement is a reference, not call, to function 'bubbleSort' [-Waddress]
24:12: warning: statement has no effect [-Wunused-value]
28:15: warning: statement is a reference, not call, to function 'selectionSort' [-Waddress]
28:15: warning: statement has no effect [-Wunused-value]
41:1: error: a function-definition is not allowed here before '{' token
31:5: warning: unused variable 'unsorted' [-Wunused-variable]
131:2: error: expected '}' at end of input
closed account (48T7M4Gy)
Forget the warnings for a while and go to the first error. It's telling you line 41 is sh!t, to put it bluntly. You need to read the messages and learn how to use them - it is a cruel exercise but 'you made em, you fix em'.

However, you have ; in the wrong spot. main should finish
return 0;
}

Not the way you've done it. :)

PS line 131 ?? - your turn.
Last edited on
Pandaman427 (9)
So my main should finish up top or at the end of my program? Which ; is in the wrong spot? I'm sorry I am new to programming so stuff like this really stumps me.
closed account (48T7M4Gy)
int main()
{
code here
return 0;
}

int function1()
{
code ...
return xyz;
}

double function2()
{
code;
return abc;
}
lionman2201 (1)
Did you finish the program Panda? If so I can look over it to double check it for you.
Pandaman427 (9)
This is as far as I have gone with it at the moment:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
 
#include <iostream>
#include <cmath>
#include <string>
#include <cstdlib>

using namespace std;

int answer;
int answer2;
int size;
void bubbleSort(int[], int);
void selectionSort(int[], int);
int binarySearch(int unsorted[], int size, int value); 
int linearSearch(int unsorted[], int numElements, int value);  
int value;
int numElements;

int unsorted[] =
{
    85, 64, 16, 18, 1, 88, 48, 63, 54, 83, 79, 50, 0, 55,
    17, 99, 69, 53, 65, 22, 93, 86, 9, 37, 56, 23, 21, 52,
    78, 29, 14, 58, 35, 47, 68, 87, 3, 34, 5, 74, 4, 45,
    41, 49, 67, 89, 92, 60, 72, 20, 8, 15, 42, 71, 31, 36,
    90, 84,70, 51, 28, 32, 81, 10, 82, 40, 57, 24, 25, 91,
    44, 66, 30, 62, 94, 6, 7, 46, 43,38, 75, 11, 39, 80,
    98, 27, 12, 76, 96, 2, 77, 19, 26, 59, 33, 73, 13,
    61, 95, 97
};

int main()
{
    cout <<
        "Which algorithm should be used to sort?" <<
        "(0: Bubble Sort, 1: Selection Sort)" << endl;

    cin >> answer;
    if (answer == 0)
    {
        bubbleSort(int unsorted[], int size);         
    }
    else
    {
        selectionSort(int unsorted[], int size);      
    }
     cout <<
        "Which algorithm should be used to search?" <<
        "(0: Linear Search, 1: Binary Search)" << endl;

    cin >> answer2; 
    if (answer2 == 0)    // <----- This should be answer2, not answer.
    {
        answer2 = linearSearch(unsorted, numElements, value);     
    }
    else
    {
        answer2 = binarySearch(unsorted, size, value);   
    }

}
// Bubble Sort Fun
void bubbleSort(int unsorted[], int size)
{
    bool swap;
    int temp;

    do
    {
        swap = false;
        for (int count = 0; count < (size - 1); count++)
        {
            if (unsorted[count] > unsorted[count - 1]; count++)
            {
                temp = unsorted[count];
                unsorted[count] = unsorted[count + 1];
                unsorted[count + 1] = temp;
                swap = true;
            }
        }
    } while (swap);
}

// Selection Sort Function
void selectionSort(int unsorted[], int size)
{
    int startScan, minIndex, minValue;
    for (startScan = 0; startScan < (size - 1); startScan++)
    {
        minIndex = startScan;
        minValue = unsorted[startScan];
        for (int index = startScan + 1; index < size; index++)
        {
            minValue = unsorted[index];
            minIndex = index;
        }
        unsorted[minIndex] = unsorted[startScan];
        unsorted[startScan] = minValue;
    }
}
    // Linear Search Function
int linearSearch(int unsorted[], int numElements, int value)
{
    int index = 0;                      
    int pos = -1;                       
    bool found = false;                 

    while (index < numElements && !found)
    {
        if (unsorted[index] == value) 
        {
            found = true;
            pos = index; 
        }
        index++; 
    }
    return pos; 
}
// Binary Search Function
int binarySearch(int unsorted[], int size, int value)
{
    int first = 0,
        last = size - 1,
        middle,
        position = -1;
    bool found = false;

    while (!found);  
      {
          middle = (first + last) / 2;        // Calculate the middle element
          
          if (unsorted[middle] == value)      // If value is the middle element
          {
              found = true;
              position = middle;
          }
          else if (unsorted[middle] > value)  // If value is in lower part
              last = middle - 1;
          else
              first = middle + 1;             // If value is in upper part
      }
      return position;
  
    return 0;
}


here are my errors:
In function 'int main()':
39:20: error: expected primary-expression before 'int'
39:36: error: expected primary-expression before 'int'
43:23: error: expected primary-expression before 'int'
43:39: error: expected primary-expression before 'int'
In function 'void bubbleSort(int*, int)':
71:54: error: expected ')' before ';' token
71:63: error: expected ';' before ')' token
64:9: warning: unused variable 'temp' [-Wunused-variable]

I know its usually a logical error on my behalf but I am still working on this program.
closed account (18hRX9L8)
You're declaring variables in function calls, which is not proper syntax.
Last edited on
Pandaman427 (9)
Only have two errors now! 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
 
#include <iostream>
#include <cmath>
#include <string>
#include <cstdlib>

using namespace std;

int answer;
int answer2;
int size;
void bubbleSort(int[], int);
void selectionSort(int[], int);
int binarySearch(int unsorted[], int size, int value); 
int linearSearch(int unsorted[], int numElements, int value);  
int value;
int numElements;

int unsorted[] =
{
    85, 64, 16, 18, 1, 88, 48, 63, 54, 83, 79, 50, 0, 55,
    17, 99, 69, 53, 65, 22, 93, 86, 9, 37, 56, 23, 21, 52,
    78, 29, 14, 58, 35, 47, 68, 87, 3, 34, 5, 74, 4, 45,
    41, 49, 67, 89, 92, 60, 72, 20, 8, 15, 42, 71, 31, 36,
    90, 84,70, 51, 28, 32, 81, 10, 82, 40, 57, 24, 25, 91,
    44, 66, 30, 62, 94, 6, 7, 46, 43,38, 75, 11, 39, 80,
    98, 27, 12, 76, 96, 2, 77, 19, 26, 59, 33, 73, 13,
    61, 95, 97
};

int main()
{
    cout <<
        "Which algorithm should be used to sort?" <<
        "(0: Bubble Sort, 1: Selection Sort)" << endl;

    cin >> answer;
    if (answer == 0)
    {
        bubbleSort( unsorted[],  size);         
    }
    else
    {
        selectionSort( unsorted[], size);      
    }
     cout <<
        "Which algorithm should be used to search?" <<
        "(0: Linear Search, 1: Binary Search)" << endl;

    cin >> answer2; 
    if (answer2 == 0)    // <----- This should be answer2, not answer.
    {
        answer2 = linearSearch(unsorted, numElements, value);     
    }
    else
    {
        answer2 = binarySearch(unsorted, size, value);   
    }

}
// Bubble Sort Fun
void bubbleSort(int unsorted[], int size)
{
    bool swap;
    int temp;

    do
    {
        swap = false;
        for (int count = 0; count < (size - 1); count++)
        {
            if (unsorted[count] > unsorted[count + 1])
            {
                temp = unsorted[count];
                unsorted[count] = unsorted[count + 1];
                unsorted[count + 1] = temp;
                swap = true;
            }
        }
    } while (swap);
}

// Selection Sort Function
void selectionSort(int unsorted[], int size)
{
    int startScan, minIndex, minValue;
    for (startScan = 0; startScan < (size - 1); startScan++)
    {
        minIndex = startScan;
        minValue = unsorted[startScan];
        for (int index = startScan + 1; index < size; index++)
        {
            minValue = unsorted[index];
            minIndex = index;
        }
        unsorted[minIndex] = unsorted[startScan];
        unsorted[startScan] = minValue;
    }
}
    // Linear Search Function
int linearSearch(int unsorted[], int numElements, int value)
{
    int index = 0;                      
    int pos = -1;                       
    bool found = false;                 

    while (index < numElements && !found)
    {
        if (unsorted[index] == value) 
        {
            found = true;
            pos = index; 
        }
        index++; 
    }
    return pos; 
}
// Binary Search Function
int binarySearch(int unsorted[], int size, int value)
{
    int first = 0,
        last = size - 1,
        middle,
        position = -1;
    bool found = false;

    while (!found);  
      {
          middle = (first + last) / 2;        // Calculate the middle element
          
          if (unsorted[middle] == value)      // If value is the middle element
          {
              found = true;
              position = middle;
          }
          else if (unsorted[middle] > value)  // If value is in lower part
              last = middle - 1;
          else
              first = middle + 1;             // If value is in upper part
      }
      return position;
  
    return 0;
}


here are my errors again:

In function 'int main()':
39:30: error: expected primary-expression before ']' token
43:33: error: expected primary-expression before ']' token

Thank you guys so much! This form really helps me out. Again I think its a simple error that is on my part.
closed account (18hRX9L8)
The compiler describes the problem exactly... Remove the [] in the calls on lines 39 and 43.
Last edited on
Pandaman427 (9)
Thank you, i knew it would be something stupid on my behalf. I am new to c++. I need to get better at reading compilers.
Pandaman427 (9)
ok so i got it running but now i need it tell the user how many loops it each function does on this array. I need to implement a counter function in each sorting and searching function. Here is my code as it stands:

P.S: I know that these cout functions have the wrong variables inside them. That is also what I need help with.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
 
#include <iostream>
#include <cmath>
#include <string>
#include <cstdlib>

using namespace std;

int answer;
int answer2;
int size;
void bubbleSort(int[], int);
void selectionSort(int[], int);
int binarySearch(int unsorted[], int size, int value); 
int linearSearch(int unsorted[], int numElements, int value);  
int value;
int numElements;
int count;

int unsorted[] =
{
    85, 64, 16, 18, 1, 88, 48, 63, 54, 83, 79, 50, 0, 55,
    17, 99, 69, 53, 65, 22, 93, 86, 9, 37, 56, 23, 21, 52,
    78, 29, 14, 58, 35, 47, 68, 87, 3, 34, 5, 74, 4, 45,
    41, 49, 67, 89, 92, 60, 72, 20, 8, 15, 42, 71, 31, 36,
    90, 84,70, 51, 28, 32, 81, 10, 82, 40, 57, 24, 25, 91,
    44, 66, 30, 62, 94, 6, 7, 46, 43,38, 75, 11, 39, 80,
    98, 27, 12, 76, 96, 2, 77, 19, 26, 59, 33, 73, 13,
    61, 95, 97
};

int main()
{
    cout <<
        "Which algorithm should be used to sort?" <<
        "(0: Bubble Sort, 1: Selection Sort)" << endl;

    cin >> answer;
    if (answer == 0)
    {
        bubbleSort( unsorted,  size);         
    }
    else
    {
        selectionSort( unsorted, size);      
    }
     cout <<
        "Which algorithm should be used to search?" <<
        "(0: Linear Search, 1: Binary Search)" << endl;

    cin >> answer2; 
    if (answer2 == 0)    // <----- This should be answer2, not answer.
    {
        answer2 = linearSearch(unsorted, numElements, value);     
    }
    else
    {
        answer2 = binarySearch(unsorted, size, value);   
    }

}
// Bubble Sort Function
void bubbleSort(int unsorted[], int size)
{
    bool swap;
    int temp;

    do
    {
        swap = false;
        for (int count = 0; count < (size - 1); count++)
        {
            if (unsorted[count] > unsorted[count + 1])
            {
                temp = unsorted[count];
                unsorted[count] = unsorted[count + 1];
                unsorted[count + 1] = temp;
                swap = true;
            }
        }
    } while (swap);
        cout << "With using Bubble Sort it looped " << size << " times! " << endl;  // I know that size is not correct to give the output.
                                                                                    //IDK what i need to do get a counter function in this loop.
}


// Selection Sort Function
void selectionSort(int unsorted[], int size)
{
    int startScan, minIndex, minValue;
    for (startScan = 0; startScan < (size - 1); startScan++)
    {
        minIndex = startScan;
        minValue = unsorted[startScan];
        for (int index = startScan + 1; index < size; index++)
        {
            minValue = unsorted[index];
            minIndex = index;
        }
        unsorted[minIndex] = unsorted[startScan];
        unsorted[startScan] = minValue;
    }
    cout << "With using Selection Sort it looped " << size << " times! " << endl;   // I need another counter function that works!
}
// Linear Search Function
int linearSearch(int unsorted[], int numElements, int value)
{
    int index = 0;                      
    int pos = -1;                       
    bool found = false;                 

    while (index < numElements && !found)
    {
        if (unsorted[index] == value) 
        {
            found = true;
            pos = index; 
        }
        index++; 
    } 
    cout << "With using Linear Search it looped " << numElements << " times! " << endl;  //  And anohter counter function!
    return pos;
}
// Binary Search Function
int binarySearch(int unsorted[], int size, int value)
{
    int first = 0,
        last = size - 1,
        middle,
        position = -1;
    bool found = false;

    while (!found);  
      {
          middle = (first + last) / 2;        // Calculate the middle element
          
          if (unsorted[middle] == value)      // If value is the middle element
          {
              found = true;
              position = middle;
          }
          else if (unsorted[middle] > value)  // If value is in lower part
              last = middle - 1;
          else
              first = middle + 1;             // If value is in upper part 
      }
      return position;
    cout << "With using Binary Search it looped " << size << " times! " << endl;  // Last counter function
    return 0;
}


Also my cout function on the binary search function is not working, probably just another logical error I did. Let me know guys!
Thanks!
closed account (48T7M4Gy)
OK we'll get onto it right away chief.
Topic archived. No new replies allowed.