线性表的链式存储及其接口函数C++类实现

最新推荐文章于 2021-09-17 00:12:17 发布
转载 最新推荐文章于 2021-09-17 00:12:17 发布 · 915 阅读 · 0

本文详细介绍了链式存储结构实现线性表的基本操作，包括插入、删除、获取长度、获取容量等，并提供了完整的C++代码实现。通过实例演示了如何使用链表进行数据管理。

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


http://blog.youkuaiyun.com/hongkangwl/article/details/21883231

首先通过结构体建立每个节点

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. <span style="font-size: 18px;"> struct node //链表节点  
  2. {  
  3.     node* ptrnext;  
  4.     int data;  
  5.   
  6. };</span>  
<span style="font-size: 18px;"> struct node	//链表节点
{
	node* ptrnext;
	int data;

};</span>
在线性表的类中，定义了一些对线性表的常用操作

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. <span style="font-size: 18px;">class linklist //链表类  
  2. {  
  3. private:  
  4.     static int length; //链表长度  
  5.     static int capacity;//链表容量  
  6.   
  7. public:  
  8.     node* ptr_node;//节点指针  
  9.     node* rootnode;//链表根节点，没有元素，指向position为0的节点  
  10.     linklist()//构造函数  
  11.     {  
  12.         length = 0;  
  13.         capacity = 0;  
  14.         ptr_node = NULL;  
  15.         rootnode->ptrnext = NULL;  
  16.     }  
  17.     linklist(int capacity_num)//带参数的构造函数  
  18.     {  
  19.         capacity = capacity_num;  
  20.         length = 0;  
  21.         ptr_node = NULL;  
  22.         rootnode = new node;  
  23.         rootnode->ptrnext = NULL;  
  24.     }  
  25.       
  26.     int linklist_insert(linklist* ptr,int pos,int member);//插入元素  
  27.     int linklist_erase(linklist* ptr,int  pos);//删除元素  
  28.     int linklist_getlength(linklist* ptr);//获取链表长度  
  29.     int linklist_getcapacity(linklist* ptr);//获取链表容量  
  30.     void linklist_display(linklist* ptr);//顺序输出链表中的每个元素  
  31.     void linklist_increaselength(linklist* ptr);//增加元素的个数  
  32.     void linklist_decreaselength(linklist* ptr);//减少元素的个数  
  33.     int linklist_getmember(linklist* ptr,int pos);//获取某位置上的元素  
  34.   
  35.     ~linklist()//析构函数  
  36.     {  
  37.       
  38.     }     
  39. };</span>  
<span style="font-size: 18px;">class linklist //链表类
{
private:
	static int length; //链表长度
	static int capacity;//链表容量

public:
	node* ptr_node;//节点指针
	node* rootnode;//链表根节点，没有元素，指向position为0的节点
	linklist()//构造函数
	{
		length = 0;
		capacity = 0;
		ptr_node = NULL;
		rootnode->ptrnext = NULL;
	}
	linklist(int capacity_num)//带参数的构造函数
	{
		capacity = capacity_num;
		length = 0;
		ptr_node = NULL;
		rootnode = new node;
		rootnode->ptrnext = NULL;
	}
	
	int linklist_insert(linklist* ptr,int pos,int member);//插入元素
	int linklist_erase(linklist* ptr,int  pos);//删除元素
	int linklist_getlength(linklist* ptr);//获取链表长度
	int linklist_getcapacity(linklist* ptr);//获取链表容量
	void linklist_display(linklist* ptr);//顺序输出链表中的每个元素
	void linklist_increaselength(linklist* ptr);//增加元素的个数
	void linklist_decreaselength(linklist* ptr);//减少元素的个数
	int linklist_getmember(linklist* ptr,int pos);//获取某位置上的元素

	~linklist()//析构函数
	{
	
	}	
};</span>

每次最难的就是插入，插入的是第一个和最后一个时比较麻烦

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. <span style="font-size: 18px;">int linklist::linklist_insert(linklist* ptr,int pos,int member)  
  2. {     
  3.     if(ptr->linklist_getlength(ptr) == ptr->linklist_getcapacity(ptr))//链表已满  
  4.     {  
  5.         cout<<"超出链表的容量"<<endl;  
  6.         return -1;  
  7.     }  
  8.     if(pos > linklist::linklist_getcapacity(ptr) - 1)//位置在链表之外  
  9.     {  
  10.         cout<<"位置超出链表的尾巴"<<endl;  
  11.         return -1;  
  12.     }  
  13.     else  
  14.     {  
  15.         if(rootnode->ptrnext == NULL) //空链表的  
  16.         {  
  17.             ptr_node = new node;  
  18.             ptr_node->data = member;  
  19.             ptr_node->ptrnext = NULL;  
  20.             rootnode->ptrnext = ptr_node;  
  21.             ptr->linklist_increaselength(ptr);  
  22.         }  
  23.         else    //在中间插入  
  24.             if(ptr->linklist_getlength(ptr) - 1 < pos)  
  25.             {  
  26.                 node* current;  
  27.                 node* next;  
  28.                 current = rootnode;  
  29.                 next = current->ptrnext;  
  30.                 ptr_node = new node;  
  31.                 ptr_node->data = member;  
  32.                 ptr_node->ptrnext = NULL;  
  33.                 for(int i = 0; i < ptr->linklist_getlength(ptr) ; i++)  
  34.                 {  
  35.                     current = next;  
  36.                     next = current->ptrnext;  
  37.                 }  
  38.                 current->ptrnext = ptr_node;  
  39.                 ptr->linklist_increaselength(ptr);  
  40.                 return 0;  
  41.             }  
  42.             else if(pos == 0) //空链表，貌似跟上面的重复了，额，不影响运行  
  43.             {  
  44.                 ptr_node = new node;  
  45.                 ptr_node->data = member;  
  46.                 ptr_node->ptrnext = rootnode->ptrnext;  
  47.                 rootnode->ptrnext = ptr_node;  
  48.                 ptr->linklist_increaselength(ptr);  
  49.                 return 0;  
  50.             }  
  51.             else  
  52.             {  
  53.                 node* current;  
  54.                 node* next;  
  55.                 current = rootnode;  
  56.                 ptr_node = new node;  
  57.                 ptr_node->data = member;  
  58.                 next = current->ptrnext;  
  59.                 for(int i = 0; i < pos; i++)  
  60.                 {  
  61.                     current = next;  
  62.                     next = next->ptrnext;  
  63.                 }  
  64.                 ptr_node->ptrnext = current->ptrnext;  
  65.                 current->ptrnext = ptr_node;  
  66.                 ptr->linklist_increaselength(ptr);  
  67.                 return 0;  
  68.             }  
  69.               
  70.     }  
  71.       
  72. }</span>  
<span style="font-size: 18px;">int linklist::linklist_insert(linklist* ptr,int pos,int member)
{	
	if(ptr->linklist_getlength(ptr) == ptr->linklist_getcapacity(ptr))//链表已满
	{
		cout<<"超出链表的容量"<<endl;
		return -1;
	}
	if(pos > linklist::linklist_getcapacity(ptr) - 1)//位置在链表之外
	{
		cout<<"位置超出链表的尾巴"<<endl;
		return -1;
	}
	else
	{
		if(rootnode->ptrnext == NULL) //空链表的
		{
			ptr_node = new node;
			ptr_node->data = member;
			ptr_node->ptrnext = NULL;
			rootnode->ptrnext = ptr_node;
			ptr->linklist_increaselength(ptr);
		}
		else    //在中间插入
			if(ptr->linklist_getlength(ptr) - 1 < pos)
			{
				node* current;
				node* next;
				current = rootnode;
				next = current->ptrnext;
				ptr_node = new node;
				ptr_node->data = member;
				ptr_node->ptrnext = NULL;
				for(int i = 0; i < ptr->linklist_getlength(ptr) ; i++)
				{
					current = next;
					next = current->ptrnext;
				}
				current->ptrnext = ptr_node;
				ptr->linklist_increaselength(ptr);
				return 0;
			}
			else if(pos == 0) //空链表，貌似跟上面的重复了，额，不影响运行
			{
				ptr_node = new node;
				ptr_node->data = member;
				ptr_node->ptrnext = rootnode->ptrnext;
				rootnode->ptrnext = ptr_node;
				ptr->linklist_increaselength(ptr);
				return 0;
			}
			else
			{
				node* current;
				node* next;
				current = rootnode;
				ptr_node = new node;
				ptr_node->data = member;
			    next = current->ptrnext;
				for(int i = 0; i < pos; i++)
				{
					current = next;
					next = next->ptrnext;
				}
				ptr_node->ptrnext = current->ptrnext;
				current->ptrnext = ptr_node;
				ptr->linklist_increaselength(ptr);
				return 0;
			}
			
	}
	
}</span>
之后就是删除了

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. int linklist::linklist_erase(linklist* ptr,int pos)  
  2. {  
  3.     node* current = rootnode;  
  4.     node* next = current->ptrnext;  
  5.     if(pos > ptr->linklist_getlength(ptr))//位置在链表之外  
  6.     {  
  7.         cout<<"oop!!该位置没有元素"<<endl;  
  8.         return -1;  
  9.     }  
  10.     else  
  11.     {  
  12.         for(int i = 0; i < pos; i++)  
  13.         {  
  14.             current = next;  
  15.             next = current->ptrnext;  
  16.         }  
  17.   
  18.         current->ptrnext = next->ptrnext;  
  19.         ptr->linklist_decreaselength(ptr);  
  20.     }  
  21. }  
int linklist::linklist_erase(linklist* ptr,int pos)
{
	node* current = rootnode;
	node* next = current->ptrnext;
	if(pos > ptr->linklist_getlength(ptr))//位置在链表之外
	{
		cout<<"oop!!该位置没有元素"<<endl;
		return -1;
	}
	else
	{
		for(int i = 0; i < pos; i++)
		{
			current = next;
			next = current->ptrnext;
		}

		current->ptrnext = next->ptrnext;
		ptr->linklist_decreaselength(ptr);
	}
}

删除比插入简单多了。。。

线性表的链式存储具体实现和完整测试代码如下：

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. #include<iostream>  
  2. using namespace std;  
  3.  struct node    //链表节点  
  4. {  
  5.     node* ptrnext;  
  6.     int data;  
  7.   
  8. };  
  9. class linklist //链表类  
  10. {  
  11. private:  
  12.     static int length; //链表长度  
  13.     static int capacity;//链表容量  
  14.   
  15. public:  
  16.     node* ptr_node;//节点指针  
  17.     node* rootnode;//链表根节点，没有元素，指向position为0的节点  
  18.     linklist()//构造函数  
  19.     {  
  20.         length = 0;  
  21.         capacity = 0;  
  22.         ptr_node = NULL;  
  23.         rootnode->ptrnext = NULL;  
  24.     }  
  25.     linklist(int capacity_num)//带参数的构造函数  
  26.     {  
  27.         capacity = capacity_num;  
  28.         length = 0;  
  29.         ptr_node = NULL;  
  30.         rootnode = new node;  
  31.         rootnode->ptrnext = NULL;  
  32.     }  
  33.       
  34.     int linklist_insert(linklist* ptr,int pos,int member);//插入元素  
  35.     int linklist_erase(linklist* ptr,int  pos);//删除元素  
  36.     int linklist_getlength(linklist* ptr);//获取链表长度  
  37.     int linklist_getcapacity(linklist* ptr);//获取链表容量  
  38.     void linklist_display(linklist* ptr);//顺序输出链表中的每个元素  
  39.     void linklist_increaselength(linklist* ptr);//增加元素的个数  
  40.     void linklist_decreaselength(linklist* ptr);//减少元素的个数  
  41.     int linklist_getmember(linklist* ptr,int pos);//获取某位置上的元素  
  42.   
  43.     ~linklist()//析构函数  
  44.     {  
  45.       
  46.     }     
  47. };  
  48. int linklist::length = 0;  
  49. int linklist::capacity = 0;  
  50. int linklist::linklist_getmember(linklist* ptr,int pos)  
  51. {  
  52.     node* current = rootnode;  
  53.     node* next = current->ptrnext;  
  54.     for(int i = 0; i < pos; i++)  
  55.     {  
  56.         current = next;//循环迭代  
  57.         next = current->ptrnext;  
  58.     }  
  59.     return next->data;  
  60. }  
  61. void linklist::linklist_decreaselength(linklist *ptr)  
  62. {  
  63.     ptr->length--;  
  64. }  
  65. int linklist::linklist_erase(linklist* ptr,int pos)  
  66. {  
  67.     node* current = rootnode;  
  68.     node* next = current->ptrnext;  
  69.     if(pos > ptr->linklist_getlength(ptr))//位置在链表之外  
  70.     {  
  71.         cout<<"oop!!该位置没有元素"<<endl;  
  72.         return -1;  
  73.     }  
  74.     else  
  75.     {  
  76.         for(int i = 0; i < pos; i++)  
  77.         {  
  78.             current = next;  
  79.             next = current->ptrnext;  
  80.         }  
  81.   
  82.         current->ptrnext = next->ptrnext;  
  83.         ptr->linklist_decreaselength(ptr);  
  84.     }  
  85. }  
  86. int linklist::linklist_getcapacity(linklist *ptr)  
  87. {  
  88.     return ptr->capacity;  
  89. }  
  90. void linklist::linklist_increaselength(linklist* ptr)  
  91. {  
  92.     ptr->length++;  
  93. }  
  94. int linklist::linklist_getlength(linklist* ptr)  
  95. {  
  96.     return ptr->length;  
  97. }  
  98. void linklist::linklist_display(linklist* ptr)//输出每个元素  
  99. {  
  100.     node *current;  
  101.     current = rootnode;  
  102.     node* next;  
  103.     next = current->ptrnext;  
  104.     for(int i = 0; i< ptr->linklist_getlength(ptr); i++)  
  105.     {  
  106.         cout<<current->ptrnext->data<<" ";  
  107.         current = next;  
  108.         next = current->ptrnext;  
  109.           
  110.     }  
  111.     cout<<endl;  
  112. }  
  113. int linklist::linklist_insert(linklist* ptr,int pos,int member)  
  114. {     
  115.     if(ptr->linklist_getlength(ptr) == ptr->linklist_getcapacity(ptr))//链表已满  
  116.     {  
  117.         cout<<"超出链表的容量"<<endl;  
  118.         return -1;  
  119.     }  
  120.     if(pos > linklist::linklist_getcapacity(ptr) - 1)//位置在链表之外  
  121.     {  
  122.         cout<<"位置超出链表的尾巴"<<endl;  
  123.         return -1;  
  124.     }  
  125.     else  
  126.     {  
  127.         if(rootnode->ptrnext == NULL) //空链表的  
  128.         {  
  129.             ptr_node = new node;  
  130.             ptr_node->data = member;  
  131.             ptr_node->ptrnext = NULL;  
  132.             rootnode->ptrnext = ptr_node;  
  133.             ptr->linklist_increaselength(ptr);  
  134.         }  
  135.         else    //在中间插入  
  136.             if(ptr->linklist_getlength(ptr) - 1 < pos)  
  137.             {  
  138.                 node* current;  
  139.                 node* next;  
  140.                 current = rootnode;  
  141.                 next = current->ptrnext;  
  142.                 ptr_node = new node;  
  143.                 ptr_node->data = member;  
  144.                 ptr_node->ptrnext = NULL;  
  145.                 for(int i = 0; i < ptr->linklist_getlength(ptr) ; i++)  
  146.                 {  
  147.                     current = next;  
  148.                     next = current->ptrnext;  
  149.                 }  
  150.                 current->ptrnext = ptr_node;  
  151.                 ptr->linklist_increaselength(ptr);  
  152.                 return 0;  
  153.             }  
  154.             else if(pos == 0) //空链表，貌似跟上面的重复了，额，不影响运行  
  155.             {  
  156.                 ptr_node = new node;  
  157.                 ptr_node->data = member;  
  158.                 ptr_node->ptrnext = rootnode->ptrnext;  
  159.                 rootnode->ptrnext = ptr_node;  
  160.                 ptr->linklist_increaselength(ptr);  
  161.                 return 0;  
  162.             }  
  163.             else  
  164.             {  
  165.                 node* current;  
  166.                 node* next;  
  167.                 current = rootnode;  
  168.                 ptr_node = new node;  
  169.                 ptr_node->data = member;  
  170.                 next = current->ptrnext;  
  171.                 for(int i = 0; i < pos; i++)  
  172.                 {  
  173.                     current = next;  
  174.                     next = next->ptrnext;  
  175.                 }  
  176.                 ptr_node->ptrnext = current->ptrnext;  
  177.                 current->ptrnext = ptr_node;  
  178.                 ptr->linklist_increaselength(ptr);  
  179.                 return 0;  
  180.             }  
  181.               
  182.     }  
  183.       
  184. }  
  185. int main()  
  186. {  
  187.     int num;  
  188.     cout<<"链表的容量是多少"<<endl;  
  189.     cin>>num;  
  190.     linklist* LinkList = new linklist(num);  
  191.     int n;  
  192.     cout<<"你想要在链表中放入多少元素"<<endl;  
  193.     cin>>n;  
  194.     int* ptrint = new int[n];  
  195.     for(int i = 0; i < n; i++)  
  196.     {  
  197.         cin>>ptrint[i];  
  198.     }  
  199.     for(int i = 0; i < n; i++)  
  200.     {  
  201.         LinkList->linklist_insert(LinkList,i,ptrint[i]);  
  202.     }  
  203.     cout<<"链表中元素是："<<endl;  
  204.     LinkList->linklist_display(LinkList);  
  205.     LinkList->linklist_erase(LinkList,3);  
  206.     cout<<"删除位置是3（即第4个）的元素后，链表中元素是："<<endl;  
  207.     LinkList->linklist_display(LinkList);  
  208.     cout<<"位置为2（即第3个）的元素是："<<endl;  
  209.     cout<<LinkList->linklist_getmember(LinkList,2);  
  210.       
  211.       
  212.     return 0;  
  213. }  
#include<iostream>
using namespace std;
 struct node	//链表节点
{
	node* ptrnext;
	int data;

};
class linklist //链表类
{
private:
	static int length; //链表长度
	static int capacity;//链表容量

public:
	node* ptr_node;//节点指针
	node* rootnode;//链表根节点，没有元素，指向position为0的节点
	linklist()//构造函数
	{
		length = 0;
		capacity = 0;
		ptr_node = NULL;
		rootnode->ptrnext = NULL;
	}
	linklist(int capacity_num)//带参数的构造函数
	{
		capacity = capacity_num;
		length = 0;
		ptr_node = NULL;
		rootnode = new node;
		rootnode->ptrnext = NULL;
	}
	
	int linklist_insert(linklist* ptr,int pos,int member);//插入元素
	int linklist_erase(linklist* ptr,int  pos);//删除元素
	int linklist_getlength(linklist* ptr);//获取链表长度
	int linklist_getcapacity(linklist* ptr);//获取链表容量
	void linklist_display(linklist* ptr);//顺序输出链表中的每个元素
	void linklist_increaselength(linklist* ptr);//增加元素的个数
	void linklist_decreaselength(linklist* ptr);//减少元素的个数
	int linklist_getmember(linklist* ptr,int pos);//获取某位置上的元素

	~linklist()//析构函数
	{
	
	}	
};
int linklist::length = 0;
int linklist::capacity = 0;
int linklist::linklist_getmember(linklist* ptr,int pos)
{
	node* current = rootnode;
	node* next = current->ptrnext;
	for(int i = 0; i < pos; i++)
	{
		current = next;//循环迭代
		next = current->ptrnext;
	}
	return next->data;
}
void linklist::linklist_decreaselength(linklist *ptr)
{
	ptr->length--;
}
int linklist::linklist_erase(linklist* ptr,int pos)
{
	node* current = rootnode;
	node* next = current->ptrnext;
	if(pos > ptr->linklist_getlength(ptr))//位置在链表之外
	{
		cout<<"oop!!该位置没有元素"<<endl;
		return -1;
	}
	else
	{
		for(int i = 0; i < pos; i++)
		{
			current = next;
			next = current->ptrnext;
		}

		current->ptrnext = next->ptrnext;
		ptr->linklist_decreaselength(ptr);
	}
}
int linklist::linklist_getcapacity(linklist *ptr)
{
	return ptr->capacity;
}
void linklist::linklist_increaselength(linklist* ptr)
{
	ptr->length++;
}
int linklist::linklist_getlength(linklist* ptr)
{
	return ptr->length;
}
void linklist::linklist_display(linklist* ptr)//输出每个元素
{
	node *current;
	current = rootnode;
	node* next;
	next = current->ptrnext;
	for(int i = 0; i< ptr->linklist_getlength(ptr); i++)
	{
		cout<<current->ptrnext->data<<" ";
		current = next;
		next = current->ptrnext;
		
	}
	cout<<endl;
}
int linklist::linklist_insert(linklist* ptr,int pos,int member)
{	
	if(ptr->linklist_getlength(ptr) == ptr->linklist_getcapacity(ptr))//链表已满
	{
		cout<<"超出链表的容量"<<endl;
		return -1;
	}
	if(pos > linklist::linklist_getcapacity(ptr) - 1)//位置在链表之外
	{
		cout<<"位置超出链表的尾巴"<<endl;
		return -1;
	}
	else
	{
		if(rootnode->ptrnext == NULL) //空链表的
		{
			ptr_node = new node;
			ptr_node->data = member;
			ptr_node->ptrnext = NULL;
			rootnode->ptrnext = ptr_node;
			ptr->linklist_increaselength(ptr);
		}
		else    //在中间插入
			if(ptr->linklist_getlength(ptr) - 1 < pos)
			{
				node* current;
				node* next;
				current = rootnode;
				next = current->ptrnext;
				ptr_node = new node;
				ptr_node->data = member;
				ptr_node->ptrnext = NULL;
				for(int i = 0; i < ptr->linklist_getlength(ptr) ; i++)
				{
					current = next;
					next = current->ptrnext;
				}
				current->ptrnext = ptr_node;
				ptr->linklist_increaselength(ptr);
				return 0;
			}
			else if(pos == 0) //空链表，貌似跟上面的重复了，额，不影响运行
			{
				ptr_node = new node;
				ptr_node->data = member;
				ptr_node->ptrnext = rootnode->ptrnext;
				rootnode->ptrnext = ptr_node;
				ptr->linklist_increaselength(ptr);
				return 0;
			}
			else
			{
				node* current;
				node* next;
				current = rootnode;
				ptr_node = new node;
				ptr_node->data = member;
			    next = current->ptrnext;
				for(int i = 0; i < pos; i++)
				{
					current = next;
					next = next->ptrnext;
				}
				ptr_node->ptrnext = current->ptrnext;
				current->ptrnext = ptr_node;
				ptr->linklist_increaselength(ptr);
				return 0;
			}
			
	}
	
}
int main()
{
	int num;
	cout<<"链表的容量是多少"<<endl;
	cin>>num;
	linklist* LinkList = new linklist(num);
	int n;
	cout<<"你想要在链表中放入多少元素"<<endl;
	cin>>n;
	int* ptrint = new int[n];
	for(int i = 0; i < n; i++)
	{
		cin>>ptrint[i];
	}
	for(int i = 0; i < n; i++)
	{
		LinkList->linklist_insert(LinkList,i,ptrint[i]);
	}
	cout<<"链表中元素是："<<endl;
	LinkList->linklist_display(LinkList);
	LinkList->linklist_erase(LinkList,3);
    cout<<"删除位置是3（即第4个）的元素后，链表中元素是："<<endl;
	LinkList->linklist_display(LinkList);
	cout<<"位置为2（即第3个）的元素是："<<endl;
	cout<<LinkList->linklist_getmember(LinkList,2);
	
	
	return 0;
}

测试结果如下：


用C++实现线性表的链式存储结构
m0_70940447的博客
06-09 313
C++实现线性表的链式存储
C++实现数据结构链式线性表的基本操作
weixin_53391750的博客
11-16 813
#include <iostream> using namespace std; typedef int ElemType; typedef struct Node{ ElemType e; struct Node * next; }Node,*LinkList; void initList(LinkList &L){ L = new Node; L->next = NULL; } //插入 void insert...
C++ 链式线性表 类方式实现
07-29
C++ 链式线性表，以类的方式实现
数据接口线性表C++实现
a363344923的专栏
12-07 519
#include #include using namespace std; const int list_init_size = 100; const int listincrement = 10; template class list_sq { public: bool InitList(); //构造一个空的线性表 void DestroyList(
线性表链式存储结构算法C++实现
dubin_0820的博客
05-23 441
单链表 链表的实现算法中有两个重点：插入、删除 插入 从头结点开始，通过current指针定位到目标位置 从堆空间申请新的Node结点 核心逻辑： node->value = e; node->next = current->next; current->next = node; 删除 从头结点开始，通过current指定位置到目标位置 使用toDel指针指向需要删除结点 核心逻辑： toDel = current->next; current->next =
线性表链式存储C++实现
YYC的专栏
03-24 2021
#include"LsList.h" #include #include #include using  namespace std; #pragma once template class LsList { public: class LNode{ public:   T data;//数据域 LNode * next;//指针域 ~LNode()
线性表的链式存储结构c++模板类实现
06-20
在提供的C++代码中，实现了一个基于链式存储的线性表类`reacl`，使用了模板（template）以支持不同数据类型的元素。模板类使得这个线性表可以用于存储整型、浮点型等任意类型的数据。 类`reacl`包含以下成员函数： ...
C++实现线性表的链式存储及其操作详解
本文档详细探讨了使用C++语言实现线性表的链式存储结构，并包含了该数据结构的基本操作：插入、删除、查找等。 链式存储结构是一种使用指针链接各个存储单元的数据结构形式，其每个元素（结点）包含两部分：一部分...
线性表的链式存储与实现
07-29
线性表是计算机科学中一种基础的数据结构，它是由n（n≥0）个相同类型...在实际编程中，我们可以结合具体需求选择单链表或双向链表，并根据所使用的编程语言特性，如C、C++、Java或Python等，实现相应的链表操作函数。
数据结构（c++版） 第二章 线性表
尘埃
10-13 529
本章的基本内容是： Ø线性表的逻辑结构 Ø 线性表的顺序存储及实现 Ø 线性表的链接存储及实现 Ø 顺序表和链表的比较 Ø 线性表的其他存储方法 2.1 线性表的逻辑结构 （一）线性表的定义 1、线性表：简称表，是n（n≥0）个具有相同类型的数据元素的有限序列。 2、 线性表的长度：线性表中数据元素的个数。 3、空表：长度等于零的线性表，记为：L=( 
数据结构第二章线性表自测题及答案
01-01
数据结构第二章线性表自测题及答案 数据结构第二章线性表自测题及答案
严蔚敏 《数据结构》第二章线性表 2.3节线性表的链式表示 C++实现
桂圆儿的仓库
03-21 240
严蔚敏 《数据结构》第二章线性表 2.2节线性表的链式表示 C++实现 代码没有怎么测试过，可能有些地方有BUG // link_list.h // By Envirian #ifndef LINK_LIST_H_ #define LINK_LIST_H_ #include <iostream> using std::cin; using Status = int; // 返回值类型 const int TRUE = 1; const int F
数据结构 王道 算法大题 第二章 线性表 C++编程实现
编写一个生成器函数，能够生成斐波那契数列
09-17 864
数据结构 第二章 线性表 2.2 线性表的顺序表示 1.从顺序表中删除具有最小值的元素。由函数返回被删元素的值。空出的位置由最后一个元素填补。若顺序表为空，则显示出错信息并退出运行。 #include<stdio.h> #define maxsize 50 typedef struct{ int data[maxsize]; int length; }SqList; //从顺序表中删除具有最小值的元素。由函数返回被删元素的值。空出的位置由最后一个元素填补。若顺序表为空，则显示出错信息并退出
线性表的链式表示和实现
qq_43615815的博客
04-26 511
建一个工程 1.建一个头文件status.c #ifndef STATUS_H #define STATUS_H //函数结果状态代码 #define TURE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 //status 是函数的类型，其值是函...
C++实现线性表的链式表示
qq_46027243的博客
02-13 449
文章目录一、链表相关概念1，相关名词2，链表的特点3，链表分类4，单链表表示二、单链表的C++实现 一、链表相关概念 1，相关名词 2，链表的特点 3，链表分类 4，单链表表示 二、单链表的C++实现 typedef struct { string name; int age; }Student; //定义结点的数据域 typedef struct LNode { Student data; //结点的数据域 LNode* next; //结点的指针域 }LNode, *
【008】数据结构：线性表之链式存储结构——C++单向链表的代码实现（使用模板类）
mengyu_0317的博客
10-21 383
线性表： 最基本和最常用的一种数据结构，由零个或多个数据元素组成的有限序列，表示线性结构。分为顺序存储结构和链式存储结构两种。 特点： 1.数据元素的数据类型相同 2.位顺从1开始 3.由唯一前驱和后继（除第一个和最后一个元素外） 顺序存储结构： 用一段不连续的内存空间存储线性表中的数据元素。 C++单向链表的代码实现 DynamicArray.h 链表类的定义 #include <iostream> //链表节点 template <typename T> class LinkN
数据结构教程 第八课 线性表的链式表示与实现
kong0613的专栏
05-25 1483
本课主题： 线性表的链式表示与实现 教学目的： 掌握线性链表、单链表、静态链表的概念、表示及实现方法 教学重点： 线性链表之单链表的表示及实现方法。 教学难点： 线性链表的概念。 授课内容： 一、复习顺序表的定义。 二、线性链表的概念： 以链式结构存储的线性表称之为线性链表。 特点是该线性表中的数据元素可以用任意的存储单元来存储。线性表中逻辑相邻
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值