# Appreciation

/*
 * Problem :: 11497 / 통나무 건너뛰기
 *
 * Kind :: Greedy
 *
 * Insight
 * - 가능한 조합을 모두 만들어볼까?
 *   + 100000! * T => 불가능
 *
 * - 주어지는 통나무 높이의 순서가 의미있나?
 *   + No => 일단 정렬
 *
 * - 주어진 통나무 높이가 {1, 4, 5, 7, 12} 이라고 할 때 <= 높이가 증가하는 순서로 정렬
 *   + 가장 첫 통나무와 가장 마지막 통나무가 인접해 있지 않다면
 *     높이가 증가하는 순서로 정렬한 배열은 인접한 원소의 차이들을 최소로 만들어 주기때문에
 *     최소 난이도를 가지는 배열이 된다
 *     # 그런데 가장 첫 통나무와 가장 마지막 통나무가 인접한 경우에는
 *       위처럼 정렬할 경우 첫 원소와 마지막 원소의 차이로 인해
 *       최대 난이도를 가지는 배열이 된다
 *
 * - 주어진 통나무 높이들을 높이가 증가하는 순서대로 정렬한 후,
 *   각 통나무 높이들을 그 정렬된 순서에 대응하는 인덱스로 바라보자
 *   ({1, 4, 5, 7, 12} => {0, 1, 2, 3, 4})
 *   + 이상적인 배열은 각 원소가 자신의 인덱스와 1 차이 나는 원소들과 비교하도록 만들어진 배열이다
 *     # 자신의 인덱스 : 위처럼 배열을 만들 때 비교가능한 인덱스
 *               0 : 1
 *               1 : 0, 2
 *               2 : 1, 3
 *               3 : 2, 4
 *               4 : 3
 *       즉, (0,1) (1,2) (2,3), (3,4) 끼리 인접한 배열이 만들어져야 한다
 *       -> 그런데 만들 수 없다...
 *          0 옆에는 적어도 두 개의 원소가 인접해야 되는데
 *          그러면 인덱스 2 차이 나는 원소와 만날 수밖에 없다
 *       -> Greedy 하게 인접한 원소들의 인덱스 차이가 1 이 나도록 배치하면 결국 마지막에는
 *          가장 작은 원소와 가장 큰 원소가 인접하게 된다...
 *
 * - 그럼 인덱스 2 차이 이하로 나는 배열을 만들 수 없을까?
 *   + 자신의 인덱스 : 위처럼 배열을 만들 때 비교가능한 인덱스
 *             0 : 1, 2
 *             1 : 0, 2, 3
 *             2 : 0, 1, 3, 4
 *             3 : 1, 2, 4
 *             4 : 2, 3
 *     즉, (0,2), (1,3), (2,4) 끼리 인접한 배열이 만들어져야 한다
 *     참고로 (0,2) 는 (0,1) 을 포함한다 <= (0,2) 의 차이가 (0,1) 의 차이보다 크거나 같기 때문에
 *     마찬가지로 (1,3) 은 (1,2) 를, (2,4) 는 (2,3) 을 포함한다
 *     # 1 0 2 <= 일단 0을 시작으로 배열을 만들어봄
 *       -> 3을 넣을 차례인데, 두 가지의 배열이 가능함
 *          (3은 넣기 전 배열의 가장 첫 원소와 마지막 원소에 인접하게 된다)
 *          3 1 0 2 <= 3을 왼쪽에 붙임
 *          1 0 2 3 <= 3을 오른쪽에 붙임
 *       -> 이제 4를 넣을 차례인데,
 *          아랫배열의 경우 4가 1과 3에 인접하게 되어 인덱스가 3 차이나게 된다
 *          그러나 윗배열의 오른쪽에 붙이면 인덱스가 2 차이나도록 배열을 만들 수 있다
 *          그럼 다음의 배열을 최종적으로 얻을 수 있다
 *          3 1 0 2 4
 *       -> 이 배열에서는 (0,1), (0,2), (1,3), (2,4), (3,4) 의 조합이 서로 인접하다
 *          (0,1) 은 (0,2) 에 포함되고 (3,4) 는 (2,4) 에 포함되니
 *          (0,2), (1,3), (2,4) 끼리 인접한 배열이라고도 볼 수 있다
 *          즉, 인덱스 2 차이 이하로 나는 배열을 만들 수 있다
 *       -> 위와 같은 배열을 만드는 방법은
 *          0
 *          1 0
 *          1 0 2
 *          3 1 0 2
 *          3 1 0 2 4
 *          5 3 1 0 2 4
 *          5 3 1 0 2 4 6
 *          ...
 *          작은 값부터 번갈아서 앞쪽, 뒤쪽에 붙이는 것이다
 *          (또는 큰 값부터 번갈아서 앞쪽, 뒤쪽에 붙이는 것이다)
 *
 * - 인덱스 2 차이 이하로 나는 배열에서
 *   답(최소 난이도)를 구하기 위한 후보들의 조합은
 *   (0,2), (1,3), (2,4), (3,5), ..., (N-4, N-2), (N-3, N-1) 이다
 *   + 인접한 원소들의 인덱스 차이가 최대한 적게끔 배열을 만들었으므로
 *     이때 배열의 인접한 원소의 차이들의 최댓값이 최소 난이도이다
 */

# Code

//
//  BOJ
//  ver.C++
//
//  Created by GGlifer
//
//  Open Source

#include <iostream>
#include <algorithm>

using namespace std;

#define endl '\n'

// Set up : Global Variables
/* None */

// Set up : Functions Declaration
/* None */


int main()
{
    // Set up : I/O
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    // Set up : Input
    int T; cin >> T;

    while (T--) {
        int N; cin >> N;
        int L[N];
        for (int i=0; i<N; i++) {
            cin >> L[i];
        }

        // Process
        sort(L, L+N); /* 통나무 높이가 증가하는 순으로 정렬 */
        int ans = -1;
        /* 최소 난이도를 구하려면
         * -> 정렬된 순서 기준 인접한 원소의 인덱스 차이가 최대한 작아야함
         * -> 인접한 원소들 간의 인덱스가 1 차이나도록 배열을 만드는 것은 불가능
         * -> 인접한 원소들 간의 인덱스가 2 차이나도록 배열을 만드는 것은 가능
         * -> 인접하 원소들 간의 인덱스가 3 이하로 차이나도록 배열을 만드는 것은 가능할 것 같으나,
         *    인접한 원소들 간의 최소 인덱스 차이가 2 이상이므로 고려치 않아도 됨
         *    => 이는, 인덱스 2 차이나는 원소들의 높이 차의 최대가 최소 난이도임을 보장함 */
        for (int i=0; i<N-2; i++) {
            ans = max(ans, abs(L[i]-L[i+2]));
        }

        // Control : Output
        cout << ans << endl;
    }
}

// Helper Functions
/* None */