在长度为n的（）上，删除第一个元素，其算法的时间复杂度为O(n)
 A.只有表头指针的不带表头结点的循环单链表
 B.只有表尾指针的不带表头结点的循环单链表
 C.只有表尾指针的带表头结点的循环单链表
 D.只有表头指针的带表头结点的循环单链表
 
答案：A
 
分析：
 单链表只能按单方向顺序访问节点，按题目意思，只有当A条件时，并当新元素的节点从表头插入，使得第一个元素的节点在表尾，才成立。这样表头指针顺序访问节点，访问至链表尾部时，复杂度刚好为O(n)。
 
 对于B而言，不带头节点循环链表，表尾指针，如果是头插法则第一元素就是表尾指针rear（假设表尾指针为rear）所指的节点，即当前节点，时间复杂度为O(1)。如果是正常顺序插入节点（即非头插法），由于是循环链表，表尾指针rear指向最后一个元素，rear->next即为第一个元素（因为循环链表，表尾的next是表头，且没有头节点），时间复杂度仍然是O(1)，所以B不成立。
 对于C而言，和B情况相似，多了一个表头节点，如果是头插法，则和B一样表尾指针rear所指当前元素即为第一个元素，时间复杂度为O(1)。如果是正常顺序插入节点，则比B多一个头节点，就变成rear->next->next，但时间复杂度仍然是O(1)，所以C不成立。
 对于D而言，比A多一个头节点，虽然当头插法时时间复杂度为O(n+1)，根据次数化解原则，就为O(n)，但是答案不是选D（我也不是很清楚，老师讲解时直接跳过没有解释清楚，希望大佬评论解答，感激！！！）

1、随机生成长度为n，且值在[min-max]范围内
 
function generateRandomArr(n, min, max) {
    var arr = [];
    for (var i = 0; i < n; i++) {
        var random = Math.floor(Math.random() * (max - min + 1) + min);
        arr.push(random);
    }
    return arr;
}
 
2、随机生成长度为n，且值在[0-(n-1)]范围内的无重复数据的有序数组
 
function generateOrderedNoRepeatArr(n) {
    var arr = Array.from({length:n}, (v, k) => k);
    return arr;
}
 
3、随机生成长度为n，且值在[min-max]范围内的随机不重复数组,前提是n<(max-min)
 
function generateNoRepeatdArr(n, min, max) {
    var arr = [],res = [];
    for(var i=min;i<max;i++){
        arr.push(i);
    }
    for (i=0 ; i <n; i++) {
        var index = parseInt(Math.random()*(arr.length));   
        res.push(arr[index]);
        arr.splice(index,1)  //已选用的数，从数组arr中移除， 实现去重复
    }
    return res;
}
 
4、随机生成长度为n，且值在[min-max]范围内的随机有序数组
 
/*首先生成一个无须且可能有重复数据的数组*/
function generateOrderedArr(n, min, max) {
    var arr = [];
    for (var i = 0; i < n; i++) {
        var random = Math.floor(Math.random() * (max - min + 1) + min);
        arr.push(random);
    }
    return arr;
}
/*以下为三路快排的方法，可对无序数组进行排序，达到良好的效果*/
function __quickSort3Ways(arr, l, r) {
    if (l >= r) return;
    /*partition*/
    var random = Math.floor(Math.random() * (r - l + 1) + l);
    [arr[l], arr[random]] = [arr[random], arr[l]];

    var v = arr[l];
    var lt = l;  //arr[l+1...lt]<v
    var gt = r + 1;  //arr[gt...r]>v
    var i = l + 1;  //arr[lt+1...i]==v
    while (i < gt) {
        if (arr[i] < v) {
            [arr[i], arr[lt + 1]] = [arr[lt + 1], arr[i]];
            lt++;
            i++;
        } else if (arr[i] > v) {
            [arr[i], arr[gt - 1]] = [arr[gt - 1], arr[i]];
            gt--;
        } else {  //arr[i]==v
            i++;
        }
    }
    [arr[l], arr[lt]] = [arr[lt], arr[l]];
    __quickSort3Ways(arr, l, lt - 1);
    __quickSort3Ways(arr, gt, r);
}

function quickSort3Ways(arr, n) {
    __quickSort3Ways(arr, 0, n - 1);
}
/*排好序的数组*/
quickSort3Ways(generateOrderedArr(100,1,10),100);

现有一循环队列，其队头指针为front，队尾指针为rear；循环队列长度为N。其队内有效长度为？(假设队头不存放数据)
 对于循环队列 空间长度为N 是固定的
 举个简单例子 空间 位置为 1，2，3，4，5，6， 空间长度为6
 本体中 front 不存数据
 如果front <= rear 则（rear－front）> 0 实际空间长度就是 （rear-front）举例 front ＝ 1 ，rear ＝ 4
 如果front > rear 则（rear－front）< 0 实际长度 就是 （rear＋N－front） 举例front ＝ 5 ，rear＝ 2
 为了统一两种情况 所以给出的结果为（rear－front＋N）％ N
 
如果front中也存放数据时
 则结果为
 （rear－front＋1+N）％ N

       寻找长度为n数组中出现次数超过n/2的元素。
 
     可以暴力枚举时间复杂度为O(n^2)，可以排个序然后处理时间复杂度为O(n*lon(n))，主要花在排序上。
 
     在元素较小的情况下可以哈希处理，空间复杂度为O(n)，时间复杂度也为O(n)。但是题目并未说元素较小且较少，此时此法不妥，更通用的方法是只需设置一个变量记录元素次数，首次出现为1，下一个若相同计数器+1，否则-1，注意一些小细节，下面是代码：
 
#include<iostream>
#include<ctime>
using namespace std;

const int INF=1<<30;
const int MAXN=1000;

int init(int *pArray)
{
	srand((unsigned)(clock()));
	int n=rand()%MAXN;
	int *hash=new int[n];
	for(int i=0;i<n;i++)
		pArray[i]=rand()%(10000);
	int num=0,randNum=rand()%(10000);
	memset(hash,0,n*sizeof(int));
	while(num<=(n/2+1))
	{
		int id;
		do{
		   id=rand()%n;
		}while(hash[id]);
		hash[id]=1;
		pArray[id]=randNum;
		num++;
	}
	delete []hash;
	return n;
}

int findThatNumber(int *pArray,int n)
{
	if(NULL==pArray||0==n)
		return INF;
	int num=0,result,i=0;
	while(i<n)
	{
		if(0==num)
		{
			num++;
			result=pArray[i];
		}
		else if(result==pArray[i])
			num++;
		else num--;
		i++;
	}
	return result;
}

int main()
{
	int array[MAXN]={1,3,5,7,3,6,3,3,3,3};
	int n=10;
	n=init(array);
	for(int i=0;i<n;i++)
	{
		cout<<array[i]<<"  ";
		if(i&&0==i%10)
			cout<<endl;
	}
	cout<<endl<<findThatNumber(array,n)<<endl;
	system("pause");
	return 0;
}