考研相关的单链表题目

结构:
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;
}