GDUT数据结构anyview题目+答案,代码搓大牛们勿喷,大家随意就好!
/**********
【题目】试写一算法,实现链栈的判空操作。
链栈的类型定义为:
typedef struct LSNode {
ElemType data; // 数据域
struct LSNode *next; // 指针域
} LSNode, *LStack; // 结点和链栈类型
***********/
Status StackEmpty_L(LStack S)
/* 对链栈S判空。若S是空栈,则返回TRUE;否则返回FALSE */
{
if(S == NULL) return TRUE;
else return FALSE;
}
/**********
【题目】试写一算法,实现链栈的取栈顶元素操作。
链栈的类型定义为:
typedef struct LSNode {
ElemType data; // 数据域
struct LSNode *next; // 指针域
} LSNode, *LStack; // 结点和链栈类型
***********/
Status GetTop_L(LStack S, ElemType &e)
/* 取链栈S的栈顶元素到e,并返回OK; */
/* 若S是空栈,则失败,返回ERROR。 */
{
if(S == NULL) return ERROR;
else
{
e = S->data;
return OK;
}
}
/**********
【题目】试写一算法,实现链队列的判空操作。
链队列的类型定义为:
typedef struct LQNode {
ElemType data;
struct LQNode *next;
} LQNode, *QueuePtr; // 结点和结点指针类型
typedef struct {
QueuePtr front; // 队头指针
QueuePtr rear; // 队尾指针
} LQueue; // 链队列类型
***********/
Status QueueEmpty_LQ(LQueue Q)
/* 判定链队列Q是否为空队列。 */
/* 若Q是空队列,则返回TRUE,否则FALSE。*/
{
if(Q.front==NULL && Q.rear==NULL) return TRUE;
else return FALSE;
}
/**********
【题目】试写一算法,实现链队列的求队列长度操作。
链队列的类型定义为:
typedef struct LQNode {
ElemType data;
struct LQNode *next;
} LQNode, *QueuePtr; // 结点和结点指针类型
typedef struct {
QueuePtr front; // 队头指针
QueuePtr rear; // 队尾指针
} LQueue; // 链队列类型
***********/
int QueueLength_LQ(LQueue Q)
/* 求链队列Q的长度并返回其值 */
{
int count = 0;
LQNode* p;
p = Q.front;
if(Q.front == NULL && Q.rear == NULL) return count;
while(p != NULL)
{
count++;
p = p->next;
}
return count;
}
/**********
【题目】假设以带头结点的循环链表表示队列,并且
只设一个指针指向队尾元素结点(注意不设头指针),
试编写相应的队列初始化、入队列和出队列的算法。
带头结点循环链队列CLQueue的类型定义为:
typedef struct LQNode {
ElemType data;
struct LQNode *next;
} LQNode, *CLQueue;
**********/
Status InitCLQueue(CLQueue &rear) // 初始化空队列
{
LQNode *head;
head = (LQNode*)malloc(sizeof(LQNode));
rear = head;
head->next = rear;
return OK;
}
Status EnCLQueue(CLQueue &rear, ElemType x) // 入队
{
LQNode *head = rear->next;
LQNode *p;
p = (LQNode*)malloc(sizeof(LQNode));
p->data = x;
p->next = head;
rear->next = p;
rear = p;
return OK;
}
Status DeCLQueue(CLQueue &rear, ElemType &x) // 出队
{
LQNode *p;
LQNode *head;
head = rear->next;
if(rear == NULL || head->next == rear->next) return ERROR;
p = head->next;
x = p->data;
head->next = p->next;
free(p);
return OK;
}
/**********
【题目】试写一算法,实现带头结点单链表的判空操作。
单链表的类型定义为:
typedef struct LNode {
ElemType data;
struct LNode *next;
} LNode, *LinkList; // 结点和结点指针类型
***********/
Status ListEmpty_L(LinkList L)
/* 判定带头结点单链表L是否为空链表。 */
/* 若L是空链表,则返回TRUE,否则FALSE。*/
{
if(L == NULL || L->next == NULL) return TRUE;
else return FALSE;
}
/**********
【题目】试写一算法,实现带头结点单链表的销毁操作。
单链表的类型定义为:
typedef struct LNode {
ElemType data;
struct LNode *next;
} LNode, *LinkList; // 结点和结点指针类型
***********/
Status DestroyList_L(LinkList &L)
/* 销毁带头结点单链表L,并返回OK。*/
{
LNode *q;
if(!L) return OK;
while(L != NULL)
{
q = L;
L = L->next;
free(q);
}
return OK;
}
/**********
【题目】试写一算法,实现带头结点单链表的清空操作。
单链表的类型定义为:
typedef struct LNode {
ElemType data;
struct LNode *next;
} LNode, *LinkList; // 结点和结点指针类型
***********/
Status ClearList_L(LinkList &L)
/* 将带头结点单链表L置为空表,并返回OK。*/
/* 若L不是带头结点单链表,则返回ERROR。 */
{
if(L == NULL) return ERROR;
else
{
L->next = NULL;
return OK;
}
}
/**********
【题目】试写一算法,实现带头结点单链表的求表长度操作。
单链表的类型定义为:
typedef struct LNode {
ElemType data;
struct LNode *next;
} LNode, *LinkList; // 结点和结点指针类型
***********/
int ListLength_L(LinkList L)
/* 求带头结点单链表L的长度,并返回长度值。*/
/* 若L不是带头结点单链表,则返回-1。 */
{
int count = 0;
LNode *p = L;
if(L == NULL) return -1;
while(p->next != NULL)
{
count++;
p = p->next;
}
return count;
}
/**********
【题目】试写一算法,在带头结点单链表L插入第i元素e。
带头结点单链表的类型定义为:
typedef struct LNode {
ElemType data;
struct LNode *next;
} LNode, *LinkList;
**********/
Status Insert_L(LinkList L, int i, ElemType e)
/* 在带头结点单链表L插入第i元素e,并返回OK。*/
/* 若参数不合理,则返回ERROR。 */
{
int count = 0;
LNode* p ;
LNode* q;
q = (LNode*)malloc(sizeof(LNode));
p = L;
while(p!=NULL && count<i-1)
{
p = p->next;
count++;
}
if(!p || count>i-1) return ERROR;
q->data = e;
q->next = p->next;
p->next = q;
return OK;
}
/**********
【题目】试写一算法,在带头结点单链表删除第i元素到e。
带头结点单链表的类型定义为:
typedef struct LNode {
ElemType data;
struct LNode *next;
} LNode, *LinkList;
**********/
Status Delete_L(LinkList L, int i, ElemType &e)
/* 在带头结点单链表L删除第i元素到e,并返回OK。*/
/* 若参数不合理,则返回ERROR。 */
{
LNode* p = L;
LNode* q;
int count = 0;
while(p->next != NULL && count<i-1)
{
p = p->next;
count++;
}
if(p->next == NULL || count>=i) return ERROR;
e = p->next->data;
q = p->next;
p->next = q->next;
free(q);
return OK;
}
/**********
【题目】试写一算法,在带头结点单链表的第i元素起的
所有元素从链表移除,并构成一个带头结点的新链表。
带头结点单链表的类型定义为:
typedef struct LNode {
ElemType data;
struct LNode *next;
} LNode, *LinkList;
**********/
Status Split_L(LinkList L, LinkList &Li, int i)
/* 在带头结点单链表L的第i元素起的所有元素 */
/* 移除,并构成带头结点链表Li,返回OK。 */
/* 若参数不合理,则Li为NULL,返回ERROR。 */
{
int count = 0;
LNode* head;
LNode* p;
head = (LNode*)malloc(sizeof(LNode));
p = L;
while(p->next && count<i-1)
{
p = p->next;
count++;
}
if(!(p->next)|| count>=i)
{
Li = NULL;
return ERROR;
}
head->next = p->next;
p->next = NULL;
Li = head;
return OK;
}
/**********
【题目】试写一算法,在带头结点单链表删除第i元素
起的所有元素。
带头结点单链表的类型定义为:
typedef struct LNode {
ElemType data;
struct LNode *next;
} LNode, *LinkList;
**********/
Status Cut_L(LinkList L, int i)
/* 在带头结点单链表L删除第i元素起的所有元素,并返回OK。*/
/* 若参数不合理,则返回ERROR。 */
{
int count = 0;
LNode* p;
//head = (LNode*)malloc(sizeof(LNode));
p = L;
while(p->next && count<i-1)
{
p = p->next;
count++;
}
if(!(p->next)|| count>=i)
{
return ERROR;
}
p->next = NULL;
return OK;
}
/**********
【题目】试写一算法,删除带头结点单链表中所有值
为x的元素,并释放被删结点空间。
单链表类型定义如下:
typedef struct LNode {
ElemType data;
struct LNode *next;
} LNode, *LinkList;
**********/
Status DeleteX_L(LinkList L, ElemType x)
/* 删除带头结点单链表L中所有值为x的元素, */
/* 并释放被删结点空间,返回实际删除的元素个数。*/
{
LNode* p;
LNode* q;
p = L;
int count = 0;
if(!L) return 0;
while(p->next)
{
if(p->next->data == x)
{
q = p->next;
p->next = q->next;
free(q);
count++;
}
else p = p->next;
}
return count;
}
/**********
【题目】试写一算法,删除带头结点单链表中所有值
小于x的元素,并释放被删结点空间。
单链表类型定义如下:
typedef struct LNode {
ElemType data;
struct LNode *next;
} LNode, *LinkList;
**********/
Status DeleteSome_L(LinkList L, ElemType x)
/* 删除带头结点单链表L中所有值小于x的元素, */
/* 并释放被删结点空间,返回实际删除的元素个数。*/
{
LNode* p;
LNode* q;
p = L;
int count = 0;
if(!L) return 0;
while(p->next)
{
if(p->next->data < x)
{
q = p->next;
p->next = q->next;
free(q);
count++;
}
else p = p->next;
}
return count;
}
/**********
【题目】试以顺序表L的L.rcd[L.length+1]作为监视哨,
改写教材5.2节中给出的升序直接插入排序算法。
顺序表的类型RcdSqList定义如下:
typedef struct {
KeyType key;
...
} RcdType;
typedef struct {
RcdType rcd[MAXSIZE+1]; // r[0]闲置
int length;
} RcdSqList;
**********/
int a[100];
int cmp (int a,int b)
{
return a<b;
}
void swap(int x,int y)
{
int t=a[x];
a[x]=a[y];
a[y]=t;
}
void InsertSort(RcdSqList &L)
{
int i,j;
int cnt=0;
for(i=1; i<=L.length; i++)
{
a[i]=L.rcd[i].key;
}
for(i=1; i<L.length; i++)
{
for(j=i+1; j<=L.length; j++)
{
if(a[i]>a[j])
{
swap(i,j);
}
}
}
for(i=1; i<=L.length; i++)
{
L.rcd[i].key=a[i];
}
}
/**********
【题目】如下所述,改写教材1.5节的冒泡排序算法:
将算法中用以起控制作用的布尔变量change改为一个整型
变量,指示每一趟排序中进行交换的最后一个记录的位置,
并以它作为下一趟起泡排序循环终止的控制值。
顺序表的类型RcdSqList定义如下:
typedef struct {
KeyType key;
...
} RcdType;
typedef struct {
RcdType rcd[MAXSIZE+1]; // r[0]闲置
int length;
} RcdSqList;
**********/
void BubbleSort(RcdSqList &L)
/* 元素比较和交换必须调用如下定义的比较函数和交换函数:*/
/* Status LT(RedType a, RedType b); 比较:"<" */
/* Status GT(RedType a, RedType b); 比较:">" */
/* void Swap(RedType &a, RedType &b); 交换 */
{
int i,j,final = L.length+1,k;
for(i = 1; i < L.length; i++)
{
for(j = 2,k = 0; j < final; j++)
{
if(GT(L.rcd[j-1],L.rcd[j]))
{
Swap(L.rcd[j-1],L.rcd[j]);
k = j;
}
}
final = k;
if(final <= 2)break;
}
}
/**********
【题目】已知记录序列L.rcd[1..L.length]中的关键
字各不相同,可按如下所述实现计数排序:另设数组
c[1..n],对每个记录a[i], 统计序列中关键字比它
小的记录个数存于c[i],则c[i]=0的记录必为关键字
最小的记录,然后依c[i]值的大小对序列中记录进行
重新排列。试编写算法实现上述排序方法。
顺序表的类型RcdSqList定义如下:
typedef struct {
KeyType key;
...
} RcdType;
typedef struct {
RcdType r[MAXSIZE+1]; // r[0]闲置
int length;
} RcdSqList;
**********/
void CountSort(RcdSqList &L)
/* 采用顺序表存储结构,在函数内自行定义计数数组c */
{
int c[MAXSIZE + 1];
int i,j,k,tempI;
RcdType temp;
for(i = 1; i <= L.length; i++)
{
for(j = 1; j<=L.le