int vis[1000]是什么意思？

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#pragma warning(disable:4996)

int vis[1000];

typedef struct ltbl
{
struct ltbl* pPre;/* 指向链表中前一个元素的指针 */
struct ltbl* pNxt;/* 指向链表中后一个元素的指针 */
int nKey;/* KEY VALUE*/
unsigned char ucDummy[32];/*备用*/
}LTBL;

typedef struct mng
{
int nNodeCnt;/*链表的长度*/
LTBL* pHead;/*指向链表头的指针*/
}MNG;

int TBLCreate(MNG* pMng, int nCnt)
{
memset(vis, 0, sizeof(vis)); //防止随机值重复
if (!pMng)return -1;
pMng->nNodeCnt = nCnt;
LTBL* p = (LTBL*)malloc(sizeof(LTBL)); //创建头节点
if (!p)return -1;
int x = 0;
x = rand() % 1000;
vis[x] = 1;
p->nKey = x;
p->pPre = NULL;
p->pNxt = NULL;
pMng->pHead = p;

for (int i = 1; i < nCnt; ++i) {
LTBL* temp = (LTBL*)malloc(sizeof(LTBL));
if (!temp)return -1;
while (1) { //随机值防止重复
x = rand() % 1000;
if (!vis[x]) {
vis[x] = 1;
break;
}
}
temp->nKey = x;
temp->pNxt = NULL;
temp->pPre = p;//新节点前驱指向当前节点
p->pNxt = temp;//当前节点的后继为新节点
p = p->pNxt;//当前节点后移
}
return 0;
}

void TBLFree(MNG* pMng) {
pMng->nNodeCnt = 0;
LTBL* pre = pMng->pHead;
while (pre) {
LTBL* p = pre->pNxt;
free(pre);
pre = p;
}
pMng->pHead = NULL;
}

LTBL* TBLSearch(const MNG* pMng, int nKey) {
LTBL* p = pMng->pHead;
while (p) {
if (p->nKey == nKey)return p;
p = p->pNxt;
}
return p;
}

int TBLInsert(MNG* pMng, LTBL* pNode) {
LTBL* p = pMng->pHead;
LTBL* pre = NULL;
while (p) {
if (p->nKey == pNode->nKey)return -1;
else if (p->nKey < pNode->nKey) {
pre = p;
p = p->pNxt;
}
else { //按升序排
pNode->pPre = pre;
if (pre)pre->pNxt = pNode;//插入节点不会变为头节点
else pMng->pHead = pNode; //pre为NULL则插入节点变为头节点
pNode->pNxt = p;
if(p)p->pPre = pNode;//插入节点不是尾结点
pMng->nNodeCnt++;
return 0;
}
}
}

int TBLDelete(MNG* pMng, int nKey) {
LTBL* p = TBLSearch(pMng, nKey); //找到删除节点
if (!p)return -1;
LTBL* pre = p->pPre;
LTBL* next = p->pNxt;
if (pre)pre->pNxt = next; //删除节点不是头节点
else pMng->pHead = p->pNxt; //删除节点为头节点
if (next)next->pPre = pre; //删除节点不是尾节点
free(p);
pMng->nNodeCnt--;
return 0;

}

void TBLSort(MNG* pMng, int nFlg) {
LTBL* p = NULL;
LTBL* q = NULL;
for (p = pMng->pHead; p!=NULL && p->pNxt != NULL; p = p->pNxt) { //冒泡排序
for (q = p->pNxt; q != NULL; q = q->pNxt) {
if ((p->nKey < q->nKey) == nFlg) {
int temp = p->nKey;
p->nKey = q->nKey;
q->nKey = temp;
}
}
}
}

void show(MNG* pMng) {
LTBL* p = pMng->pHead;
while (p) {
printf("%d ", p->nKey);
p = p->pNxt;
}
printf("\n");
}

int main() {
MNG mng;
mng.pHead = NULL;
while (1) {
srand(time(NULL));
printf("1.新建链表\n");
printf("2.插入节点\n");
printf("3.删除节点\n");
printf("4.查找节点\n");
printf("5.排序链表\n");
int choice;
scanf("%d", &choice);
if (choice == 6)break;
switch (choice)
{
case 1: {
printf("请输入想要创建多少节点的链表：\n");
int cnt;
scanf("%d", &cnt);
TBLFree(&mng);
if (TBLCreate(&mng, cnt) == -1) {
printf("创建失败，请重试！\n");
}
else {
printf("创建后的链表为：\n");
show(&mng);
}
break;
}
case 2: {
printf("请输入想要插入节点的值：\n");
LTBL* p = (LTBL*)malloc(sizeof(LTBL));
p->pNxt = NULL;
p->pPre = NULL;
scanf("%d", &p->nKey);
if (TBLInsert(&mng, p) == -1) {
printf("插入失败，请重试！\n");
}
else {
printf("插入后的链表为：\n");
show(&mng);
}
break;
}
case 3: {
printf("请输入想要删除节点的值：\n");
int key;
scanf("%d", &key);
if (TBLDelete(&mng, key) == -1) {
printf("删除失败，请重试！\n");
}
else {
printf("删除后的链表为：\n");
show(&mng);
}
break;
}
case 4: {
printf("请输入想要查找节点的值：\n");
int key;
scanf("%d", &key);
if (!TBLSearch(&mng, key)) {
printf("没有该节点\n");
}
else {
printf("该节点存在\n");
}
break;
}
case 5: {
printf("请输入想要排序的方式(0:升序，1:降序)：\n");
int flag;
scanf("%d", &flag);
TBLSort(&mng, flag);
printf("排序后的链表为：\n");
show(&mng);
break;
}
default:
break;
}
}
return 0;
}