考研相关的单链表题目

结构:
typedef int ElemType;
typedef struct LNode {
	ElemType val;
	struct LNode *next;
}*LinkedList;

//将一个没有头结点的结点数据为字符的单链表，分解成还有字母字符、数字字符和其他字符的三个带头节点的循环链表
void OneToThree(LinkedList l,LinkedList la,LinkedList ld,LinkedList lo)
{
	while(l != nullptr)
	{
		LinkedList r = l;
		l = l->next;
		if(r->val >= 'a' && r->val <= 'z' || r->val >= 'A' && r->val <= 'Z')
		{
			r->next = la->next;
			la->next = r;
		}
		else if(r->val >= 0 && r->val <= 9)
		{
			r->next = ld->next;
			ld->next = r;
		}else
		{
			r->next = lo->next;
			lo->next = r;
		}
	}
} 


//不带头结点的删除有序链表中元素相同的结点
//如 1 2 2 3 返回 1 2 3
LinkedList  DelSame_None(LinkedList head)
{
    LinkedList  pre = head;
    LinkedList  p = pre->next;
    while(p != nullptr)
    {
        if(p->val == pre->val)
        {
            LinkedList  tmp = p;
            p = p->next;
            free(tmp);
        }
        else {
            pre->next = p;
            pre = p;
            p = p->next;
        }
    }
    pre->next = p;
}



//带头结点的删除有序链表中元素相同的结点
LinkedList  DelSame(LinkedList la)
{
    LinkedList  pre = la->next;
    LinkedList  p = pre->next;
    while(p != nullptr)
    {
        if(p->val == pre->val)
        {
            LinkedList  tmp = p;
            p = p->next;
            free(tmp);
        }
        else {
            pre->next = p;
            pre = p;
            p = p->next;
        }
    }
    pre->next = p;
}


/*
设有一个由正整数组成的无序单链表，带头结点。
(1)找出最小值，并且打印该值
(2)如果该数为奇数，则将其与直接后继结点的数值交换
(3)如果该数为偶数，则将其直接后继结点删除
*/

void MinValue(LinkedList head)
{
	LinkedList p = head->next; 
        //不带头结点为 LinkedList p = head;
	LinkedList pre = p;
	while(p != nullptr)
	{
		if(p->val < pre->val)
			pre = p;
		p = p->next;
	}
	cout<<pre->val<<endl;
	if(pre->val % 2 != 0)
	{
		if(pre->next != nullptr)
		{
			int tmp = pre->val;
			pre->val = pre->next->val;
			pre->next->val = tmp;
		}
	}
	else{
		if(pre->next != nullptr)
		{
			LinkedList u = pre->next;
			pre->next = u->next;
			free(u);
		}
	}
}


//带头节点的单链表的逆置
LinkedList invertlist(LinkedList head)
{
	LinkedList p = head->next;
	head->next = nullptr;
	while(p != nullptr)
	{
		LinkedList  r = p->next;
		p->next = head->next;
		head->next = p;
		p = r;	
	}	
	return head;
} 


//不带头节点的单链表的逆置
LinkedList invertlist_None(LinkedList &head)
{
	if(head == nullptr)
		return nullptr;
	if(head->next == nullptr)
		return head;
	LinkedList p1,p2,p3;
	p1 = head;
	p2 = head->next;
	head->next = nullptr;
	p3 = p2->next;
	while(p3 != nullptr)
	{
		p2->next = p1;
		p1 = p2;
		p2 = p3;
		p3 = p2->next;
	}	
	p2->next = p1;
	head = p2;
	return head;
} 


//带头结点的循环链表,将表中的第i个结点(i大于1)到m结点(m>3)这部分倒置(1<i<m) 
LinkedList PatternInvert(LinkedList L,int i,int m )
{
	if(i < 1 || i >=m || m < 4)
	{
		cout<<"²ÎÊý´íÎó"<<endl;
		exit(0);
	}
	LinkedList p = L->next->next;
	LinkedList pre = L->next;
	int j = 1;
	while(j < i - 1)
	{
		j++;
		pre = p;
		p = p->next;
	}
	LinkedList q = p;//ÔÝ´æµÚi¸ö½áµã
	p = p->next; //pÖ¸ÏòµÚn+1¸ö½áµã
	j += 2;
	while(j <= m)
	{
		LinkedList r = p->next;
		p->next = pre->next;
		pre->next = p;
		p = r;
		j++;
	} 
	q->next = pre->next;	 	 
}

/*
判断第二项起的每个元素值是否等于其序号的平方减去其前驱的值
满足返回true 不满足返回false
*/
//不带头结点 
boolJudge_None(LinkedList la)
{
	LinkedList p = la->next;
	LinkedList pre = la;
        //带头结点写成
        //LinkedList p = la->next->next;
	//LinkedList pre = la->next;    
	int i = 2;
	while(p != nullptr)
	{
		if(p->val == i*i - pre->val)
		{
			i++;
			pre = p;
			p = p->next;
		}
		else 
			break;
	}
	if(p != nullptr)
	{
		return false;
	}
	else 
		return true;
}