数据结构（C++）——单链表

最新推荐文章于 2025-01-17 00:42:48 发布
最新推荐文章于 2025-01-17 00:42:48 发布
阅读量313 收藏 1
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_35909255/article/details/54634144
本文介绍了一个模板链表类的设计与实现，包括链表的基本操作如插入、删除、排序等，并提供了一个简单的交互式菜单来演示这些功能。

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

#include"AllHead.h"
template<class T>
class List;

template<class T>
class ListNode
{
	template<class T>
	friend class List;
private:
	T data;
	ListNode<T> *next;
public:
	ListNode(ListNode<T> *ptr = NULL){next = ptr;}              //只初始化指针域的构造函数
	ListNode(T x,ListNode<T> *ptr = NULL){data = x;next = ptr;}//初始化数据域和指针域的构造函数
};
template<class T>
class List
{
private:
	ListNode<T> *first;
	ListNode<T> *last;
	size_t   size;
public:
	List()
	{
		first = new ListNode<T>;
		last = first;
		size = 0;
	}
	~List(){makeEmpty();}
	List(ListNode<T> &L);
	Status push_back(T x);
	Status push_front(T x);
	Status IsEmpty(){return first == last?TRUE:FALSE;}
	void show_list();
	size_t getlenth(){return size;}
	T getHead_val(){return first!=last?first->next->data:NULL;}
	T getLast_val(){return first!=last?last->data:NULL;}
	ListNode<T>* getFirst(){return first;}
	void makeEmpty();
	Status pop_back();
	Status pop_front();
	void sort();
	void reverse();
	Status insert_val(T x);
	Status del_val(T x);
	ListNode<T>* find(T key);
	List& operator=(List<T> &L);
};

template<class T>
List<T>& List<T>::operator=(List<T>& L)
{
	T value;
	ListNode<T> *oldptr = L.getFirst();//获得旧的链表的头结点
	ListNode<T> *newptr = new ListNode<T>;//新开一个节点作为头结点
	first = newptr;
	while(oldptr->next != NULL)
	{
		value = oldptr->next->data;
		newptr->next = new ListNode<T>(value);
		newptr = newptr->next;
		oldptr = oldptr->next;
		newptr->next = NULL;
	}
	return *this;

}

template<class T>
Status List<T>::del_val(T x)
{
	if(IsEmpty())
	{
		cout<<"链表已空(del_val)....."<<endl;
		return ERROR;
	}
	ListNode<T> *q = first;
	ListNode<T> *h;
	size_t sizemem = size;
	while(q!= NULL)
	{
		if(q->data == x)
		{
			if(q->next == NULL)//(q == last)
	        {
				last = h;
	        }
	        h->next = q->next;
	        delete q;
	        --size;
	    	return OK;
		}
		h = q;
		q = q->next;
	}
	if(size == sizemem)
	{
		cout<<"链表中不存在该值！"<<endl;
		return ERROR;
	}
}

template<class T>
void List<T>::reverse()
{
	if(IsEmpty())
	{
		cout<<"空链表无法逆置"<<endl;
	}
	ListNode<T> *h = first->next->next;
	ListNode<T> *q = h->next;
	ListNode<T> *m = last;
	last = first->next;
	first->next->next = NULL;

	while(q!=NULL)
	{
		h->next = first->next;
		first->next = h;
		h = q;
		q = q->next;
	}
	m->next = first->next;
	first->next = m;
}
template<class T>
ListNode<T>* List<T>::find(T key)
{
	if(IsEmpty())
	{
		cout<<"链表为空。。。"<<endl;
	}
	ListNode<T> *q = first->next;
	while(q != NULL&&q->data != key)
	{
		q=q->next;
	}
	return q;
}
template<class T>
Status List<T>::insert_val(T x)/////////////////INSERT_VAL/////////////////
{
	ListNode<T> *p = new ListNode<T>;
	p->data = x;
	p->next = NULL;
	ListNode<T> *q = first->next;
	ListNode<T> *h = first;
	while(q!= NULL&&q->data<x)
	{
		h = q;
		q = q->next;
	}	
	if(q == NULL)
	{
		h->next = p;
		last = p;
	}
	else
	{
		p->next = q;
		h->next = p;
	}
	++size;
	return OK;
}

template<class T>
void List<T>::sort()///////////////////////////SORT//////////////
{
	ListNode<T> *q = first->next;
	ListNode<T> *h;
	first->next = NULL;
	last = first;
	while(q!= NULL)
	{//h和q是断开后面的指针！！！
		h = q;
		q = q->next;
	 //p和m是新的表头这边的两个指针！！！
		ListNode<T> *p = first->next;
		ListNode<T> *m = first;
		while(p!= NULL&&(p->data)<(h->data))
		{
			m = p;
			p = p->next;
		}
		if(p == NULL)
	    {
		  m->next = h;
		  h->next = NULL;
		  last = h;
	    }
		else
	    {
			h->next = p;
		    m->next = h;
	     }
	}
}
template<class T>
Status List<T>::pop_front()
{
	if(IsEmpty())
	{
		cout<<"空链表不能删除(pop_front)......"<<endl;
		return ERROR;
	}
	ListNode<T> *q = first->next;
	first->next = q->next;
	delete q;
	if(size == 1)
	{
		 last = first;
	}
	--size;
	return OK;


}
template<class T>
Status List<T>::pop_back()
{
	if(IsEmpty())
	{
		cout<<"空链表不能删除(pop_back)......"<<endl;
		return ERROR;
	}//--------以下代码有待改进----------（用一个指针）
	ListNode<T> *q = first;
	ListNode<T> *h;
	while(q->next!=NULL)
	{
		h = q;
		q=q->next;
	}
	last = h;
	h->next = NULL;
	delete q;
	--size;
	return OK;
}
template<class T>
void List<T>::makeEmpty()//清空完后要处理下first和last，注意维护好list这个类。
{
	ListNode<T> *q = first->next;
	while(q != NULL)
	{
		first->next = q->next;
		delete q;
		q = first->next;
	}
	last = first;
	size = 0;
}
template<class T>
List<T>::List(ListNode<T> &L)
{
	T value;
	ListNode<T> *oldptr = L.getFirst();//获得旧的链表的头结点
	ListNode<T> *newptr = first = new ListNode<T>;//新开一个节点作为头结点
	while(oldptr->next != NULL)
	{
		value = oldptr->next->data;
		newptr->next = ListNode<T>(value);
		newptr = newptr->next;
		oldptr = oldptr->next;
		newptr->next = NULL;
	}
}

template<class T>
Status List<T>::push_back(T x)
{
	ListNode<T> *s = new ListNode<T>;
	s->data = x;
	last->next = s;
	s->next = NULL;
	last = s;
	++size;
	return OK;

}
template<class T>
Status List<T>::push_front(T x)
{
	ListNode<T> *s = new ListNode<T>;
	s->data = x;
	s->next = first->next;
	first->next = s;
	if(size == 0)
	{
		last = s;
	}
	++size;
	return OK;
}
template<class T>
void List<T>::show_list()
{
	ListNode<T> *p = first->next;
	while(p!=NULL)
	{
		cout<<p->data<<"-->";
		p=p->next;
	}
	cout<<"NULL"<<endl;
}


#if 1
#include"list.h"
int main()
{
	List<int> myls;
	List<int> yourls;
	int select = 1;
	while(select)
	{
		cout<<"||======================================||"<<endl;
		cout<<"||==[1]push_front    [2]push_back=======||"<<endl;
		cout<<"||==[3]show_list     [4]getlenth========||"<<endl;
		cout<<"||==[5]getHead_val   [6]getLast_val=====||"<<endl;
		cout<<"||==[7]quit          [8]测试赋值 =======||"<<endl;
		cout<<"||==[9]makeEmpty     [10]pop_back=======||"<<endl;
		cout<<"||==[11]pop_front    [12]insert_val=====||"<<endl;
		cout<<"||==[13]del_val      [14]sort===========||"<<endl;
		cout<<"||==[15]reverse      [16]find_val_rid===||"<<endl;  
		cout<<"||======================================||"<<endl;
		cout<<"请输入您的选择：>";
		cin>>select;
		system("cls");
		switch(select)
		{
		case 1:
			int item_pf;
			cout<<"请输入插入的值(以-1结束)：>"<<endl;
			while(cin>>item_pf,item_pf!=-1)
			{
				myls.push_front(item_pf);
			}
			break;
		case 2:
			int item_pb;
			cout<<"请输入插入的值(以-1结束)：>"<<endl;
			while(cin>>item_pb,item_pb!=-1)
			{
				myls.push_back(item_pb);
			}
			break;
		case 3:
			myls.show_list();
			break;
		case 4:
			size_t size;
			size = myls.getlenth();
			cout<<"链表长度为："<<size<<endl;
			break;
		case 5:
			int head;
			head = myls.getHead_val();
			cout<<"该链表的第一个为："<<head<<endl;
			break;
		case 6:
			int last;
			last = myls.getLast_val();
			cout<<"该链表的最后一个值为："<<last<<endl;
			break;
		case 7:
			exit(1);
			break;
		case 8:
			cout<<"即将为您拷贝..."<<endl;
			yourls = myls;
			cout<<"为您打印拷贝过来的内容：";
	    	yourls.show_list();
			break;
		case 9:
			myls.makeEmpty();
			break;
		case 10:
			myls.pop_back();
			break;
		case 11:
			myls.pop_front();
			break;
		case 12:
			int val_insert;
			cout<<"请输入您要插入的值：>";
			cin>>val_insert;
			myls.insert_val(val_insert);
			break;
		case 13:
			int val_del;
			cout<<"请输入您要删除的值：>";
			cin>>val_del;
			myls.del_val(val_del);
			break;
		case 14:
			myls.sort();
			break;
		case 15:
			myls.reverse();
			break;
		case 16:
			ListNode<int> *key;
			int key_find;
			cout<<"请输入您要查找的值；>";
			cin>>key_find;
			key = myls.find(key_find);
			if(key != NULL)
				cout<<"找到啦-->"<<key<<endl;
			else
				cout<<"没找到..."<<endl;
			break;
		}

	}
	return 0;

}
#endif






                

        

    

    
  



    



                



	

		

			

				
					
c/c++ 数据结构 单链表

				
			

			

				

					2301_78564545的博客
				

				

					06-21
					
					732
					
				

			

		

		

			
				
创建方法二：依然是头插法，但是在赋值时将数组最后一个元素赋值给第一个创建的节点（创建完后是最后一个），将数组倒数第二个元素赋值给第二个创建的节点（创建完后是倒数第二个节点），以此类推。单链表的销毁：从头节点开始依次往后释放各个节点的内存，剩最后一个节点时退出循环，再将其free();求单链表的长度：每循环一次count+1，直到p为最后一个节点，返回count。根据单链表的元素值求索引：当索引小于单链表长度且存在该元素才返回，否则返回-1。根据单链表的索引取值：索引有效才为真，否则为假。

			
		

	



                

            
              



	

		

			

				
					
数据结构C++——单链表习题1

				
			

			

				

					weixin_52114591的博客
				

				

					05-23
					
					2195
					
				

			

		

		

			
				
针对带附加头节点的单链表，试编写下列函数。

定位函数Locate:在单链表中寻找第i个结点。若找到，则函数返回第i个结点的地址；若找不到，则函数返回NULL。
	求最大值函数max:通过一趟遍历在单链表中确定值最大的结点。
	统计函数number:统计单链z表中具有给定值x的所有元素。
	建立create：根据一维数组a[ n]建立一个单链表，使单链表中各元素的次序与a[ n]中各元素的次序相同，要求该程序的时间复杂性为O（n）。
	整理函数tidyup:在非递减有序的单链表中删除值相同的多余结点。

#

			
		

	



              


  
              

                


	

		

			

				
					
数据结构（C++）实现单链表

				
			

			

				

					qq_43656233的博客
				

				

					09-18
					
					765
					
				

			

		

		

			
				
#include<iostream>
using namespace std;
template<class T>
struct Node
{
	T data;
	Node<T>* next;
};
template<class T>
class Linklist
{
	Node<T>* first;
public:
	Linklist(...

			
		

	





	

		

			

				
					
数据结构单链表C++实现

				
			

			

				

					weixin_46396711的博客
				

				

					06-08
					
					735
					
				

			

		

		

			
				
单链表简单介绍
单链表是线性表的一种，其逻辑结构为线性结构，采用链式存储结构，不同于顺序表既能顺序存取又可随机存取，单链表只能顺序存取。优点是添加和删除元素方便，时间复杂度为O(1)，缺点是查找元素比较麻烦，需从头指针开始遍历，时间复杂度为O(n)。
单链表数据结构

typedef struct pe{ string name; string sex; int age; bool operator ==(const pe &p)//重载==运算符 { return(p.name==name&amp

			
		

	



		

			
		



	

		

			

				
					
数据结构之线性表

				
			

			

				

					CCDreamOldBoys的专栏
				

				

					10-05
					
					428
					
				

			

		

		

			
				
一、循顺序存储


#ifndef  __MY_SEQLIST_H__ 
#define __MY_SEQLIST_H__

typedef void SeqList;
typedef void SeqListNode;


SeqList* SeqList_Create(int capacity);

int  SeqList_Create01(SeqList **handle, int 

			
		

	





	

		

			

				
					
数据结构之单链表（C++）

				
			

			

				

					Fay
				

				

					05-04
					
					647
					
				

			

		

		

			
				
#ifndef LIST_H
#define LIST_H

/************************************************************************/
/* C++实现单链表                                                         
/************************

			
		

	





	

		

			

				
					
C++——单链表的详细讲解

				
			

			

				

					imaima666的博客
				

				

					05-16
					
					1677
					
				

			

		

		

			
				
链表是一种数据结构，由一系列节点组成，每个节点包含数据和指向下一个节点的指针。链表中的节点可以在内存中不连续地存储，通过指针来连接彼此。链表可以是单向链表，双向链表或循环链表。链表的优点是可以动态地分配内存空间，插入和删除操作效率高，但查找操作效率较低。

			
		

	





	

		

			

				
					
数据结构——单链表基本操作实现 (c++)

				
			

			

				

					weixin_74794504的博客
				

				

					03-16
					
					3252
					
				

			

		

		

			
				
单链表链式存储结构的特点是：用一组任意的存储单元存储线性表的数据元素（这里存储单元可以是连续的，也可以是不连续的），为了表示每个数据元素a与其直接后继数据元素之间的逻辑关系，除了存储信息本身外还要存储一个指示其直接后继的信息（地址）.这两部分信息组成数据元素a的存储映像称为结点，它包括两个域：存储信息的称为数据域，存储直接后继存储地址的域称为指针域，指针域中存储的信息称作指针或链。

			
		

	





	

		

			

				
					
C C++数据结构（二） —— 单链表_数据结构空的单链表怎么画

					
最新发布

				
			

			

				

					2501_90257082的博客
				

				

					01-17
					
					737
					
				

			

		

		

			
				
📝 代码示例
从这个结构定义中，我们也就知道，结点由 存放数据元素的数据域 和 存放后继结点地址的指针域 组成。假设 p 是指向线性表第 i 个元素的指针，则该结点aia_iai​ 的数据域我们可以用 p->data 来表示，p->data 的值是一个数据元素，结点aia_iai​ 的指针域可以用 p->next 来表示，p->next 的值是一个指针。p->next 指向谁呢？当然是指向第i1i+1i+1 个元素，即指向ai1a_{i+1}ai+1​ 的指针。也就是说，如果 p->data 等于 a，那

			
		

	





	

		

			

				
					
数据结构实验——单链表

				
			

			

				

					02-12
				

			

		

		

			
				
在带头结点的单链表h中第i个数据元素之前插入一个数据元素x ，首先需要在单链表中寻找到第i-1个结点并用指针p指示，然后申请一个由指针s 指示的结点空间，并置x为其数据域值，最后修改第i-1个结点，并使x结点的指针...

			
		

	





	

		

			

				
					
数据结构单链表C++语言的实现

				
			

			

				

					04-20
				

			

		

		

			
				
数据结构中单链表的实现，包括两个链表的合并，求交集，求并集，增加，删除，插入功能

			
		

	





	

		

			

				
					
数据结构单链表的基本操作及实现(C/C++)

				
			

			

				

					06-03
				

			

		

		

			
				
数据结构单链表的基本操作及实现(C/C++)，包括初始化、创建链表、插入元素、删除元素、获取指定位置的元素等

			
		

	





	

		

			

				
					
数据结构C++链表

				
			

			

				

					03-04
				

			

		

		

			
				
基于C++的数据结构单链表，带主程序可运行，使用头文件可直接编程。

			
		

	





	

		

			

				
					
C++数据结构——单链表

				
			

			

				

					m0_56728976的博客
				

				

					05-13
					
					287
					
				

			

		

		

			
				
@C++数据结构——单链表
C++数据结构——单链表
代码
版本一：
#include <iostream>
using namespace std;


template<class T>
struct Node
{
    T data;
    Node<T>* next;

    Node()
    {
        next = nullptr;
    }
    explicit Node(T item, Node<T>* ptr = nu

			
		

	





	

		

			

				
					
数据结构之单链表(C++版)

				
			

			

				

					diaoe3953的博客
				

				

					11-04
					
					186
					
				

			

		

		

			
				
#include <iostream>#include <stdlib.h>using namespace std; typedef string ElemType;typedef struct LNode{	ElemType data;  //数据域	struct LNode *next;  //指针域}LNode, *SLink;
void InitList...

			
		

	





	

		

			

				
					
数据结构---单链表（C++实现）

				
			

			

				

					江城的博客
				

				

					06-20
					
					5336
					
				

			

		

		

			
				
单链表



线性表由于在内存上顺序存储，在插入和删除元素时效率很低。单链表通过链式存储，适用于插入和删除频繁，储存空间不定的情形。

单链表的一个存储结点（node）包括两个部分：数据域（data）和指针域（link） 
数据域：存储线性表的一个数据元素 
指针域：存储下一个节点的首地址 



只能通过头指针(pHead)进行操作：链表的第一个结点的地址可以通过链表的头指针找到，但是其他结点的...

			
		

	





	

		

			

				
					
数据结构----单链表（C++实现）

				
			

			

				

					WYJ的博客
				

				

					03-17
					
					2817
					
				

			

		

		

			
				
111



			
		

	





	

		

			

				
					
数据结构：C++实现单链表

				
			

			

				

					weixin_46191137的博客
				

				

					04-29
					
					127
					
				

			

		

		

			
				
c++单链表
#include<bits/stdc++.h>//单链表
using namespace std;

struct Node
{
    int data;
    Node *next;
};
typedef Node* NODE;
NODE p,head,tail;
int n;

void out()//输出函数
{
    p=head->next;
    while(p->next!=NULL)
    {
        cout<<p-&gt

			
		

	





	

		

			

				
					
[C++]数据结构之单链表

				
			

			

				

					aaab789456123的博客
				

				

					01-31
					
					477
					
				

			

		

		

			
				
C++ 数据结构之单链表

			
		

	





	

		

			

				
					
多项式相加算法实现及数据结构——单链表解析

				
			

			

				

					
				

			

		

		

			
				
"两个多项式的相加算法-数据结构课件"  在数据结构中，多项式是一种常见的数学概念，它可以通过链表结构来有效地表示和处理。这篇课件主要讲解了如何实现两个多项式的相加算法，这个算法是基于链表的数据结构设计的...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值