PTA函数题相关接口(未完)

int LocateElem(SqList L,ElemType e)
{
    for(int i = 0;i<L.length;i++)
    {
        if(L.elem[i]==-1)return 0;
        if(e == L.elem[i])return i+1;
    }
    return 0;
}

顺序表的插入

本题要求实现一个函数，在顺序表的第i个位置插入一个新的数据元素e，插入成功后顺序表的长度加1，函数返回值为1；插入失败函数返回值为0；

int ListInsert(SqList &L,int i,ElemType e)
{
    if(L.length == MAXSIZE)
    {
        return 0;
    }
    if(i<1||i>L.length+1)
    {
        return 0;
    }
    int b  = L.length;
    for(;b>i-1;b--)
    {
        L.elem[b] = L.elem[b-1];
    }
    L.elem[b] = e;
    L.length = L.length+1;
    
    return 1;
}

顺序表的删除

本题要求实现一个函数，要求将顺序表的第i个元素删掉，成功删除返回1，否则返回0；

int ListDelete(SqList &L,int i)
{
    if(i>0&&i<=L.length)
    {
        int k = i-1;
        for(i=k;i<L.length-1;i++)
        {
            L.elem[i] = L.elem[i+1];
        }
        L.length = L.length - 1;
        return 1;
    }
    else
        return 0;
}

顺序表有序插入

本题要求实现一个函数，要求将指定元素插入到有序表的合适位置，使得插入后仍然保持有序，若插入失败返回0；插入成功则返回1，并且顺序表的长度加1.

int SqInsert(SqList &L,ElemType e)
{
    int i;
    if(L.length==MAXSIZE)return 0;
    for(i=L.length-1;i>=0;i--)
    {
        if(L.elem[i]>e)L.elem[i+1] = L.elem[i];
        else break;
    }
    L.elem[i+1] = e;
    L.length++;
    return 1;
}

2.链表

带头结点单链表的查询

H为单链表的头指针，key为待查找的值（第一个为参考，第二个为准）

int Get_LinkList(LinkList H,ElemType key)
{
    LinkList t;
    int i;
    t = H->next;
    for(i=1;t!=NULL;i++)
    {
        if(t->data == key)
        {
            return i;
        }
        t = t->next;
    }
    if(t == NULL)
    return 0;
}

ElementType FindKth( List L, int K )
{
    int count = 1;
    PtrToLNode p = L;
    
    while(L!=NULL&&count<K)
    {
        p = p->Next;
        count++;
    }
    if(p&&count==K)
        return p->Data;
    else
        return ERROR;
}

带头结点单链表的插入

H为单链表的头指针，i为插入位置，e为新插入的值（第一个为参考，第二个为准）

Status ListInsert(LinkList &H,int i,ElemType e)
{
   LinkList t,pi,n;
   pi = (LinkList)malloc(sizeof(LNode));
   int j = 1;
   t = H->next;
   n = H;
   for(j = 1;j<=i;j++)
   {
       if(j==i)
       {
           pi->data = e;
           pi->next = t;
           n ->next = pi;
       }
       n = t;
       t = t->next;
   }
    return OK;
}

本题要求实现带头结点的单链表插入操作，插入成功返回1，否则返回0。

int insert_link ( LinkList L,int i,ElemType e)
{
    if(i<=0)return 0;
    
    LinkList p = L;
    LinkList pre = p;
    int count = 1;
    
    if(!L)return 0;
    
    while(p)
    {
        pre = p;
        p = p->next;
        if(count == i)break;
        if(p==NULL)break;
        count++;
    }
    
    if(count!=i)return 0;//插入位置越界检查
    
    LinkList pr = malloc(sizeof(struct LNode));
    pr->data = e;
    
    pre->next = pr;
    pr->next = p;
    return 1;
    
}

带头结点单链表的删除

H为单链表的头指针，i为删除位置（第一个为参考，第二个为准）

Status ListDelete(LinkList &H,int i)
{
    LinkList t,n;
    t = H->next;
    n = H;
    int j;
    for(j=1;j<=i;j++)
    {
        if(j==i)
        {
            n->next = t->next;
        }
        n = t;
        t = t->next;
        
    }
}

本题要求实现删除单链表的第i个元素结点，删除成功返回1，否则返回0。

int delete_link ( LinkList L,int i)
{
   if(i<=0)return 0;
   LinkList p = L;
   int count = 1;
    
    while(p&&count<i)
    {
        p = p->next;
        count++;
    }
    if(p->next == NULL)return 0;
    LNode*pre = p->next;
    p->next = pre->next;
    free(pre);
    return 1;
}

两个有序链表序列的合并

本题要求实现一个函数，将两个链表表示的递增整数序列合并为一个非递减的整数序列。


 
List Merge( List L1, List L2 ) {
	List pa, pb, pc, L;
	L = (List)malloc(sizeof(struct Node));    //申请一个头结点L.
	pa = L1->Next;    //指针pa指向L1的第一个结点。
	pb = L2->Next;    //指针pb指向L2的第一个结点。
	pc = L;    //指针pc指向上面创立的头结点L.
	while ( pa && pb ) {    //当L1和L2链表都没有遍历完成的时候。
		if ( pa->Data <= pb->Data ) {    //若pa结点的数据小。
			pc->Next = pa;    //把pa串入L中。
			pc = pa;    //pc移向当前最后一个结点pa，这也是尾插。
			pa = pa->Next;    //在L1链表中，更新pa位置。
		} else {
			pc->Next = pb;
			pc = pb;
			pb = pb->Next;
		}
	}
    /*如果L1未遍历完，将L1全部串入L，如果L2未遍历完，将L2全部串入L*/
	pc->Next = pa ? pa : pb;
	L1->Next = NULL;
	L2->Next = NULL;
	
	return L;
}

3.栈和队列

顺序栈的基本运算

编写函数实现顺序栈的初始化、出栈、入栈运算。

 Status iniStack(Sqstack&S)
 {
     S.base = (SElemType*)malloc(100*sizeof(SElemType));
     S.top = S.base;
     S.stacksize = 100;
 }
Status push(Sqstack&S,SElemType x)
{
    if(S.top - S.base >= S.stacksize)
        return 0;
    *S.top = x;
    S.top++;
    return 1;
}
Status pop(Sqstack&S,SElemType &e)
{
    if(S.base == S.top)
        return 0;
    S.top--;
    e =*S.top;
    return 1;
}

循环队列出队入队(详细见博客http://t.csdn.cn/S8ep1)

用一个数组表示循环队列，请编写算法实现循环队列的初始化、入队和出队操作。

void InitQ(SqQueue &Q,int N)
{
    Q.base = (int*)malloc(N*sizeof(int));
    Q.front = 0;
    Q.rear = Q.front;
}

void AddQ(SqQueue &Q,int x)
{
    if((Q.rear+1)%N==Q.front)
    {
        printf("Queue Full\n");
    }
    else{
        Q.base[Q.rear]=x;
        Q.rear=(Q.rear+1)%N;
    }
}
Status DeleteQ(SqQueue &Q,int &e)
{
    if(Q.rear == Q.front)
    {
        printf("Queue Empty\n");
        return 0;
    }
    e = Q.base[Q.front];
    Q.front = (Q.front+1)%N;
    return 1;
}

循环队列入队出队操作（详细见博客http://t.csdn.cn/mkfmL）

Status InitQueue(SqQueue& Q) 
{

	Q.base = (QElemType*)malloc(MAXQSIZE * sizeof(QElemType));
	if (!Q.base)
		exit(OVERFLOW);
	Q.front = Q.rear = 0;
	return OK;
}


Status EnQueue(SqQueue& Q, QElemType e) {
	if ((Q.rear + 1) % MAXQSIZE == Q.front)
		return ERROR;
	Q.base[Q.rear] = e;
	Q.rear = (Q.rear + 1) % MAXQSIZE;
	return OK;
}


Status DeQueue(SqQueue& Q, QElemType& e) 
{
	if (Q.front == Q.rear)
		return ERROR;
	e = Q.base[Q.front];
	Q.front = (Q.front + 1) % MAXQSIZE;
	return OK;
}

另类堆栈

在栈的顺序存储实现中，另有一种方法是将Top定义为栈顶的上一个位置。请编写程序实现这种定义下堆栈的入栈、出栈操作。如何判断堆栈为空或者满？

注意：如果堆栈已满，Push函数必须输出“Stack Full”并且返回false；如果队列是空的，则Pop函数必须输出“Stack Emp

最低0.47元/天解锁文章

ScarboroughFair#

关注

13
点赞
踩
85

收藏

觉得还不错? 一键收藏
0
评论
PTA函数题相关接口(未完)

目录1.顺序表顺序表的查找顺序表的插入顺序表的删除顺序表有序插入2.链表带头结点单链表的查询带头结点单链表的插入带头结点单链表的删除两个有序链表序列的合并3.栈和队列顺序栈的基本运算循环队列出队入队(详细见博客http://t.csdn.cn/S8ep1)循环队列入队出队操作（详细见博客http://t.csdn.cn/mkfmL）另类堆栈十进制转二进制（顺序栈设计和应用）进制转换排队叫号系统5.二叉树求叶子结点个数后缀表达式哈夫曼编码二叉树的遍历统计二叉树结点个数求二叉树的深度6.图图的创建（邻接
复制链接

扫一扫