本题目要求读入n个整数，然后对他们进行排序。接着输入num组数（a,b,c），其中a为需查询的数，b和c为查询的区间下标。要求运用二分查找查询a的下标并输出。如果查询失败，则输出-1.

### 回答1：
首先，我们需要读入n个整数并进行排序。可以使用任何一种排序算法，如冒泡排序、快速排序等。

接着，我们需要输入num组数（a,b,c），其中a为需查询的数，b和c为查询的区间下标。这里需要注意，查询的区间下标是从开始的。

然后，我们可以运用二分查找算法查询a的下标。二分查找算法的基本思想是将有序数组分成两部分，取中间值与目标值进行比较，如果中间值等于目标值，则返回中间值的下标；如果中间值大于目标值，则在左半部分继续查找；如果中间值小于目标值，则在右半部分继续查找。重复以上步骤，直到找到目标值或者查找区间为空。

最后，如果查询失败，则输出-1。

### 回答2：
本题要求将给定n个整数进行排序，并进行多次查询。对于排序，常见的方法有冒泡排序、选择排序、插入排序、归并排序、快速排序等。这里我们可以选择快速排序算法，它的时间复杂度为O(nlogn)。

对于查询，要利用快速排序后的有序数组，采用二分查找的方法查询给定的数值a是否存在。二分查找也称折半查找，每次将查询范围缩小一半，时间复杂度为O(logn)。

具体做法如下：

1. 读入n个整数，存入数组中。
2. 对数组进行快速排序。这里可以自己实现快速排序算法，也可以调用STL库中的快速排序函数sort。
3. 输入num组查询数据。对于每组数据，进行如下操作：
a) 设定查询范围，即数组下标区间[b,c]，并计算出它的中间位置mid。
b) 比较a与数组中下标为mid的元素的大小关系，若a等于该元素，返回mid；若a小于该元素，将查询范围缩小到[b,mid-1]，否则缩小到[mid+1,c]。
c) 重复步骤b，直到查询范围为空或者查找到a为止。
d) 如果查找到a，输出其下标mid；否则输出-1。

具体代码如下（使用STL库函数sort和二分查找函数lower_bound）：

#include <iostream>
#include <algorithm>

using namespace std;

int main() {
    int n;
    cin >> n;
    int a[n];
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }
    sort(a, a + n); //排序
    int num;
    cin >> num;
    while (num--) {
        int target, left, right;
        cin >> target >> left >> right;
        //二分查找，返回下标
        int index = lower_bound(a + left, a + right + 1, target) - a;
        if (index < n && a[index] == target) {
            cout << index << endl;
        } else {
            cout << -1 << endl;
        }
    }
    return 0;
}

### 回答3：
本题需要实现两个功能：排序和二分查找。

首先，对于排序，有多种算法可以选择，如冒泡排序、插入排序、选择排序、快速排序等。在本题中，我们可以选择快速排序算法，其时间复杂度为O(nlogn)，空间复杂度为O(logn)。

其次，对于二分查找，我们可以采用递归或循环方式实现。在递归方式中，我们首先判断查找范围是否合法，然后计算中间值并与目标值比较，若相等，则返回中间值的下标；若中间值大于目标值，则在左半部分递归查找；否则，在右半部分递归查找。在循环方式中，我们则采用二分查找的经典写法，即不断更新查找范围，直到查找范围为空或找到目标值。

综上所述，我们可以设计以下伪代码实现本题：

1. 读入n个整数并进行排序，得到有序数组arr
2. 读入num组查询数据
3. 对于每组查询数据(a,b,c)：
1) 若b<0或c>=n或b>c，则输出-1并继续下一组查询
2) 采用递归或循环方式实现二分查找，返回结果并输出

其中，快速排序的实现方式如下：

void quicksort(int arr[], int l, int r) {
if (l >= r) return;
int i = l, j = r, p = arr[(l+r)/2];
while (i <= j) {
while (arr[i] < p) i++;
while (arr[j] > p) j--;
if (i <= j) {
swap(arr[i], arr[j]);
i++; j--;
}
}
quicksort(arr, l, j);
quicksort(arr, i, r);
}

递归方式的二分查找实现方式如下：

int binary_search(int arr[], int l, int r, int target) {
if (l > r) return -1;
int mid = (l + r) / 2;
if (arr[mid] == target) return mid;
else if (arr[mid] > target) return binary_search(arr, l, mid-1, target);
else return binary_search(arr, mid+1, r, target);
}

循环方式的二分查找实现方式如下：

int binary_search(int arr[], int l, int r, int target) {
while (l <= r) {
int mid = (l + r) / 2;
if (arr[mid] == target) return mid;
else if (arr[mid] > target) r = mid - 1;
else l = mid + 1;
}
return -1;
}

最终，我们可以得到完整代码如下：