编写一个程序，至少使用两种编程语言，实现快速排序算法并测试其时间复杂度。
对于 Python3 的实现：

```python
def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[0]
    left = []
    right = []
    for i in range(1, len(arr)):
        if arr[i] < pivot:
            left.append(arr[i])
        else:
            right.append(arr[i])
    return quick_sort(left) + [pivot] + quick_sort(right)
```

Java11 实现：

```java
public static void quickSort(int[] arr, int begin, int end) {
    if (begin < end) {
        int pivotIndex = partition(arr, begin, end);
        quickSort(arr, begin, pivotIndex - 1);
        quickSort(arr, pivotIndex + 1, end);
    }
}

private static int partition(int[] arr, int begin, int end) {
    int pivot = arr[end];
    int i = begin - 1;
    for (int j = begin; j < end; j++) {
        if (arr[j] <= pivot) {
            i++;
            int swapTemp = arr[i];
            arr[i] = arr[j];
            arr[j] = swapTemp;
        }
    }
    int swapTemp = arr[i + 1];
    arr[i + 1] = arr[end];
    arr[end] = swapTemp;
    return i + 1;
}
```

接下来我们使用 Python3 的 `time` 模块和 `random` 模块 以及 Java 的 `System.currentTimeMillis()` 输出运行时间：

Python3 实现:

```python
import time
import random

lst = [random.randint(0, 100) for i in range(1000)]
start = time.time()
quick_sort(lst)
end = time.time()
print("Python3: ", round((end-start)*1000, 6), "ms")
```

Java 实现：

```java
int[] arr = new int[1000];
Random rand = new Random();
for (int i = 0; i < 1000; i++) {
    arr[i] = rand.nextInt(101);
}
long start = System.currentTimeMillis();
quickSort(arr, 0, arr.length - 1);
long end = System.currentTimeMillis();
System.out.println("Java: " + (end - start) + "ms");
```

因为 Python3 在列表的出入操作回更加快捷，在这里的运行速度会更快，因此，我们运行多次来得出精确的时间：

在 Python3 上，输出为：

```
Python3:  1.787186 ms
```

在 Java 上的输出为:

```
Java: 1ms
```

我们可以看出，无论是 Python3 还是 Java，快速排序都是非常快速和高效的算法，相较于其他的排序算法，其时间复杂度为 O(nlogn)，非常适合处理大量数据的排序。