链表的基本操作

最新推荐文章于 2022-08-20 22:42:09 发布
最新推荐文章于 2022-08-20 22:42:09 发布
阅读量596 收藏
点赞数
分类专栏： 数据结构（c++）源代码实现 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenxueying0728/article/details/21039657
版权

头文件

#ifndef LINKLIST_H_INCLUDED
#define LINKLIST_H_INCLUDED
#include <stdlib.h>
#include <iostream>

using namespace std;

template<class T> class LinkList;

//链表的结点类;
template<class T>
class node {                 //单链表的结点类;
public:
  node(const T dataval, node<T>* linkval =NULL):data(dataval),next(linkval){}
  //构造函数1：根据对已给结点数据和指针构造新结点;
  node(node<T>* linkval =NULL):next(linkval){} //构造函数2：根据对已给结点指针构造新结点;
  ~node(){}
  //template<class T>
  friend class LinkList<T>;
private:
  T data;                    //结点元素的值;
  node<T> *next;             //链表的下一个结点指针;
};

template<class T>
class LinkList{							// 有序链表类;
private:
  node<T>* first;					    // 表头指针;;;
public:
  LinkList();						   // 构造函数;
  LinkList(const LinkList<T> &alist);  // 拷贝构造函数;
  LinkList(T a[],int n);              //用数组a构造链表
  ~LinkList();			  			   // 析构函数;
  int Length() const;				   //计算表长度,并输出;
  int Locate(T item) const;			   //定位函数：查找item在表中位置，返回序号;
  bool IsIn(T item) const;				//判断item是否在表中;
  void Insert(int i, const T &item);	//插入数据item到链表中;
  T Delete(int i);						//删除第i个元素(i>=1)，并返回被删元素的值;
  T Next(T item)const;                  //返回item的后继;
  T Prior(T item)const;                 //返回item的前驱;
  bool Empty() const;                          //判空
  bool Full()const;                            //判满
  LinkList<T>& operator=(const LinkList<T> &alist);     //重载赋值运算符
  T operator[](int i)const;				       //按位查找，返回第i个元素的值;
  void MakeEmpty();							   //将表置为空表;
  void PrintList();//打印链表

};
template<class T>
LinkList<T> Union(const LinkList<T> & A, const LinkList<T> &B);
template<class T>
LinkList<T> Intersection(const LinkList<T> & A, const LinkList<T> &B);

template<class T>
LinkList<T>::LinkList()						   // 构造函数;
{
	first = new node<T>;
	if(!first)
		cout<<"分配失败\n";
	first->next = NULL;
	cout<<"初始化成功！\n";
}
template<class T>
LinkList<T>::~LinkList()			  			   // 析构函数;
{
	node<T> *p;
	while(first != NULL)
	{
		p = first;
		first = first->next;
		delete p;
	}
	cout<<"析构函数调用成功\n";
}

//用数组a构造链表,头插法
template<class T>
 LinkList<T>::LinkList(T a[],int n)
 {
	 first = new node<T>;
	 if(!first)
		 cout<<"用数组a构造链表的空间分配失败！\n";
	 node<T> *s;
	 first->next = NULL;
	 for(int i = 0; i < n; i++)
	 {
		 s = new node<T>;
		 if(!s)
			 cout<<"新加入结点空间分配失败"<<endl;
		 else
		 {
		 s->data = a[i];
		 s->next = first->next;
		 first->next = s;
		 }
	 }

 }
 template <class T>
 void LinkList<T>::PrintList()
 {
	 node<T> *p;
	 p = first->next;
	 if(Empty())
		 cout<<"没有元素可以输出，链表为空！\n";
	 while(p)
	 {
		 cout<<p->data<<"\t";
		 p = p->next;
	 }
	 cout<<endl;
 }

template<class T>
int LinkList<T>:: Length() const				   //计算表长度,并输出;
{
	node<T> *p;
	p = first->next;
	int count = 0;
	while(p != NULL)
	{
		p = p->next;
		count++;
	}
	return count;

}

template<class T>
  int LinkList<T>::Locate(T item) const		   //定位函数：查找item在表中位置，返回序号;
  {
	  node<T> *p;
	  p = first->next;
	  int count = 1;
	  while(p)
	  {
		  if(p->data == item)
			  return count;
		  p = p->next;
		  count++;
	  }
	  return 0;
  }

  template<class T>
  bool LinkList<T>::IsIn(T item) const				//判断item是否在表中;
  {
	  node<T> *p;
	  p = first->next;
	  while(p)
	  {
		  if(p->data == item)
			  return true;
		  p = p->next;
	  }
	  return false;
  }

  template<class T>
  void LinkList<T>::Insert(int i, const T &item)	//插入数据item到链表中;
  {
	  node<T> *p,*s;
	  p = first;
	  int count = 0;
	  while(p && count < i - 1)
	  {
		  p = p->next;
		  count++;
	  }
	  if(p == NULL)
		  cout<<"插入位置不合法！插入位置必须在链表长度范围之内！\n";
	  else
	  {
		  s = new node<T>;
		  s->data = item;
		  s->next = p->next;
		  p->next = s;
	  }
  }

  template<class T>
  T LinkList<T>::Delete(int i)						//删除第i个元素(i>=1)，并返回被删元素的值;
  {
	  node<T> *p,*q;
	  int count = 0;
	  p = first;
	  while(p && count < i - 1)
	  {
		  p = p->next;
		  count++;
	  }
	  if(p == NULL)
		  return 0;
	  else
	  {
		  q = p->next;
		  T x = q->data;
		  p->next = q->next;
		  delete q;
		  return x;
	  }
  }

  template<class T>
  T LinkList<T>::Next(T item)const                 //返回item的后继;
  {
	  node<T>*p,*q;
	  p = first->next;
	  while(p && p->data != item)
	  {
		  p = p->next;
	  }
	  if(p == NULL)
	  {
		  cout<<"item不在链表中,输出0表失败\n";
		  return 0;
	  }
	  q = p->next;
	  return q->data;

  }

  template<class T>
  T LinkList<T>::Prior(T item)const                 //返回item的前驱;
  {
	  node<T> *p,*q;
	  p = first->next;
	  while(p->next&& p )
	  {
		  q = p->next;
		  if(q->data == item)
			  return p->data;
		  p = p->next;
	  }
	  cout<<"item不在链表中，输出0表失败\n";
	  return 0;
  }

  template<class T>
  bool LinkList<T>:: Empty() const                          //判空
  {
	  if(first->next == NULL)
		  return true;
	  else
		  return false;
  }
  template<class T>
  bool LinkList<T>:: Full()const                           //判满
  {
	  return false;
  }

 template<class T>
  LinkList<T>& LinkList<T>::operator=(const LinkList<T> &alist)    //重载赋值运算符
  {
	  if(first == alist.first)
	  {
		  cout<<"同一个链表，无需复制！\n";
		  return *this;
	  }
	  MakeEmpty();
	  cout<<"已清空，开始复制..\n";
	  node<T> *p,*q;
	  q = first->next;
	  p = alist.first->next;
	  for(int i = 0; i < alist.Length(); i++)
	  {
		   T x = p->data;
		   Insert(i+1,x);
		   p = p->next;
	  }
	  return *this;
  }
  template<class T>
  T LinkList<T>::operator[](int i)const			       //按位查找，返回第i个元素的值;
  {
	  node<T> *p;
	  p = first->next;
	  int count = 1;
	  while(p && count < i )
	  {
		  p = p->next;
		  count++;
	  }
	  if(p == NULL)
		  return 0;
	  else
		  return p->data;
  }

  template<class T>
  void LinkList<T>:: MakeEmpty()							   //将表置为空表;
  {
	  node<T> *p,*q;
	  p = first->next;
	  while(p)
	  {
		  q = p->next;
		  delete p;
		  p = q;
	  }
	  first->next = NULL;
  }

template<class T>
LinkList<T> Union(const LinkList<T> & A, const LinkList<T> &B) //返回集合A和B的并
{

	LinkList<T> C;
	C = B;
	int i = 1;
	T x;
	while(i < A.Length())
	{
		x = A[i];
		i++;
		if(!B.IsIn(x))
		{
			int j = B.Length()+1;
			C.Insert(j,x);
		}

	}
	return C;
}
template<class T>
LinkList<T> Intersection(const LinkList<T> & A, const LinkList<T> &B)
{
    LinkList<T> C;
    T x;
    int i = 1;
    int c = 1;
    while(i <= A.Length())
    {
        int j = i;
        i++;
        if(B.IsIn(A[j]))
        {
           C.Insert(c,A[j]);
        }
    }
    return C;

}




#endif // LINKLIST_H_INCLUDED

.cpp文件 

#ifndef LINKLIST_H_INCLUDED
#define LINKLIST_H_INCLUDED
#include <stdlib.h>
#include <iostream>

using namespace std;

template<class T> class LinkList;

//链表的结点类;
template<class T>
class node {                 //单链表的结点类;
public:
  node(const T dataval, node<T>* linkval =NULL):data(dataval),next(linkval){}
  //构造函数1：根据对已给结点数据和指针构造新结点;
  node(node<T>* linkval =NULL):next(linkval){} //构造函数2：根据对已给结点指针构造新结点;
  ~node(){}
  //template<class T>
  friend class LinkList<T>;
private:
  T data;                    //结点元素的值;
  node<T> *next;             //链表的下一个结点指针;
};

template<class T>
class LinkList{							// 有序链表类;
private:
  node<T>* first;					    // 表头指针;;;
public:
  LinkList();						   // 构造函数;
  LinkList(const LinkList<T> &alist);  // 拷贝构造函数;
  LinkList(T a[],int n);              //用数组a构造链表
  ~LinkList();			  			   // 析构函数;
  int Length() const;				   //计算表长度,并输出;
  int Locate(T item) const;			   //定位函数：查找item在表中位置，返回序号;
  bool IsIn(T item) const;				//判断item是否在表中;
  void Insert(int i, const T &item);	//插入数据item到链表中;
  T Delete(int i);						//删除第i个元素(i>=1)，并返回被删元素的值;
  T Next(T item)const;                  //返回item的后继;
  T Prior(T item)const;                 //返回item的前驱;
  bool Empty() const;                          //判空
  bool Full()const;                            //判满
  LinkList<T>& operator=(const LinkList<T> &alist);     //重载赋值运算符
  T operator[](int i)const;				       //按位查找，返回第i个元素的值;
  void MakeEmpty();							   //将表置为空表;
  void PrintList();//打印链表

};
template<class T>
LinkList<T> Union(const LinkList<T> & A, const LinkList<T> &B);
template<class T>
LinkList<T> Intersection(const LinkList<T> & A, const LinkList<T> &B);

template<class T>
LinkList<T>::LinkList()						   // 构造函数;
{
	first = new node<T>;
	if(!first)
		cout<<"分配失败\n";
	first->next = NULL;
	cout<<"初始化成功！\n";
}
template<class T>
LinkList<T>::~LinkList()			  			   // 析构函数;
{
	node<T> *p;
	while(first != NULL)
	{
		p = first;
		first = first->next;
		delete p;
	}
	cout<<"析构函数调用成功\n";
}

//用数组a构造链表,头插法
template<class T>
 LinkList<T>::LinkList(T a[],int n)
 {
	 first = new node<T>;
	 if(!first)
		 cout<<"用数组a构造链表的空间分配失败！\n";
	 node<T> *s;
	 first->next = NULL;
	 for(int i = 0; i < n; i++)
	 {
		 s = new node<T>;
		 if(!s)
			 cout<<"新加入结点空间分配失败"<<endl;
		 else
		 {
		 s->data = a[i];
		 s->next = first->next;
		 first->next = s;
		 }
	 }

 }
 template <class T>
 void LinkList<T>::PrintList()
 {
	 node<T> *p;
	 p = first->next;
	 if(Empty())
		 cout<<"没有元素可以输出，链表为空！\n";
	 while(p)
	 {
		 cout<<p->data<<"\t";
		 p = p->next;
	 }
	 cout<<endl;
 }

template<class T>
int LinkList<T>:: Length() const				   //计算表长度,并输出;
{
	node<T> *p;
	p = first->next;
	int count = 0;
	while(p != NULL)
	{
		p = p->next;
		count++;
	}
	return count;

}

template<class T>
  int LinkList<T>::Locate(T item) const		   //定位函数：查找item在表中位置，返回序号;
  {
	  node<T> *p;
	  p = first->next;
	  int count = 1;
	  while(p)
	  {
		  if(p->data == item)
			  return count;
		  p = p->next;
		  count++;
	  }
	  return 0;
  }

  template<class T>
  bool LinkList<T>::IsIn(T item) const				//判断item是否在表中;
  {
	  node<T> *p;
	  p = first->next;
	  while(p)
	  {
		  if(p->data == item)
			  return true;
		  p = p->next;
	  }
	  return false;
  }

  template<class T>
  void LinkList<T>::Insert(int i, const T &item)	//插入数据item到链表中;
  {
	  node<T> *p,*s;
	  p = first;
	  int count = 0;
	  while(p && count < i - 1)
	  {
		  p = p->next;
		  count++;
	  }
	  if(p == NULL)
		  cout<<"插入位置不合法！插入位置必须在链表长度范围之内！\n";
	  else
	  {
		  s = new node<T>;
		  s->data = item;
		  s->next = p->next;
		  p->next = s;
	  }
  }

  template<class T>
  T LinkList<T>::Delete(int i)						//删除第i个元素(i>=1)，并返回被删元素的值;
  {
	  node<T> *p,*q;
	  int count = 0;
	  p = first;
	  while(p && count < i - 1)
	  {
		  p = p->next;
		  count++;
	  }
	  if(p == NULL)
		  return 0;
	  else
	  {
		  q = p->next;
		  T x = q->data;
		  p->next = q->next;
		  delete q;
		  return x;
	  }
  }

  template<class T>
  T LinkList<T>::Next(T item)const                 //返回item的后继;
  {
	  node<T>*p,*q;
	  p = first->next;
	  while(p && p->data != item)
	  {
		  p = p->next;
	  }
	  if(p == NULL)
	  {
		  cout<<"item不在链表中,输出0表失败\n";
		  return 0;
	  }
	  q = p->next;
	  return q->data;

  }

  template<class T>
  T LinkList<T>::Prior(T item)const                 //返回item的前驱;
  {
	  node<T> *p,*q;
	  p = first->next;
	  while(p->next&& p )
	  {
		  q = p->next;
		  if(q->data == item)
			  return p->data;
		  p = p->next;
	  }
	  cout<<"item不在链表中，输出0表失败\n";
	  return 0;
  }

  template<class T>
  bool LinkList<T>:: Empty() const                          //判空
  {
	  if(first->next == NULL)
		  return true;
	  else
		  return false;
  }
  template<class T>
  bool LinkList<T>:: Full()const                           //判满
  {
	  return false;
  }

 template<class T>
  LinkList<T>& LinkList<T>::operator=(const LinkList<T> &alist)    //重载赋值运算符
  {
	  if(first == alist.first)
	  {
		  cout<<"同一个链表，无需复制！\n";
		  return *this;
	  }
	  MakeEmpty();
	  cout<<"已清空，开始复制..\n";
	  node<T> *p,*q;
	  q = first->next;
	  p = alist.first->next;
	  for(int i = 0; i < alist.Length(); i++)
	  {
		   T x = p->data;
		   Insert(i+1,x);
		   p = p->next;
	  }
	  return *this;
  }
  template<class T>
  T LinkList<T>::operator[](int i)const			       //按位查找，返回第i个元素的值;
  {
	  node<T> *p;
	  p = first->next;
	  int count = 1;
	  while(p && count < i )
	  {
		  p = p->next;
		  count++;
	  }
	  if(p == NULL)
		  return 0;
	  else
		  return p->data;
  }

  template<class T>
  void LinkList<T>:: MakeEmpty()							   //将表置为空表;
  {
	  node<T> *p,*q;
	  p = first->next;
	  while(p)
	  {
		  q = p->next;
		  delete p;
		  p = q;
	  }
	  first->next = NULL;
  }

template<class T>
LinkList<T> Union(const LinkList<T> & A, const LinkList<T> &B) //返回集合A和B的并
{

	LinkList<T> C;
	C = B;
	int i = 1;
	T x;
	while(i < A.Length())
	{
		x = A[i];
		i++;
		if(!B.IsIn(x))
		{
			int j = B.Length()+1;
			C.Insert(j,x);
		}

	}
	return C;
}
template<class T>
LinkList<T> Intersection(const LinkList<T> & A, const LinkList<T> &B)
{
    LinkList<T> C;
    T x;
    int i = 1;
    int c = 1;
    while(i <= A.Length())
    {
        int j = i;
        i++;
        if(B.IsIn(A[j]))
        {
           C.Insert(c,A[j]);
        }
    }
    return C;

}




#endif // LINKLIST_H_INCLUDED


2220728
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表基本操作
12-08
链表基本操作,是关于代码的使用，链表的基本操作，设计等操作
c语言 链表基本操作
weixin_63178060的博客
08-29 8075
当链表不为空时，则需循环遍历链表，找到链表中最后一个结点，然后将其的next域指向新节点，即cur->next=newnode，此时，不需要将新节点的next域赋值为空，因为在创建结点函数中已将next域赋值为空。在进行头插元素的时候，第一步和第二步不能进行交换，如果先进pre->next=s,此时pre->next指向了s,在进行s->next=pre->next，就会使s->next指向自己本身，无法达到预期效果。如果给定位置正常，则直接将给定位置的next指向，给定位置的next的next。...
c++链表基本操作
m0_60777643的博客
01-22 7071
单链表创建： struct linklist { int data; linklist* next; }; linklist* creat(int n) {//创建含有n个节点的链表 linklist* head; linklist* node; linklist* end; head = new linklist;//申请表头空间 end = head; head->data = n; //可以选择从表头开始存放所需数据，也可以选择独立表头； //这里选择独立表头，并且表头
python 链表基本操作
Yangcp_的博客
08-20 1708
python 链表题
C语言实现链表基本操作
qq_56066173的博客
08-20 4269
如果把数据比喻成珠子，指针就是线，链表通过指针这条线就是把数据这些珠子串起来。
链表基本操作（详解）
热门推荐
Czc1357618897的博客
11-30 1万+
链表的基本操作 这里写目录标题链表的基本操作一：单链表的基础知识二：单链表的建立头插法尾插法三：单链表的遍历四：单链表结点数目判断五：单链表的插入链表头插入任意结点插入链表尾部插入六：单链表的删除七 ：单链表的查询 一：单链表的基础知识 为什么需要链表？ 我们在使用数组存放数据是非常方便，但是由于数组的长度是固定的，所以当存储不同的元素数量时，就很容易出现问题。如果向数组中添加的数量大于数组大小时候，信息无法完全被保存。所以我们需要另一种存储方式来存储数据，其中存储的元素的个数不受限制。这种存储方式就是链
双向链表基本操作(C语言)
weixin_46503238的博客
04-29 3111
#include <stdio.h> #include <stdlib.h> #include<stdbool.h> //双向链表 typedef int Elemtype; typedef struct DNode { Elemtype data; struct DNode *prior,*next; } DNode,*DLinkList; //尾插法创建链表 DLinkList CreateList() { int x; DLin
【数据结构-C】双向循环链表基本操作及图解分析
qq_52763385的博客
02-04 4283
目录 ????双向链表介绍 ????双向链表的基本操作及图解分析 ????1.双向链表创建新的结点 ????2.双向链表初始化 ????3.双向链表的尾插 ????4.双向链表的头插 ????5.双向链表的头删 ????6.双向链表的尾删 ????7.查找某个结点并返回该节点地址 ????8.在某结点前插入一个新的结点 ????9.删除某个结点 ????10.销毁双向链表 总结 ????双向链表介绍 双向链表的结点：指针域1+数据域+指针域2 ????指针域1：指向该结点
c语言链表基本操作
weixin_42542969的博客
03-10 4690
1、链表定义 typedef struct listnode{ int n; //数据域 struct listnode*next;//指针域 }listnode; 2、链表初始化 listnode *creatlist() { listnode*head = (listnode*)malloc(sizeof(listnode)); head->next=null; return head; } 3、创建新节点 listnode *creatlistnode()
链表基本操作源码
12-28
c 语言 链表基本操作，创建 查找 删除 插入 双向链表源码
实验二 链表基本操作的实现
12-18
【实验课程名称】算法与数据结构 【实验项目名称】链表基本操作的实现
lianbiao.rar_链表基本操作_链表操作
09-24
链表的创建，删除，统计链表长度等链表的基本操作
C语言实现的链表基本操作
10-09
C语言实现的链表基本操作 C语言实现的链表基本操作 C语言实现的链表基本操作 C语言实现的链表基本操作
C语言链表基本操作.docx
最新发布
10-10
c语言链表的基本操作
链表基本操作.cpp
07-02
以下内容是我最近归纳总结的一些链表的基本操作，内容很基础，适合数据结构初学者 包括：建立空表 按序号查找 按值查找 插入结点 删除节点 参考资料：浙江大学数据结构mooc
双向链表及其基本操作
10-29
C语言，实现双向链表以及其基本操作，基本操作：链表初始化、创建、查询、删除、释放，查询和删除均有两种方式，一种是按照值，另一种是按照结点的序号。
C语言链表基本操作代码
04-23
好的，以下是C语言链表基本操作的代码示例： ```c #include #include struct Node { int data; struct Node *next; }; struct Node* create_node(int data) { struct Node* new_node = (struct Node*) ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值