链表逆置、合并和相关其他函数

最新推荐文章于 2022-03-03 11:32:37 发布
最新推荐文章于 2022-03-03 11:32:37 发布
阅读量83 收藏
点赞数
分类专栏： 数据结构学习 文章标签： 链表 其他 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52179617/article/details/122390155
版权

test.h

#include<bits/stdc++.h>
#ifndef TEST_H 
#define TEST_H
using namespace std;

template <class T> 
class Node
{
public:
	T data;
	Node<T> *next;

	Node(T data=0){this->data=data;this->next=NULL;}
};

template <class T>
class LinkList
{
	Node<T> *head;
public:
	LinkList();										//无参构造函数 
	LinkList(T a[],int n);							//有参构造函数 
	void Evaluation(T a[],int n);  					//为了给无法调用构造函数但又需要给链表赋值的特殊情况 
	~LinkList();									//析构函数 
	int Listlength();   							//求链表长度 
	T Get(int pos);									//按位查找返回第pos个元素       
	int Locate(T x);								//按值查找，返回值为x的序号 	
	void PrintList();								//遍历链表并依次输出 
	void Insert(int i,T item);						//在第I个位置插入item元素  		
	T Delete(int i);								//删掉第I个元素 
	
	void Invert();									//链表逆序	
	void Merge(LinkList &li1,LinkList &li2);		//链表合并
	void Split(int pos,LinkList &li1);				//链表分段	
};

template<class T>
LinkList<T>::LinkList()
{
	head=new Node<T>;
	head->next=NULL;
}

template<class T>
LinkList<T>::~LinkList()
{
	Node<T> *q=NULL;
	Node<T> *p=head;
	while( p!= NULL )
	{
		q= p->next;
		delete p;
		p = q;
	}
}

template<class T>
void LinkList<T>::Evaluation(T a[],int n)
{
	head=NULL;
	Node<T> *p=head;
	for(int i=0;i<n;i++)
	{
		Node<T> *tmp=new Node<T>(a[i]);
		if(head==NULL)
			head=tmp;
		else
			p->next=tmp;
			p=tmp;			
	}
	p->next=NULL;
}

template<class T>
LinkList<T>::LinkList(T a[],int n)
{
	head=NULL;
	Node<T> *p=head;
	for(int i=0;i<n;i++)
	{
		Node<T> *tmp=new Node<T>(a[i]);
		if(head==NULL)
			head=tmp;
		else
			p->next=tmp;
			p=tmp;			
	}
	p->next=NULL;
}

template<class T>
void LinkList<T>::PrintList()
{
	Node<T> *p=head;
 	while(p!=NULL)
 	{
 		cout<<p->data<<" ";
		p=p->next;	
	}
}

template<class T>
int LinkList<T>::Listlength()
{
	Node<T> *p=head;
    int length = 0;
    while (p) 
	{
        length++;
        p=p->next;
    }
    return length;
}

template<class T>
T LinkList<T>::Get(int pos)
{
	int length=this->Listlength();int tmp=pos;
	if(tmp>length || tmp<=0){return -1;}
	
	Node<T> *p=head;
	int tmp1=1;
	while(tmp1!=pos)
	{
		p=p->next;
		tmp1++;
	}
	return p->data;
}

template<class T>
int LinkList<T>::Locate(T x)
{
	int length=this->Listlength();int tmp=0;Node<T> *p=head;
	
	for(int i=0;i<length;i++)
	{
		if(p->data==x)
		{
			tmp=i+1;
			break;
			return tmp;
		}
		p=p->next;
	}
	if(tmp==0)
		return -1;
}

template<class T>
void LinkList<T>::Insert(int i,T item)
{
	int length=this->Listlength();Node<T> *p=head; 
	if(length==0)	{cout<<"链表为空，默认从第一个开始插入"<<endl;p->data=item;}
	if(i<1)			{cout<<"无法插入第"<<i<<"个元素，请重新输入插入序号"<<endl;}
	else if(i>length)
	{
		cout<<"序号过大，已超出数组最大长度，默认添加在最后一位"<<endl;
		int tmp1=1;
		while(tmp1!=length){p=p->next;tmp1++;}
		
		Node<T> *tmp=new Node<T>(item);
		p->next=tmp;
		p=tmp;
	}
	else
	{
		int tmp2=1;while(tmp2<i-1){p=p->next;tmp2++;}
		Node<T> *s=new Node<T>(item);
		s->next=p->next;p->next=s;
	}
}

template<class T>
T LinkList<T>::Delete(int i)
{
	int tmp=this->Listlength();Node<T> *p=head;
	if(i<0 || i>tmp)	{return -1;}
	else if(i>tmp)		{return -2;}
	else
	{
		int tmp1=1;
		while(tmp1<i-1){p=p->next;tmp1++;}
		Node<T> *s=new Node<T>;
		s=p->next;
		T x=s->data;
		p->next=s->next;
		delete s; 
		return x;
	}
}

template<class T>
void LinkList<T>::Invert()
{
	Node<T> *p, *q;      
	p = head;q = head->next;p->next=NULL;    
	while (q!=NULL)
	{
		p = q;
		q = q->next;
		p ->next = head;   
		head = p;          
	}
}

template<class T>
void LinkList<T>::Merge(LinkList &li1,LinkList &li2)
{
	Node<T> *p1,*p2,*p3;
	p1=li1.head->next;p2=li2.head;p3=li1.head;
	while((p1!=NULL) && (p2!=NULL)) 
	{
		if((p1->data)<(p2->data)){p3->next=p1;p1=p1->next;p3=p3->next;}
		else if((p1->data)>(p2->data)){p3->next=p2;p2=p2->next;p3=p3->next;}
		else if((p1->data)=(p2->data)){p3=p3->next;p1=p1->next;p2=p2->next;}		
	}
	if(p1!=NULL){p3->next=p1;}
	if(p2!=NULL){p3->next=p2;}
}

template<class T>
void LinkList<T>::Split(int pos,LinkList &li1)
{
	Node<T> *p=head;Node<T> *q;
	int tmp1=1;int k=this->Listlength()-pos;T a[1000];int i=0;
	if(k<=0){cout<<"输入数值超出链表长度，无法分段！";}
	else if(pos<=0){cout<<"输入的分段位置非法，无法分段！";tmp1=1000;}

	while(tmp1!=pos+1)
	{
		p=p->next;tmp1++;
		if(tmp1==pos){q=p;}
	}
	while(p!=NULL){a[i]=p->data;p=p->next;i++; }
	li1.Evaluation(a,k);q->next=NULL;
}

#endif

main.cpp

#include<iostream>
using namespace std;
template<class T>
struct Node                    //单链表的结点结构（数据域和指针域）
{
	T data;           
	Node<T> *next;
};
template<class T>
class LinkList
{
	Node<T> *head;                   //单链表的头指针
public:
	LinkList();                           //建立带头结点的空链表
	LinkList(T a[],int n);                   //建立有n个元素的单链表
	~LinkList();                            //析构函数
	int ListLength();                       //求单链表的长度
	T Get(int pos);                         //按位查找，取单链表中第pos个结点的元素值
	int Locate(T item);                    //按值查找，求单链表中值为item的元素序号
	void PrintLinkList();                 //遍历单链表，按序号依次输出各元素
	void Insert(int i,T item);             //在单链表中第i个位置上插入元素为item的结点
	T Delete(int i);                       //在单链表中删除第i个结点
	void Invert();                           //逆置单链表
	friend void Merge(LinkList<T>&L1,LinkList<T>&L2);     //合并有序单链表，声明为友元函数
	void Sort();
};
template<class T>
LinkList<T>::LinkList()
{
	head=new Node<T>;
	head->next=NULL;
}

template<class T>
LinkList<T>::LinkList(T a[],int n)
{
	/*head=new Node<T>;                 //生成头结点
	rear=head;                         //指针r用于指向当前单链表的最后一个结点
	for(int i=0;i<n;i++)                  //为每个数组元素生成一个新结点，并插入到链表尾部
	{
		s=new Node<T>;
		s->data=a[i];
		rear->next=s;
		rear=s;
	}
	rear->next=NULL;*/                    //单链表建立完毕，将最后一个结点的指针域置空
	head = new Node<T>;
	head->next = NULL;
	for (int i = 0; i < n; i++)
	{
		Node<T>* p;
		p = new Node<T>;
		p->data = a[i];
		p->next = head->next;
		head->next = p;
	}
}

template<class T>
int LinkList<T>::ListLength()
{
	Node<T>* p;
	int num=0;
	p=head->next;
	while(p)
	{
		p=p->next;
		num++;
	}
	return num;
}

template<class T>
T LinkList<T>::Get(int pos)
{
	Node<T>* p;
	p=head->next;                 
	int j=1;                    //p初始化为第1个数据结点的地址，j初始化为1
	while(p&&j<pos)
	{
		p=p->next;
		j++;
	}
	if(!p||j>pos)
	{
		cerr<<"查找位置非法";
		exit(1);
	}
	else return p->data;
}

template<class T>
int LinkList<T>::Locate(T item)
{
	Node<T>* p;
	p=head->next;
	int j=1;
	while(p&&p->data!=item)
	{
		p=p->next;
		j++;
	}
	if(p)
		return j;
	else
		return 0;
}

template<class T>
void LinkList<T>::PrintLinkList()
{
	Node<T>* p;
	p=head->next;
	while(p)
	{
		cout<<p->data<<endl;
		p=p->next;
	}
}

template<class T>
void LinkList<T>::Insert(int i,T item)
{
	Node<T>* p;
	p=head;
	int j=0;
	while(p&&j<i-1)      //找到第i-1个结点的位置
	{
		p=p->next;
		j++;
	}
	if(!p)
	{
		cerr<<"插入位置非法";
		exit(1);
	}
	else
	{
		Node<T>* s;                           //得先定义一个新结点    
		s = new Node<T>;                //生成元素为item的新结点s
		s->data=item;
		s->next=p->next;         //用后插法将s插入到结点p的后面
		p->next=s;
	}
}

template<class T>
T LinkList<T>::Delete(int i)
{
	Node<T>* p;
	p=head;
	int j=0;
	while(p&&j<i-1)       //查找第i-1个结点
	{
		p=p->next;
		j++;
	}
	if(!p||!p->next)
	{
		cerr<<"删除位置非法";
		exit(1);
	}
	else
	{
		Node<T>* q;
		int x;
		q=p->next;
		x=q->data;
		p->next=q->next;
		delete q;
		return x;
	}
}

template<class T>
LinkList<T>::~LinkList()
{
	Node<T>* p;
	p=head;
	while(p)
	{
		Node<T>* q;                     //需要给q先定义为指针变量
		q=p;
		p=p->next;
		delete q;
	}
	head=NULL;
}
template<class T>
void LinkList<T>::Invert()
{
	Node<T>* p;
	p=head->next;
	head->next=NULL;                   //将逆置后的单链表初始化为空表
	while(p!=NULL)                      //遍历单链表中的结点
	{
		Node<T>* q;
		q=p;
		p=p->next;
		q->next=head->next;           //将结点插入到逆置后的单链表的表头
		head->next=q;
	}
}

template<class T>
void Merge(LinkList<T>&L1,LinkList<T>&L2)
{
	Node<T>* p1 = L1.head->next;
	Node<T>* p2 = L2.head->next;
	Node<T>* p3 = L1.head;
	while((p1!=NULL)&&(p2!=NULL))
	{
		if((p1->data)<(p2->data))
		{
			p3->next=p1;
			p1=p1->next;
			p3=p3->next;
		}
		else
		{
			p3->next=p2;
			p2=p2->next;
			p3=p3->next;
		}
	}
	if(p1!=NULL)
		p3->next=p1;
	if(p2!=NULL)
		p3->next=p2;
	delete L2.head;
	L2.head=NULL;
}

template<class T>
void LinkList<T>::Sort()
{
	Node<T>* p;
	p = head->next;
	Node<T>* q=NULL;
	while (p)
	{
		Node<T>* tempp = p;
		p = p->next;
		Node<T>* prev, * tempq;
		for (prev = NULL, tempq = q; tempq != NULL; prev = tempq, tempq = tempq->next)
			if (tempq->data > tempp->data)
				break;
		tempp->next = tempq;
		if (prev == NULL)
			q = tempp;
		else
			prev->next = tempp;
	}
	head->next = q;
}

int main()
{
	int *a;
	int num;
	cout << "请输入链表元素的个数:";              //创建长度为num的链表
	cin >> num;
	if (num <= 0)
	{
		cout << "创建失败!" << endl;
		return 0;
	}
	cout << "创建长度为" << num << "的链表" << endl;
	a=new int[num];
	for (int i = 0; i < num; i++)
	{
		cin >> a[i];
	}
	LinkList <int> l(a, num);
	l.PrintLinkList();

	//int l1=l.Get(6);
	int l1=l.Get(3);
	cout<<"查找到的元素是:"<<l1<<endl;

	int item,l2;
	cout<<"输入想要查询的数据:";
	cin>>item;
	l2=l.Locate(3);
	cout<<"查询到数据的序号为:"<<l2<<endl;

	l.Insert(2,8);
	cout << "插入结点后的链表为：" << endl;
	l.PrintLinkList();

	l.Delete(4);
	cout << "删除结点后的链表为：" << endl;
	l.PrintLinkList();

	l.Invert();
	cout << "逆置后的链表为：" << endl;
	l.PrintLinkList();

	int *b;
	int n2;
	cout << "请输入链表元素的个数:";              
	cin >> n2;
	b=new int[n2];
	for (int j = 0; j < n2; j++)
	{
		cin >> b[j];
	}
	LinkList <int> ll(b, n2);
	Merge(l,ll);
	cout << "合并后的链表为：" << endl;
	l.Sort();
	l.PrintLinkList();
	

	return 0;
}
哈哈笑死哈哈
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
链表合并与逆置
qq_43717119的博客
06-13 290
对两个元素递增有序的单链表A和单链表B，编写算法将A、B合并成为一个按元素递减有序（允许有相同元素）的单链表C，不允许使用A、B中的原有结点，不允许增加新结点。
单向链表的逆置 C++源代码
06-09
单向链表是一种常见的数据结构，它由一系列...此外，链表逆置问题可以进一步扩展到双向链表、带有附加属性的链表，甚至是链表的其他操作，如插入、删除、合并等。熟悉这些操作对于提升编程技能和应对面试挑战至关重要。
链表倒置与合并小结(含稀疏多项式求值)
qq_51340322的博客
03-22 272
链表倒置与合并小结(共四个) 请看目录： 文章目录链表倒置与合并小结(共四个)一、链表整体倒置二、链表局部倒置三、有序链表的合并(包含链表有序化)四、稀疏多项式求值 注：代码均在Dev_C++中运行，可能存在谬误，但在此编译器均可通过 在目录中，一、二为一类，三四为一类，其中二为一的加强，四为三的加强 一、链表整体倒置 思路&&步骤： 设置前驱指针，遍历指针，前驱指针存上个节点的地址，遍历指针向后走，一直到尾部 前驱初始化为NULL，每一次前驱都要覆盖遍历指针所指节点指针域的地址，
合并两个有序链表
weixin_30530339的博客
09-15 82
合并两个有序链表，使得合并后的结果仍然是有序的，直观的做法就是从两个链表的首节点开始比较，将其中小的那个链接到新链表之中，（如果不想破坏原链表，那么需要将该节点拷贝一份，然后链接到新链表之中。）然后将该节点对应的原链表的遍历指针向后移动（p = p->next）一直这样比较下去，直到其中某个被遍历完，这时将剩余的那个链表直接链接到新链表后面即可。 当然，对...
链表的合并与逆置
qq_61769596的博客
11-27 747
##单链表的合并与逆置 一.单链表合并 算法分析： 合并链表需要利用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
c语言链表的就地逆置,单链表就地逆置以及链表合并
weixin_33835558的博客
05-19 277
题目：链表操作：1. 单链表就地逆置2. 合并链表数据结构基础题代码实现(GCC编译通过)#include"stdio.h"#include"stdlib.h"typedefstructnode{intdata;structnode*next;}link;link*ReverseLink(link*head);link*AddLink(link*h1,link*...
JAVA单链表的简单操作（递增单链表插入数据，链表逆置，链表逆序合成）
12-21
本文主要探讨了在单链表中执行三个基本操作：有序插入、链表逆置以及两个有序链表的合并。 1. **有序插入**： 给定一个按整数值递增排序的带头结点的动态单链表L，我们需要在链表中插入值为x的结点，保持链表的...
C合并两升序单链表并逆置
05-29
此函数接收两个升序单链表`la1`和`la2`，将它们合并成一个新的升序单链表。首先遍历两个链表，当`la2`非空且`la2->next->data`小于等于`p1->next->data`时，将`la2->next`插入到`p1`之后。如果`la2`链表仍有剩余节点...
链表实现拼接
11-05
链表是一种常用的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的引用。在编程中，特别是C++这样的语言中，链表的实现通常涉及到自定义结构体或类来表示节点，以及相应的操作函数。在这个场景中...
链表，建立链表、遍历链表、排序、去重、反转。。。。
04-21
3. **链表逆置**：在不创建新节点的情况下，链表逆置可以通过三个指针（当前节点、前一个节点和临时节点）来完成。遍历链表，每次将当前节点的指针指向前一个节点，然后更新前一个节点为当前节点，当前节点为下一个...
第二章 链表——链表的逆序
weixin_42976216的博客
03-04 262
第二章 线性表—链表的逆序 数据结构基础代码 （严蔚敏 人邮教育出版社） #include <stdio.h> #include <stdlib.h> #include <iostream> using namespace std; //写一个函数,把链表逆序 typedef struct LNode { int data; struct LNo...
【链表】两个有序链表的合并
百栗.的博客
04-21 1181
两个有序链表的合并 题目要求： 本题要求实现一个函数，将两个链表表示的递增整数序列合并为一个非递减的整数序列。 函数接口定义： List Merge( List L1, List L2 ); 其中List结构定义如下： typedef struct Node *PtrToNode; struct Node { ElementType Data; /* 存储结点数据 */ ...
LeetCode 21. 合并两个有序链表
黑桃K
09-02 98
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} * ListNode(int x) : val(x), next(nullptr) {} * .
QT属性动画--设置样式属性(其他属性)
lizequan的博客
03-02 5494
这里写自定义目录标题故事背景遇到的问题解决过程最终方法感悟 故事背景   最近在制作一个按钮切换的动画特效中接触了属性动画这部分内容，并由此产生了一些思考。 遇到的问题 解决过程 最终方法 感悟 ...
Volatile的其他特性
我想月薪过万的博客
03-03 3975
2.1 volatile总体概览 在上一节中，我们已经研究完了volatile可以实现并发下共享变量的可见性，volatile除了保证可见性外，volatile还具备如下一些突出的特性： volatile的原子性问题：volatile不能保证原子性操作 禁止指令重排序：volatile可以防止指令重排序操作 2.2 volatile不保证原子性 2.3 代码测试 package Ls; /** * 目标：研究Volatile的原子性操作 * <p> * 基本观点：V.
【安卓基础】Android直接通过路径来操作其他应用的私有目录，可以吗？
m0_48179608的博客
03-02 7715
在上篇文章[【安卓基础】一文搞懂Android历代版本文件访问权限变化](https://blog.csdn.net/m0_48179608/article/details/122838494)我们对同一个应用的的文件访问权限做了比较。 那么不同应用之间文件访问又有什么限制呢？我们准备分二到三篇文件来阐述。 这篇文章，主要来看下不同系统版本下，我们直接通过路径来访问其它应用的**内部存储、外部存储私有目录**，看看能不能访问以及不同系统版本的区别。
Silane-PEG-NHS，SIL-PEG-NHS，可以用来修饰蛋白质、多肽以及其他活性基团，NHS-PEG-Silane
qq_39152602的博客
03-03 3609
英文名称：Silane-PEG-NHS 中文名称：硅烷-聚乙二醇-活性酯 分子量：1k，2k，3.4k，5k，10k，20k（可按需定制） 质量控制：95%+ 存储条件：-20°C，避光，避湿 用 途：仅供科研实验使用，不用于诊治 外观: 固体或粘性液体，取决于分子量 注意事项：取用一定要干燥，避免频繁的溶解和冻干 溶解性：溶于大部分有机溶剂，如：DCM、DMF、DMSO、THF等等。在水中有很好的溶解性 取用：现配现用，将包装从冰箱中取出，置于干燥器中缓慢升至室温，打开瓶盖，取用。取用.
[Golang]力扣Leetcode—中级算法—其他—两整数之和（位运算）
皮埃尔的博客
03-03 2927
[Golang]力扣Leetcode—中级算法—其他—两整数之和（位运算）
数据结构算法设计：合并递增链表并逆置
数组和广义表是更复杂的数据结构，数组提供随机访问但插入和删除操作较慢，而广义表可以表示更复杂的结构，如多重链表。这部分内容可能涉及如何高效地实现数组操作和广义表的存储及遍历算法。 树和二叉树是树形数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

哈哈笑死哈哈

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值