链表的实现以及合并，排序，逆序，等

最新推荐文章于 2023-01-18 19:37:43 发布
原创 最新推荐文章于 2023-01-18 19:37:43 发布 · 490 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了链表的基础知识，包括链表结构、初始化、节点创建、插入操作（头插、尾插）、查找、删除操作。重点讲解了如何合并两个有序链表保持有序、逆序链表、找到链表中间节点、删除倒数第k个节点以及链表排序的方法。同时提供了测试代码和完整实现供参考。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1。链表的结构


2，链表的初始化


3，创建节点


4，尾插


5，头插


6，查找



7，头删


8，移除


9，合并两个有序链表，合并后依然有序


Plist merge(Plist head3,Plist head4)
{
	if (head3 == NULL)
		return head4;
	if (head4 == NULL)
		return head3;
	Plist p = NULL;
	Plist cur1 = head3;
	Plist cur2 = head4;
	Plist tail = NULL;
	if (cur1->data < cur2->data)
	{
		p = cur1;
		cur1 = cur1->next;
		tail = p;
	}
	else
	{
		p = cur2;
		cur2 = cur2->next;
		tail = p;
	}
	while (cur1&&cur2)
	{
		if (cur1->data< cur2->data)
		{
			tail->next=cur1;
			cur1 = cur1->next;
			tail = tail->next;
		}
		else
		{
			tail->next = cur2;
			cur2 = cur2->next;
			tail = tail->next;
		}
	}
	if (cur1)
	{
		tail->next = cur1;
		return p;
	}
	if (cur2)
	{
		tail->next=cur2;
		return p;
	}
}


10，逆制一个链表


11，查找链表的中间节点


12，删除倒数第k个节点



13，链表的排序


14，把奇数放在偶数前面

Plist jishu_front(Plist head)//把链表奇数放在偶束前面
{
	if (head == NULL)
	{
		printf("the chain is null\n");
		return NULL;
	}
	Plist tmp = NULL;
	Plist cur = head;
	Plist newHead = NULL;
	Plist oushuhead = NULL;
	while (cur)
	{
		tmp = cur;
		cur = cur->next;
		if (tmp->data % 2 == 1)
		{
			tmp->next = newHead;
			newHead = tmp;
		}
		if (tmp->data % 2 == 0)
		{
			tmp->next = oushuhead;
			oushuhead = tmp;
		}
	}
	Plist head1 = newHead;
	while (head1->next != NULL)
	{
		head1 = head1->next;
	}
	head1->next = oushuhead;
	return newHead;


}

测试代码


完整代码


typedef int DataType;
typedef struct Listnode
{
	DataType data;
	struct Listnode *next;
}List,*Plist;
void Init(Plist&head)
{
	head = NULL;
}
Plist _CreatNode(DataType num)
{
	Plist p = (Plist)malloc(sizeof(List));
	if (p == NULL)
	{
		printf("申请失败。。。\n");
		 exit(EXIT_FAILURE);
	}
	p->data = num;
	return p;
}
void PushBack(Plist&head,DataType num)
{
	Plist p = _CreatNode(num);


	if (head == NULL)
	{
		head= p;
		p->next = NULL;
	}
	else
	{
		Plist cur = head;
		while (cur->next)
		{
			cur = cur->next;
		}
		cur->next = p;
		p->next = NULL;
	}
}
void Pushfront(Plist &head,DataType num)
{
	if (head == NULL)
	{
		PushBack(head,num);
	}
	else
	{
		Plist p=head;
		Plist s = _CreatNode(num);
		head = s;
		s->next = p;
		
	}
}
Plist find(Plist &head,DataType x)
{
	Plist cur = head;
	if (head->data == x)
		return head;
	while (cur->next)
	{
		if (cur->next->data == x)
			return cur;
		cur = cur->next;
	}
	return NULL;
}
void Popfront(Plist &head)
{
	if (head == NULL)
	{
		return;
	}
	Plist Head = head;
	if (head->next == NULL)
	{
		head = NULL;
	}
	else
	{
		head = head->next;
	}
	free(Head);


}
void remove(Plist &head,DataType x)
{
	if (head == NULL)
	{
		printf("this chain is NULL\n");
		return;
	}
	Plist p = find(head, x);


	if (head == p)
	{
		Popfront(head);
	}
	if (p == NULL)
	{
		printf("not the data\n");
		return;
	}
	p->next = p->next->next;
}
Plist merge(Plist head3,Plist head4)
{
	if (head3 == NULL)
		return head4;
	if (head4 == NULL)
		return head3;
	Plist p = NULL;
	Plist cur1 = head3;
	Plist cur2 = head4;
	Plist tail = NULL;
	if (cur1->data < cur2->data)
	{
		p = cur1;
		cur1 = cur1->next;
		tail = p;
	}
	else
	{
		p = cur2;
		cur2 = cur2->next;
		tail = p;
	}
	while (cur1&&cur2)
	{
		if (cur1->data< cur2->data)
		{
			tail->next=cur1;
			cur1 = cur1->next;
			tail = tail->next;
		}
		else
		{
			tail->next = cur2;
			cur2 = cur2->next;
			tail = tail->next;
		}
	}
	if (cur1)
	{
		tail->next = cur1;
		return p;
	}
	if (cur2)
	{
		tail->next=cur2;
		return p;
	}
}
Plist reverse(Plist head)
{
	Plist newHead = NULL;
	Plist cur = head;
	Plist tmp = NULL;
	while (cur)
	{
		tmp=cur;
		cur = cur->next;
		tmp->next = newHead;
		newHead = tmp;
	}
	
	return newHead;
}
Plist find_mid_node(Plist head)
{
	if (head == NULL)
	{
		printf("the chain is NULL\n");
		return NULL;
	}
	if (head->next == NULL||head->next->next==NULL)
	{
		return head;
	}
	Plist fast = head;
	Plist slow = head;


	while (fast->next&&fast->next->next)
	{
		fast = fast->next->next;
		slow = slow->next;
	}
	return slow;
}
void delete_k_node(Plist head,int k)
{
	Plist front = head;
	Plist back = head;
	while (front)
	{
		k--;
		if (k<0)
		{
			back = back->next;
		}
		front = front->next;
	}
	if (k < 0)
	{
		back->data = back->next->data;
		Plist del = back->next;
		back->next = back->next->next;
		free(del);
	}
}
Plist _Sort(Plist head)
{
	if (head == NULL)
	{
		printf("the chain is NULL\n");
		return NULL;
	}
	Plist tail = NULL;
	Plist cur1 = NULL;
	for (Plist cur = head; cur->next!= NULL; cur = cur->next)
	{
		for (cur1 = head; cur1->next != tail; cur1 = cur1->next)
		{
			if (cur1->data > cur1->next->data)
			{
				swap(cur1->data, cur1->next->data);


			}
		}
		tail = cur1;
	}
	return head;
}
Plist jishu_front(Plist head)//把链表奇数放在偶束前面
{
	if (head == NULL)
	{
		printf("the chain is null\n");
		return NULL;
	}
	Plist tmp = NULL;
	Plist cur = head;
	Plist newHead = NULL;
	Plist oushuhead = NULL;
	while (cur)
	{
		tmp = cur;
		cur = cur->next;
		if (tmp->data % 2 == 1)
		{
			tmp->next = newHead;
			newHead = tmp;
		}
		if (tmp->data % 2 == 0)
		{
			tmp->next = oushuhead;
			oushuhead = tmp;
		}
	}
	Plist head1 = newHead;
	while (head1->next != NULL)
	{
		head1 = head1->next;
	}
	head1->next = oushuhead;
	return newHead;


}
int main()
{
	Plist head2 ;
	Plist head1;
	Init(head2);
	Init(head1);
	PushBack(head1, 1);
	PushBack(head1, 2);
	PushBack(head1, 3);
	PushBack(head2,5);
	PushBack(head2, 4);
	PushBack(head2, 6);
	PushBack(head2, 7);


	Plist l = merge(head1,head2);	
	Plist h=reverse(l);
	Plist a = find_mid_node(h);
	Plist g=_Sort(h);
	Plist m=jishu_front(g);
	/*delete_k_node(h,2);*/
	printf("%d\n",a->data);
}


链表合并并排序
道亦无名
12-07 1554
将两个有序的链表合并为一个新链表，要求新的链表是通过拼接两个链表的节点来生成的，且合并后新链表依然有序。 代码如下： /** * struct ListNode { * int val; * struct ListNode *next; * }; */ class Solution { public: /** * * @param l1 ListNode类 * @param l2 ListNode类 * @return ListNode类
浅谈归并排序：合并 K 个升序链表的归并解法
最新发布
hello_1566的博客
01-08 1197
如何实现多个升序链表的合并。这是 LeetCode 上的一道原题，题目具体如下
有序链表按逆序合并的实现
10-26
严蔚敏教材中所讲的将递增的两个顺序表按逆序合并算法的实现。不错的算法，很容易理解。代码可以直接运行
链表逆序、有序合并
02-02 954
struct Node { int data; Node *next; }; typedef struct Node Node; 1)已知链表的头结点head，写一个函数把这个链表逆序 Node *ReverseList(Node *head) { if(head == NULL || head->next == NULL) return head; Node *p1
力扣 143. 重排链表 链表逆序+合并
xiji333的博客
08-06 322
https://leetcode-cn.com/problems/reorder-list/ 思路：首先通过快慢指针得到链表的中点，从中点处断开再将后半部分翻转一下，那么问题就很简单了，逐一合并两个链表即可。 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} *
写链表逆序，两个链表合并成有序链表
single6的博客
08-30 897
struct Node{ int data; Node *next; }; typedef struct Node Node; Node *Reverse(Node *head){ if(head==NULL||head-&gt;next==NULL) { return head;} Node *p1=head; Node *p2=p1-&gt;next; Node *p3=p2-&gt;...
链表操作详解：双向链表删除、合并排序及环检测
有序链表的合并是将两个已排序的链表组合成一个新的有序链表。通常使用归并排序中的合并过程，步骤如下： - 创建一个哑节点（dummy node）作为合并后链表的头部，并用一个指针current指向这个哑节点。 - 比较两个...
数据结构链表排序数据结构课设，链表排序，升序，逆序，倒置
03-19
本项目“数据结构链表排序数据结构课设”旨在通过实际操作加深对链表排序的理解，包括升序、逆序和倒置等操作。 链表不同于数组，它不连续存储数据，而是通过节点之间的指针链接。每个节点包含数据元素和指向下一个...
cpp代码-链表的合并、排序（O(n^2)）-oj
07-14
- `main.cpp`文件很可能是实现链表合并和排序算法的代码，包含了必要的节点定义、插入、删除、比较和遍历等函数。 - `README.txt`文件可能包含了关于代码的简要说明、使用方法或问题描述。 4. **在线判题系统（oj...
17 - 01 - 03 链表逆序合并
Sodaoo's Blog
12-26 608
【问题】 现有两个单链表A、B，他们的元素都是递增有序。 编写算法将A、B 归并成一个按元素值递减有序的(允许有相同值) 链表C、要求用A、B、中的原结点形成，不能重新申请新节点。/*两个单链表的有序合并*/ LinkList Merge(LinkList A,LinkList B) { LinkList C; LNode *p,*q; p = A->next; q
链表头插法-实现两个递增表合并且逆序
05-12
链表头插法-实现两个递增表合并且将它进行逆置逆序
（杂）百度实习的一道题链表逆序，合并两个有序链表
简洁之美 的专栏
06-25 789
关于链表逆序，
链表的逆序输出与两个有序链表的合并
yd的博客
07-01 1056
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; struct node{ int data; struct node *next; }; int main() { struct node *head , *p , *q , *t; int i , n , a; void reverse(struct ...
两个链表的连接和逆序合链表
m0_63985448的博客
10-12 409
链表合并逆序
单链表操作：逆序、合并
no crying out, but Striving for!
09-28 709
备注：常常看到有关单链表的逆序、合并问题，
链表的合并与逆置
qq_61769596的博客
11-27 799
##单链表的合并与逆置 一.单链表合并 算法分析： 合并链表需要利用Merge函数，首先定义两个指针变量p和q,分别指向HA链表与HB链表的首元结点，并让r指向合并后的链表尾结点，合并后的链表头结点公用HA链表的头结点。 首先定义一下链表类型： typedef struct node { char name[20]; int number; int score; struct node*next; }Node,*LinkList; 合并程序如下： Void Merge(LinkList HA,Lin
数据结构复习之单链表：基本操作及逆序打印、逆转、合并等
指点江山，激扬code
08-18 698
#include “stdafx.h” #include<malloc.h>struct ListNode; typedef int ValueType; typedef struct ListNode* Position;/*List中存放的是ListNode结构体的首地址，但若定义List list，则可直接使用list->value来访问结构体中的变量值，所以“->”运算符就是取指针所指向的值
【算法】单链表的逆序，指定获取与合并
m0_71917549的博客
01-18 184
对单链表逆序操作，获取第k个值，合并两个有序单链表。单链表 数据加入，修改，删除，显示。
链表的创建、逆序、合并、遍历
qfl_sdu的博客
09-27 719
功能： 将两个非递减次序排列的单链表归并为一个非递增次序排列的单链表，并计算表长。要求利用原来两个单链表的结点存放归并后的单链表。 效果图： 代码： #include <iostream> using namespace std; struct StNode { int data; struct StNode* next; }; //创建节点 StNode* CreateNode(int d) { StNode* node = new StNode; node-.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值