4.单链表ADT模板简单应用算法设计：单链表中前 m 个元素和后 n 个元素的互换

关注

原创最新推荐文章于 2026-02-13 02:30:11 发布 1.3k 阅读 AI 写同款· GEO 优化 ›

【信息科学与工程学】计算机科学与自动化——第三百零五篇计算机系统中的各类运算操作01 编号类型领域运算操作运算类型算法算法的详细设计及数学分析参数列表及参数的数值设计应用场景 (100+条)集合运算1集合运算关系代数并集 (Union)集合运算归并排序去重合并两个集合，去除重复元素。时间复杂度 O(n+m)，n,m为两集合大小。输入：集合A, B。输出：A∪B。数据集成、多表结果合并、去重后的全量数据提取。2集合运算关系代数交集 (Intersection)集合运算哈希交集找出同时属于两个集合的元素。平均时间复杂度 O(min(n,m))，最坏 O(n*m)。输入：集合A, B。输出：A∩ 阅读详情

问题描述 :

目的：使用C++模板设计单链表的抽象数据类型（ADT）。并在此基础上，使用单链表ADT的基本操作，设计并实现单链表的简单算法设计。

内容：（1）请使用模板设计单链表的抽象数据类型。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。参考网盘中的ADT原型文件。）

（2）ADT的简单应用：使用该ADT设计并实现单链表应用场合的一些简单算法设计。

应用1：假设有一个带头结点的单链表A，现要求设计一个算法，实现单链表的就地逆置，即利用原表的存储空间实现表中前m 个元素和后n 个元素的互换。

参考函数原型：

template<class ElemType>

void Exchange_L( LinkList<ElemType> &L, int m );

单链表ADT原型如下：

/* 单链表的结点定义 */
template<class ElemType>
struct LinkNode
{
    ElemType data;
    LinkNode<ElemType> *next;
    LinkNode(LinkNode<ElemType> *ptr = NULL){next = ptr;}
    LinkNode(const ElemType &item, LinkNode<ElemType> *ptr = NULL)
    //函数参数表中的形参允许有默认值，但是带默认值的参数需要放后面
    {
        next = ptr;
        data = item;
    }
};

//带头结点的单链表
template<class ElemType>
class LinkList:public link<ElemType>
{
   private:
      LinkNode<ElemType> *head;   // 头指针
LinkNode<ElemType> *tail;   // 尾指针

   public:
      //无参数的构造函数
      LinkList(){head = new LinkNode<ElemType>; tail =head;}
      //带参数的构造函数
      LinkList(const ElemType &item){head = new LinkNode<ElemType>(item); tail = head;}
      //拷贝构造函数
      LinkList(LinkList<ElemType> &List);
      //析构函数
      ~LinkList(){ListDestroy();}
      //重载函数:赋值
      LinkList<ElemType>& operator=(LinkList<ElemType> &List);
      //销毁链表
      void ListDestroy();
      //清空链表
      void ListClear();
      //返回链表的长度
      int ListLength() const;
      //判断链表是否为空表
      bool ListEmpty() const;
      //在首结点之前插入一个结点
      bool InsFirst( ElemType &e );
//在尾结点之前插入一个结点
      bool InsTail( ElemType &e );

      //获取链表头指针
      LinkNode<ElemType>* GetHead() const{ return head;}
//获取链表尾指针
      LinkNode<ElemType>* GetTail() const{ return tail;}

      //设置链表头指针
void SetHead(LinkNode<ElemType> *p){ head = p;}
//设置链表尾指针
void SetTail(LinkNode<ElemType> *p){ tail = p;}

      //用e返回链表的第i个元素
      ElemType GetElem(int pos);
      //在链表的第pos个位置之前插入e元素
      bool ListInsert(int pos,ElemType e);
      //删除链表的首结点
      //bool DelFirst( ElemType &e);
      //表头插入法动态生成链表
      void CreateList_Head(vector<ElemType> &A);
      //表尾插入法动态生成链表
      void CreateList_Tail(vector<ElemType> &A);
      //删除链表的第pos个位置的元素
      ElemType ListDelete(int pos);
      //compare函数，用来判断a和b是否相等
      //bool compare(ElemType a, ElemType *b);
      //按指定条件查找，返回指向第一个符合条件（=e）的元素的指针
      bool LocateElem(const ElemType &e, LinkNode<ElemType> * &pos);
      //返回链表给定数据元素的前驱数据元素的值
      //bool PriorElem(ElemType cur_e, ElemType &pri_e);
      //返回链表给定数据元素的后继数据元素的值
      bool NextElem(LinkNode<ElemType> *p, ElemType &e);
      //遍历链表
      bool ListTraverse() const;
};

输入说明 :

第一行：顺序表A的数据元素的数据类型标记（0：int，1：double，2：char，3：string）

第二行：待逆置单链表的数据元素（数据元素之间以空格分隔）

第三行：逆置位置m

输出说明 :

如第一行输入值为0、1、2、3之外的值，直接输出“err”

否则：

第一行：待逆置单链表的遍历结果（数据元素之间以"->"分隔）

空行

第三行：逆置后单链表的遍历结果（数据元素之间以"->"分隔）

这是一条分割线

题解

对于其中的关键exchange函数的解析：

可以参考某网友的图解

法一：在创建单链表时，cin>>elem一个一个输入节点

完整AC代码：

#include<iostream>
using namespace std;

template<class T>
 struct LNode{
	T data;
	LNode<T>* next=NULL;
};

//遍历输出 
template <class T>
void traverse(LNode<T>& L,int length){
	LNode<T>* p=&L;//p初始化指向头节点
	for(int i=1;i<length;++i)
	{
		p=p->next;
		cout<<p->data<<"->";
	}
	cout<<p->next->data;
}
//将前m个节点与后n个节点互换 
template <class T>
void exchange(LNode<T>& L,int  m,int length){
	LNode<T>* rear;//尾指针 
	LNode<T>* p=&L;//p初始化指向头节点 
	LNode<T>* pm;
	
	for(int i=1;i<=length;i++)
	{
		p=p->next;
		if(i==m)	pm=p;//pm指向第m个节点 
	}
	rear=p;
	
	rear->next=L.next;
	L.next=pm->next;
	rear=pm;
}
//用后插法创建单链表 
template <class T>
void create(LNode<T>& L,int & length){

	LNode<T>* rear=&L;//尾指针 
	LNode<T>* p;//p用来指向每一个新输入的节点 
	T elem;
	while(cin>>elem)
	{
		length++;
		p=new LNode<T>;
		p->data=elem;
		rear->next=p;
		rear=p;
		if(cin.get()=='\n')	break;
		//cin会跳过空格和tab，cin.get()不会跳过空格，tab，回车 
	}
}

int main(){
	int kind=0;
	cin>>kind;
	if(kind==0)
	{
		LNode<int> L;
		int len=0;
		create(L,len);
		int m=0;
		cin>>m;
		traverse(L,len);
		cout<<endl<<endl;
		exchange(L,m,len);
		traverse(L,len);
	}
	else if(kind==1)
	{
		LNode<double> L;
		int len=0;
		create(L,len);
		int m=0;
		cin>>m;
		traverse(L,len);
		cout<<endl<<endl;
		exchange(L,m,len);
		traverse(L,len);
	}
	else if(kind==2)
	{
		LNode<char> L;
		int len=0;
		create(L,len);
		int m=0;
		cin>>m;
		traverse(L,len);
		cout<<endl<<endl;
		exchange(L,m,len);
		traverse(L,len);
	}
	else if(kind==3)
	{
		LNode<string> L;
		int len=0;
		create(L,len);
		int m=0;
		cin>>m;
		traverse(L,len);
		cout<<endl<<endl;
		exchange(L,m,len);
		traverse(L,len);
	}
	else
	{
		cout<<"err";
	}
	
	
	
	return 0;
}

其中中的create函数创建单链表的方法借鉴了，DHU另一位朋友的写法

本菜鸟学到了用cin>>elem,和用cin.get()=='\n',来进行输入。cin,get()不会跳过空格，tab，以及换行符。

另外在写各个函数时，我用LNode<T>* L来作形参老是出问题，暂时我不清楚问题出在哪儿了，所以先略过。

法二：用getline(cin,str)整行输入，再用stringstream 类将str转换为单个节点存入链表。

只是在

template <class T>
void create(LNode<T>& L,int & length,stringstream &stream){

	LNode<T>* rear=&L;//尾指针 
	LNode<T>* p;//p用来指向每一个新输入的节点 
	T elem;
	while(stream>>elem)
	{
		length++;
		p=new LNode<T>;
		p->data=elem;
		rear->next=p;
		rear=p;
	}
}

和主函数main()中有略微差别

int kind=0;
	cin>>kind;
	cin.get();//跳过换行符 
	string str;
	getline(cin,str);//结束符'\n'不会放入缓存区，会将读入的'\n'直接去除 
	stringstream stream;
	stream<<str;
	if(kind==0)
	{
		LNode<int> L;
		int len=0;
		create(L,len,stream);
		int m=0;
		cin>>m;
		traverse(L,len);
		cout<<endl<<endl;
		exchange(L,m,len);
		traverse(L,len);
	}

完整AC代码：

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

template<class T>
 struct LNode{
	T data;
	LNode<T>* next=NULL;
};

//遍历输出 
template <class T>
void traverse(LNode<T>& L,int length){
	LNode<T>* p=&L;//p初始化指向头节点
	for(int i=1;i<length;++i)
	{
		p=p->next;
		cout<<p->data<<"->";
	}
	cout<<p->next->data;
}
//将前m个节点与后n个节点互换 
template <class T>
void exchange(LNode<T>& L,int  m,int length){
	LNode<T>* rear;//尾指针 
	LNode<T>* p=&L;//p初始化指向头节点 
	LNode<T>* pm;
	
	for(int i=1;i<=length;i++)
	{
		p=p->next;
		if(i==m)	pm=p;//pm指向第m个节点 
	}
	rear=p;
	
	rear->next=L.next;
	L.next=pm->next;
	rear=pm;
}
//用后插法创建单链表 
template <class T>
void create(LNode<T>& L,int & length,stringstream &stream){

	LNode<T>* rear=&L;//尾指针 
	LNode<T>* p;//p用来指向每一个新输入的节点 
	T elem;
	while(stream>>elem)
	{
		length++;
		p=new LNode<T>;
		p->data=elem;
		rear->next=p;
		rear=p;
	}
}

int main(){
	int kind=0;
	cin>>kind;
	cin.get();//跳过换行符 
	string str;
	getline(cin,str);//结束符'\n'不会放入缓存区，会将读入的'\n'直接去除 
	stringstream stream;
	stream<<str;
	if(kind==0)
	{
		LNode<int> L;
		int len=0;
		create(L,len,stream);
		int m=0;
		cin>>m;
		traverse(L,len);
		cout<<endl<<endl;
		exchange(L,m,len);
		traverse(L,len);
	}
	else if(kind==1)
	{
		LNode<double> L;
		int len=0;
		create(L,len,stream);
		int m=0;
		cin>>m;
		traverse(L,len);
		cout<<endl<<endl;
		exchange(L,m,len);
		traverse(L,len);
	}
	else if(kind==2)
	{
		LNode<char> L;
		int len=0;
		create(L,len,stream);
		int m=0;
		cin>>m;
		traverse(L,len);
		cout<<endl<<endl;
		exchange(L,m,len);
		traverse(L,len);
	}
	else if(kind==3)
	{
		LNode<string> L;
		int len=0;
		create(L,len,stream);
		int m=0;
		cin>>m;
		traverse(L,len);
		cout<<endl<<endl;
		exchange(L,m,len);
		traverse(L,len);
	}
	else
	{
		cout<<"err";
	}
	
	
	
	return 0;
}

本菜鸟学到了：

1.getline(cin,str),可以输入整行，对于行末结束符'\n'不会放入缓存区，直接舍弃

2.stringstream stream:常用于string字符串数据类型转换，详细信息请参考关于stringstream的使用

（有问题欢迎在评论区讨论）

收录于