AndroidSketchpad

class DataK(size:int){
} 

val array: Array<Int> = Array(size,{i -> i})
var numberOfTry = 0

init {
    for (i in 1 until size){
         array[i-1] = i
     }
}

we want to find 9999

Set the initial number of try to zero

And the last declare a new variable, named it to result and this will hold the result.
everything is set, now I am ready for the main action

To search run a for loop from 0 to the data size and compare the index value with our searching number if find the break the loop and at the end increase the number of tries.

That's is the idea.
See code

Now result:
from the linear search if the result is -1 then the value does not exist and that means data is not found.

so, we print the number of tries to see it actually search or not if the result is not -1 then
we find the data.
print number of trials, to see how much try need to find our data


Output:

Data found on: 99998

class CircularQueueK(size: Int){
}

private val list:Array<Any> = Array(size,{ i: Int -> i })
private var head = 0
private var tail = 0

Let's implement those-

fun isFull() = (tail + 1) % list.size == head
fun isEmpty() = head == tail

Code review of isFull():
In this method, we increase of tail with one the modules with list size and if the result is same as head then it is full. For example, At first, the head is 0, so insert data and tail are increasing, assume that our list size is 5, so at the 4 index it will be filled and the tail is now 4.
Now, when this method is called then first increase tail, and modulus with the list size. Increase the tail to 5 and list size is 5, then the modulus is zero, and it is equal to the head. So it's now empty. because it's come back to the start position.

enqueue():
First, check the circular queue is full or not, If full the return.
Insert data in the list at the tail position
Insert the value in the tail as we did on the if full method

fun enqueue(value: Any){
    if (isFull()){
        return
    }

    list[tail] = value
    tail = (tail+1) % list.size
}

dequeue():
First, check the circular queue is empty or not. if empty return
Get data from the head position
assign new value of the read same as enqueue()

fun dequeue():Any{

    var a:Any = ""

    if (!isEmpty()){
        a = list[head]
        head = (head +1) % list.size
    }

    return a
}

Code analysis:

head = (head +1) % list.size

what is actually happening under the hood?
For example, assume the list size is 5 and head position is now 4.
Now if we want to access data from the list then it is the last position of the list. so we don't access next data.
This is the main problem in the queue. But in the circular queue head and tail position is circled from zero to list position.
so now our goal is to initialize head position to again start point.
If the head is 4 then with increase 1 and modules with the list size, and the result is zero.
So, it's back again.
In the circular queue, at least one position is to remain blank for this purpose.

Ok, one more extra method to go-

fun iterator() = list.withIndex()

Now time for testing
Create the main method-

fun main(args: Array<String>) {
}

Create an instance of the circular queue.

val queue = CircularQueueK(5)

enqueue():
run a while loop until the circular queue is full

var s = 0

while (!queue.isFull()){
    queue.enqueue(s)
    s++
}

Check the list:
run a for loop with the help of iterator() function that we created earlier.

for ((i,v) in queue.iterator()) {
    println("Index:$i and value:$v")
}

Output:

Index:0 and value:0
Index:1 and value:1
Index:2 and value:2
Index:3 and value:3
Index:4 and value:4

dequeue():
just call dequeue method for 3 times and print the value

println("\nGet value1:${queue.dequeue()}")
println("Get value2:${queue.dequeue()}")
println("Get value3:${queue.dequeue()}")

Output:

Get value1:0
Get value2:1
Get value3:2

now enqueue() again:

var d = 10
while (!queue.isFull()){
     queue.enqueue(d)
     d++
}

Compare this list with the previous result-
print all data from the circular queue

for ((i,v) in queue.iterator()) {
    println("Index:$i and value:$v")
}

Output:

Index:0 and value:11
Index:1 and value:12
Index:2 and value:2
Index:3 and value:3
Index:4 and value:10

Result analysis:
If you compare this output with the previous output you will see the changes.
we call dequeue() function for 3times, that means we get 3 data from the circular queue. So 3 position is empty now.
We enqueue() again, and only 3 data is inserted on the position of the array is 4, 1, 2 and now the head position is 3. so circulated.

Create an array of Int' and also create 2 variable that mentions above.

var ints = IntArray(10)
var head = 0
var tail = 0

Methods:
enqueue():
insert data in the tail position and increase the tail

fun enqueue(n: Int) {
    ints[tail] = n
    tail += 1
    println("Input:" + n)
}

dequeue():
get data from head position index from the array and increase the head

fun dequeue(): Int {
    val n = ints[head]
    head += 1
    return n
}

Empty check:
if head and tail is same then the stack is empty

val isEmpty: Boolean
        get() = head == tail

Now time for access data:
First, create the main method:

fun main(arg: Array<String>) {
}

enqueue():
just run a for loop from 0 to 10 and insert data

for (i in 0..9) {
     enqueue(i)
}

Output:

Input:0
Input:1
Input:2
Input:3
Input:4
Input:5
Input:6
Input:7
Input:8
Input:9

works fine.
dequeue()
run a while loop until the queue is empty

while (!isEmpty) {
    println("value: " + dequeue())
}

Output:

value: 0
value: 1
value: 2
value: 3
value: 4
value: 5
value: 6
value: 7
value: 8
value: 9

It's work fine.
That's is the basic queue implementation.
You can check this out on Github

Discussion about queue:
The uses of the basic queue are not huge. It has a very limited use.
Because it wastes memory.
For example, if the queue has the capacity of 100. Then at the beginning data inserted from zero, when we access data from one we can get that data from the zero position. After the head is also increased and the tail already increased. Imagine by this way at 99 position data is filled and we access data from the 99 potions. If we want to insert new data into the queue it shows you a warning, "hey! I am full, I can not take any new data". But already the previous position is empty and there is no way to insert new data in the queue. we can use the previous position. But it allocates the memory. This is obviously the waste of memory. see the picture for the more clear concept.

Queue Data structure

To fix this problem we use the circular queue

Circular Queue

In circular queue top position and the last position move around a circle. I will discuss circular queue in the next post.

Until then, stay happy and keep practicing.
Thank you for reading this post. 
Happy coding

You check Wikipedia for more.