时间复杂度是衡量算法执行时间随输入规模增长而变化的数量级，通常用 O(n) 表示，其中 n 表示输入规模。常见的时间复杂度有以下几个代表：

1. 常数时间复杂度 O(1)：无论输入规模是多少，算法的执行时间都保持不变。

例如，下面的代码实现了一个数组中查找某个元素的算法，时间复杂度为 O(1)：

java

public static int find(int[] arr, int target) {
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == target) {
            return i;
        }
    }
    return -1;
}

2. 线性时间复杂度 O(n)：随着输入规模 n 的增大，算法的执行时间也会线性增长。

例如，下面的代码实现了一个数组中查找最大元素的算法，时间复杂度为 O(n)：

java

public static int findMax(int[] arr) {
    int max = arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    return max;
}

3. 对数时间复杂度 O(log n)：随着输入规模 n 的增大，算法的执行时间会逐渐减少。

例如，下面的代码实现了一个二分查找算法，时间复杂度为 O(log n)：

java

public static int binarySearch(int[] arr, int target) {
    int low = 0;
    int high = arr.length - 1;
    while (low <= high) {
        int mid = (low + high) / 2;
        if (arr[mid] == target) {
            return mid;
        } else if (arr[mid] < target) {
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }
    return -1;
}

4. 平方时间复杂度 O(n^2)：随着输入规模 n 的增大，算法的执行时间会呈平方级增长。

例如，下面的代码实现了一个冒泡排序算法，时间复杂度为 O(n^2)：

java

public static void bubbleSort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}