Arrays Left Rotation { A baby coder's struggle with time complexities}

I am working on a Hackerrank problem where I am given an array and must rotate elements to the left n amount of times. I was able to solve the problem but I am still stuck on how to calculate the time complexity of my solution since I am traversing through the array n amount of times and initializing i at 0 until the while loop condition is false, I wanted to say O(n), but I'm leaning towards O(n^2) or I'm just way off... Can someone please help me understand the approach to calculating time complexities? I know that my space complexity is O(1) since I am not using an extra data structure. Lastly, depending on the actual time complexity is there a need to make my code more efficient? P.S. please be kind with your responses, I am an undergrad still trying to master basic Computer Science principles. If you have any good books or website suggestions specifically for learning time complexities I'd be so grateful if you'd provide a link in the comments.

Here is the question:

A left rotation operation on an array shifts each of the array's elements unit to the left. For example, if 2 left rotations are performed on the array [1,2,3,4,5], then the array would become [3,4,5,1,2].

Given an array of integers n and a number, d, perform d left rotations on the array. Return the updated array to be printed as a single line of space-separated integers.

Here is my input:

5 4
1 2 3 4 5

n = 5 d = 4

Here is my output:

5, 1, 2, 3, 4

My Solution/Code :

static int[] rotLeft(int[] a, int d) {
            
            while(d != 0)
            {
                int k = a[0]; int i = 0; 

                while(i < a.length-1)
                {
                    a[i] = a[i+1]; 
                    i++; 
                }

                a[a.length-1] = k; 
                d--; 
            }

            return a; 

    }

A left rotation performs n assignments on the array, so it's an O(n) operation.

You're performing d of those operations. Since d is unrelated to n, you could say that the general form of the time complexity is O(n*d).

If you were given any additional information about the relative sizes of d and n, you could further refine this:

• If d is much larger than n, n is negligible and you could say the time complexity of the entire operation is O(d).
• If d is much smaller than n, d is negligible and you could say the time complexity of the entire operation is O(n).
• If d is the same order of magnitude as n, you could say the time complexity of the entire operation is O(n²).