数据结构之线性表经典题目

其他 2019-04-29 20:06:05 阅读次数: 0

1、逆置单链表


思路：
采用头插法将单链表中每一个元素都插入头结点之后即可实现逆置结束后将逆置后的单链表的最后一个元素的next指针置NULL。
 

void Reverse(List plist)
{
    Node *p = plist->next;
    plist->next = NULL;
    while (p != NULL)
    {
        Node *pNext = p->next;
        p->next = plist->next;
        plist->next = p;
        p = pNext;
    }
}


2、反转单链表



思路：
设置三个指针分别指向上一位置(prev)、当前位置(cur)、下一位置(pNext)反转结束后变为不含头结点的单链表，要重新写show函数输出
 

Node *Reverse_1(List plist)
{
    Node *ReverseHead = NULL;
    Node *prev = NULL;
    Node *cur = plist;
    while (cur != NULL)
    {
        Node *curNext =cur->next;
        if (curNext == NULL)
        {
            ReverseHead = cur;
        }
        cur->next = prev;
        prev = cur;
        cur = curNext;
    }
    return ReverseHead;
}
 
void Show_1(List plist)
{
    Node *p = plist;
    while (p->next != NULL)
    {
        printf("%d ",p->data);
        p = p->next; 
    }
    printf("\n");
}


3、合并两个有序的单链表

Node Merge_list(List La,List Lb)
{
    Node Lc;
    InitList(&Lc);
    List p1 = La->next;
    List p2 = Lb->next;
    List p3 = &Lc;
    while (p1 != NULL && p2 != NULL)
    {
        if (p1->data <= p2->data)
        {
            p3->next = p1;
            p3 = p1;
            p1 = p1->next;
        }
        else
        {
            p3->next = p2;
            p3 = p2;
            p2 = p2->next;
        }
    }
    if (p1 != NULL)
    {
        p3->next = p1;
    }
    if (p2 != NULL)
    {
        p3->next = p2;
    }
    return Lc;
}
 


 
/*
**递归：
**若链表1的头节点的值小于链表2的头节点的值，则链表1的头节点是合并后的链表的头节点
**再剩余的节点中，链表2的头节点大于链表1的头节点的值，则链表2 的头节点是剩余节点的头节点
**得到两个链表中值较小的头节点并把它链接到已经合并的链表之后，两个链表的剩余节点仍然是排序的
**因此合并步骤和之前是一样的，使用递归实现
*/

Node* Merge_list(Node *p1, Node *p2)
{
    if (p1 == NULL)
    {
        return p2;
    }
    else if(p2 == NULL)
    {
        return p1;
    }
    Node *p3 = NULL;
    if (p1->data < p2->data)
    {
        p3 = p1;
        p3->next = Merge_list(p1->next,p2);
    }
    else
    {
        p3 = p2;
        p3->next = Merge_list(p1,p2->next);
    }
    return p3;
}


4、判断单链表是否有环？环的入口点？环的长度？


/*
**思路：
**判断单链表是否有环：设置两个快慢指针，一个指向plist，
**一个指向plist的下一个元素，若两个快慢指针相遇，则单链表有环
**求环的长度：找到快慢指针的相遇点，从相遇点之后开始遍历，
**并设置计数器，当指针再次等于相遇点时，返回计数器长度即可
**环的入口点：设置两个指针p1，p2，先让p1向前走环的长度，p2
**从头开始遍历，当p1和p2相等时，即找到了环的入口节点
*/
 

void CreateLoop(List plist)   // 创建一个带环的单链表
{
    Node *p = plist;
    while (p->next != NULL)
    {
        p = p->next;
    }
    p->next = plist->next->next->next;
    }
 
Node* IsLoop(List plist)
{
    Node *pslow = plist->next;
    Node *pfast = pslow->next;
    while (pfast != NULL && pslow != NULL)
    {
        if (pfast == pslow)
        {
            return pfast;
        }
        pslow = pslow->next;
        pfast = pfast->next;
        if(pfast != NULL)
        {
            pfast = pfast->next;
        }
    }
    return NULL;
}
 
int LoopLen(List plist)
{
    Node *loop = IsLoop(plist);
    Node *p = loop;
    if (p == NULL)
    {
        return NULL;
    }
    int len = 1;
    while (p->next != loop)
    {
        len++;
        p = p->next;
    }
    return len;
}
 
Node *Loopstart(List plist)
{
    Node *p1 = plist;
    Node *p2 = plist;
    int len = LoopLen(plist);
    for (int i = 0; i < len; i++)
    {
        p1 = p1->next;
    }
    while (p1 != p2)
    {
        p1 = p1->next;
        p2 = p2->next;
    }
    return p1;
}


5、判断两个单链表是否相交？交点？


**思路：
**求第一个交点：两个指针p1 p2   先求出两个单链表的长度之差 pos ，使p1指向较长的单链表头节点，然后p1向前走pos，p2指向较短的单链表，从头开始遍历，当p1 = p2，则相交且为两个相交的单链表的第一个交点。
 

void CreateCut(List plist1,List plist2)
{
	plist1->next->next = plist2->next->next->next;
}

bool IsCut(List plist1,List plist2)
{
	int len1 = GetLength(plist1);
	int len2 = GetLength(plist2);
	Node *plong = plist1;
	Node *pshort = plist2;
	int len = len1-len2;
	if(len < 0) 
	{
		plong = plist2;
		pshort = plist1;
		len = len2-len1;
	}
	//plong肯定指向长的   pshort 
	//len > 0
	for(int i = 0;i < len;i++)
	{
		plong = plong->next;
	}
	while(plong != NULL && pshort != NULL && plong != pshort)
	{
		plong = plong->next;
		pshort = pshort->next;
	}
	if(plong == pshort && plong != NULL)
	{
		return true;
	}
	return false;
}

Node* IsCutNode(List plist1,List plist2)
{
	int len1 = GetLength(plist1);
	int len2 = GetLength(plist2);
	Node *plong = plist1;
	Node *pshort = plist2;
	int len = len1-len2;
	if(len < 0) 
	{
		plong = plist2;
		pshort = plist1;
		len = len2-len1;
	}
	//plong肯定指向长的   pshort 
	//len > 0
	for(int i = 0;i < len;i++)
	{
		plong = plong->next;
	}
	while(plong != NULL && pshort != NULL && plong != pshort)
	{
		plong = plong->next;
		pshort = pshort->next;
	}
	if(plong == pshort && plong != NULL)
	{
		return plong;
	}
	return NULL;
}


6、O(1)时间删除单链表的一个节点



**思路：
要删除节点 i，先把 i 的下一个节点 j 的内容复制到 i，然后把 i 的指针指向节点 j 的下一个节点，此时再删除j节点，其效果刚好是把节点i删除了，如果要删除的节点位于链表的尾部，要从链表的头节点开始，顺序遍历得到该节点的前序节点，并完成删除操作如果链表中只有一个节点，并要删除链表的头节点（也是尾节点），删除后，要将链表的头节点设置为NULL

 

void DeleteNode(List plist,Node *pDel)
{
	assert(plist != NULL && pDel != NULL);
	if(pDel->next != NULL)
	{
		Node *pDelNext = pDel->next;
		pDel->data = pDelNext->data;
		pDel->next = pDelNext->next;
		free(pDelNext);
	}
	else
	{
		Node *pCur = plist;
		while(pCur->next != pDel)
		{
			pCur =pCur->next;
		}
		pCur->next = NULL;
		free(pDel);
	}
}


7、最快时间内找到单链表倒数第K个节点？



思路：
设置两个指针p1和p2，p1向前走k-1步后，p1和p2同时向前遍历，当p1走向尾节点时，p所在位置即倒数第k个节点
 

Node *LastK(List plist,int k)
{
	if(k < 0 || plist == NULL)
	{
		return NULL;
	}
	Node *p1 = plist;
	Node *p2 = plist;
	while(k-1 > 0)
	{
		if(p1->next != NULL) 
		{
			p1 = p1->next;
			--k;
		}
		else
		{
			return NULL;
		}
	}
	while(p1->next != NULL)
	{
		p1 = p1->next;
		p2 = p2->next;
	}
	return p2;
}


8、最快时间内删除单链表倒数第K个节点？

void DeleteLastK(List plist,int k)
{
	if(k < 0 || plist == NULL)
	{
		return ;
	}
	Node *p1 = plist;
	Node *p2 = plist;
	while(k > 0)
	{
		if(p1->next != NULL) 
		{
			p1 = p1->next;
			--k;
		}
		else
		{
			return;
		}
	}
	while(p1->next != NULL)
	{
		p1 = p1->next;
		p2 = p2->next;
	}
	Node *pDel = p2->next;
	p2->next = pDel->next;
	free(pDel);
	pDel = NULL;
}


 9、 求两个顺序表的交集、并集和差集



 思路(交集)：
 新开辟一个顺序表存放交集，如果遍历两个顺序表，查找相同元素写入交集中，并记录长度
 

void Intersection(PSqlist sq1,PSqlist sq2,PSqlist sq3)
{
    int k = 0;
    for (int i = 0; i < sq1->length; i++)
    {
        int j = 0;
        while(j < sq2->length && sq2->elem[j] != sq1->elem[i])
        {
            j++;
        }
        if (j < sq2->length)
        {
            sq3->elem[k++] = sq2->elem[j];
        }
    }
    sq3->length = k;
}


 

 思路(并集)：
新开辟一个顺序表存放并集，由于是并集，所以结果中至少包含了一个顺序表中的所有元素，因此首先将第一个顺序表写入并集。然后遍历第二个顺序表，每拿到一个元素都遍历一遍第一个顺序表，进行比对，第一个顺序表遍历完毕， 第二个顺序表中的该元素在第一个顺序表中依然没有找到与之相等的元素，就将第二个顺序表中的该元素就写入并集

 

void Union(PSqlist sq1,PSqlist sq2,PSqlist sq4)
{
    for (int i = 0; i < sq1->length; i++)
    {
        sq4->elem[i] = sq1->elem[i];
    }
    sq4->length = sq1->length;
 
    int k = sq4->length;
    for (int i = 0; i < sq2->length; i++)
    {
        int j = 0;
        while(j < sq1->length && sq1->elem[j] != sq2->elem[i])
        {
            j++;
        }
        if (j == sq1->length)
        {
            sq4->elem[k++] = sq2->elem[i];
        }
    }
    sq4->length = k;
}


 

思路(差集)：
新开辟一个顺序表存放差集，属于A而不属于B的元素的集合称为A与B的差，则遍历第一个顺序表，每拿到一个元素都遍历一遍第二个顺序表，进行比对，第二个顺序表遍历完毕，第一个顺序表中的该元素在第二个顺序表中依然没有找到与之相等的元素，就将第一个顺序表中的该元素写入差集。
 

void Difference_Set (PSqlist sq1,PSqlist sq2,PSqlist sq5)
{
    int k = 0;
    for (int i = 0; i < sq1->length; i++)
    {
        int j = 0;
        while(j < sq2->length && sq1->elem[i] != sq2->elem[j])
        {
            j++;
        }
        if (j == sq2->length)
        {
            sq5->elem[k++] = sq1->elem[i];
        }
    }
    sq5->length = k;
}


10、求两个有序单链表的交集、并集和差集


两个有序的无头结点的链表La，Lb，求二者的交集、并集、差集，并且把结果分别存在一个新链表中返回。

 思路(交集)：
 依次遍历两个链表，比较两个链表当前元素的大小关系
 如果两个链表当前元素相等，则找到一个相交元素
如果第一个链表元素小于第二个链表元素，则第一个链表的指针后移一位
如果第一个链表元素大于第二个链表元素，则第二个链表的指针后移一位

 

BNode *Intersection(BTlist plist1,BTlist plist2)
{
    BTlist Lc;
    Lc = NULL;  // 初始化无头单链表
    BTlist p1 = plist1;
    BTlist p2 = plist2;
    BTlist p3 = Lc;
    while(p1 != NULL && p2 != NULL)
    {
        if (p1->data < p2->data)
        {
            p1 = p1->next;
        }
        else if(p1->data > p2->data)
        {
            p2 = p2->next;
        }
        else   // 使用尾插法将交集存入新链表
        {
            BNode *pGet = (BNode *)malloc(sizeof(BNode));
            pGet->data = p2->data;
            pGet->next = NULL;
 
            if (p3 == NULL)
            {
                Lc = pGet;  // 第一个交集元素节点存入Lc
                p3 = Lc;
            }
            else
            {
                while (p3->next != NULL)
                {
                    p3 = p3->next;
                }
                p3->next = pGet;
            }
 
            //Insert_tail(&Lc,p2->data);
            p1 = p1->next;
            p2 = p2->next;
        }
    }
    return Lc;
}
 


 

**    思路(并集)：
**    依次遍历两个链表，比较两个链表当前元素的大小关系
**    如果第一个链表元素小于第二个链表元素，则第一个链表当前元素存入新链表，并后移第一个链表指针
**    如果第一个链表元素大于第二个链表元素，则第二个链表当前元素存入新链表，并后移第二个链表指针
**  如果第一个链表元素等于第二个链表元素，则第一个链表当前元素存入新链表，并后移第一个和第二个链表指针
**    如果两个链表中某个还有剩余，则将剩余元素插入新链表

 

BNode *Union(BTlist plist1,BTlist plist2)
{
    BTlist Lc;
    Lc = NULL;  // 初始化无头单链表
    BTlist p1 = plist1;
    BTlist p2 = plist2;
    while(p1 != NULL && p2 != NULL)
    {
        if (p1->data < p2->data)
        {
            Insert_tail(&Lc,p1->data);
            p1 = p1->next;
        }
        else if(p1->data > p2->data)
        {
            Insert_tail(&Lc,p2->data);
            p2 = p2->next;
        }
        else
        {
            Insert_tail(&Lc,p1->data);
            p2 = p2->next;
            p1 = p1->next;
        }
    }
    while (p1 != NULL)
    {
        Insert_tail(&Lc,p1->data);
        p1 = p1->next;
    }
    while (p2 != NULL)
    {
        Insert_tail(&Lc,p2->data);
        p2 = p2->next;
    }
    return Lc;
}


 
 

**    思路(差集)：
**    依次遍历两个链表，比较两个链表当前元素的大小关系
**    如果两个链表当前元素相等，则两个链表的指针均后移一位
**    如果第一个链表元素小于第二个链表元素，则第一个链表的元素肯定是独有的，所有加入到结果链表中 
**    如果第一个链表元素大于第二个链表元素，则第二个链表的指针后移一位
             

 

BNode *Difference_Set(BTlist plist1,BTlist plist2)
{
    BTlist Lc;
    Lc = NULL;  // 初始化无头单链表
    BTlist p1 = plist1;
    BTlist p2 = plist2;
    while(p1 != NULL && p2 != NULL)
    {
        if (p1->data < p2->data)
        {
            Insert_tail(&Lc,p1->data);
            p1 = p1->next;
        }
        else if(p1->data > p2->data)
        {
            p2 = p2->next;
        }
        else
        {
            p1 = p1->next;
            p2 = p2->next;
        }
    }
    while (p1 != NULL)
    {
        Insert_tail(&Lc,p1->data);
        p1 = p1->next;
    }
    return Lc;
}


11、求两个单链表(可以无序)的交集、并集和差集

bool IsPresent(BTlist plist,int elem)
{
    BTlist p = plist;
    while(p != NULL)
    {
        if (p->data == elem)
        {
            return true;
        }
        p = p->next;
    }
    return false;
}


 
 

**    思路(交集)：
**    依次遍历第一个链表，在第二个链表中查找该元素
**  如果第二个链表中也有该元素，则将该元素插入到结果链表中。         
 

BNode *Intersection_1(BTlist plist1,BTlist plist2)
{
    BTlist Lc;
    Lc = NULL;  // 初始化无头单链表
    BTlist p1 = plist1;
    BTlist p2 = plist2;
    
    while(p1 != NULL)
    {
        if (IsPresent(p2,p1->data))
        {
            Insert_tail(&Lc,p1->data);
        }
        p1 = p1->next;
    }
    return Lc;
}
 


 

**    思路(并集)：
**    现将第一个链表全部插入结果链表中
**    然后遍历第二个链表，若第二个链表中的某元素在结果链表中不存在
**  则将该元素插入到结果链表中。         
 

BNode *Union_1(BTlist plist1,BTlist plist2)
{
    BTlist Lc;
    Lc = NULL;  // 初始化无头单链表
    BTlist p1 = plist1;
    BTlist p2 = plist2;
    
    while(p1 != NULL)
    {
        Insert_tail(&Lc,p1->data);
        p1 = p1->next;
    }
 
    while(p2 != NULL)
    {
        if(!IsPresent(Lc,p2->data))
        {
            Insert_tail(&Lc,p2->data);
        }
        p2 = p2->next;
    }
    return Lc;
}
 


 

**    思路(差集)：
**    遍历第一个链表，若该元素在第二个链表中不存在，则将该元素插入到结果链表中。         
 

BNode *Difference_Set_1(BTlist plist1,BTlist plist2)
{
    BTlist Lc;
    Lc = NULL;  // 初始化无头单链表
    BTlist p1 = plist1;
    BTlist p2 = plist2;
 
    while(p1 != NULL)
    {
        if(!IsPresent(p2,p1->data))
        {
            Insert_tail(&Lc,p1->data);
        }
        p1 = p1->next;
    }
    return Lc;

}

猜你喜欢

转载自blog.csdn.net/zhangfei5354/article/details/89395318
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
记一下去大梅沙的准备（2018-05-26）
Spring 注解 事务
基于HTTP协议的客户端缓存
阿里云rds 备份和还原
[PHP] 几个拖慢 PHP 程序/API 运行速度的点
python 代码风格------------PEP8规则
js控制json生成菜单——自制菜单（一）
将字符串: 'k:1|k1:2|k2:3|k3:4 ' ,处理成 python 字典: {'k':1, 'k1':2, ...}
微信小程序转支付宝小程序
Qt551.窗口滚动条
每日归档
更多
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022