实验一 线性表的物理实现（顺序表+单向链表）

最新推荐文章于 2020-10-30 21:43:53 发布
最新推荐文章于 2020-10-30 21:43:53 发布
阅读量1.3k 收藏 6
点赞数 4
分类专栏： ∨∨坑逼数据结构课 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40889820/article/details/83247201
版权
  • 基于顺序表实现的线性表
  • 基于链表实现的线性表
  • 实验中遇到的问题（&DevC++中的骚操作）

一、基于顺序表实现的线性表

List.h

#include <iostream>
using namespace std;
#ifndef _List
#define _List
namespace wangzhe
{
	template <typename E> 
	class List
	{
		private:
			void operator =(const List&) {}
			List(const List&) {}
		public:
			List() {}
			virtual ~List() {}
			virtual void clear() =0;
			virtual void insert(const E& item) =0;
			virtual void append(const E& item) =0;
			virtual E remove() =0;
			virtual void moveToStart() =0;
			virtual void moveToEnd() =0;
			virtual void prev() =0;
			virtual void next() =0;
			virtual int length() const =0;
			virtual int currPos() const =0;
			virtual void moveToPos(int pos) =0;
			virtual const E& getValue() const =0;			
	};
	
}
#endif

 

AList.h

#include<iostream>
using namespace std;
#include"List.h"
#ifndef _AList
#define _AList
namespace wangzhe
{
	template <typename E> 
	class AList:public List<E>
	{
		private:
			int maxSize;
			int listSize;
			int curr;
			E* listArray;
		public:
			AList(int size);
			~AList();
			void clear();
			void insert(const E& item);
			void append(const E& item);
			E remove();
			void moveToStart();
			void moveToEnd();
			void prev();
			void next();
			int length() const;
			int currPos() const;
			void moveToPos(int pos) ;
			const E& getValue() const ;			
	};
}
#endif

 

AList.cpp

#include<iostream>
using namespace std;
#include"AList.h"
namespace wangzhe
{
	template <typename E>
	AList<E>::AList(int size)
	{
		maxSize=size;
		listSize=curr=0;
		listArray =new E[maxSize];
	}
	
	template <typename E>
	AList<E>::~AList()
	{
		delete [] listArray;
	}
	
	template <typename E>
	void AList<E>::clear()
	{
		delete [] listArray;
		listSize=curr=0;
		listArray=new E[maxSize]; 
	}
	
	template <typename E>
	void AList<E>::insert(const E& item)
	{
		if(listSize>=maxSize)
		{
			cout<<"List capacity exceeded"<<endl;
			return;
		}
		for(int i=listSize;i>curr;i--)
		{
			listArray[i]=listArray[i-1];
		}
		listArray[curr]=item;
		listSize++;
	}
	
	template <typename E>
	void AList<E>::append(const E& item)
	{
		if(listSize>=maxSize)
		{
			cout<<"List capacity exceeded"<<endl;
			return;
		}
	    listArray[listSize++]=item; 
	} 
	
	template <typename E>
	E AList<E>::remove()
	{
		if(curr<0||curr>=listSize)
		{
			cout<<"No element"<<endl;
			return 0;
		}
		E it=listArray[curr];
		for(int i=curr;i<listSize-1;i++)
		listArray[i]=listArray[i+1];
		listSize--;
		return it;
	}
	
	template <typename E>
	void AList<E>::moveToStart()
	{
		curr=0;
	}
	
	template <typename E>
	void AList<E>::moveToEnd()
	{
		curr=listSize;
	}
	
	template <typename E>
	void AList<E>::prev()
	{
		if(curr!=0) curr--;
	}
	
	template <typename E>
	void AList<E>::next()
	{
		if(curr<listSize) curr++;
	}
	
	template <typename E>
	int AList<E>::length() const
	{
		return listSize;
	}
	
	template <typename E>
	int AList<E>::currPos() const
	{
		return curr;
	}
	
	template <typename E>
	void AList<E>::moveToPos(int pos) 
	{
		if(pos<0||pos>=listSize)
		{
			cout<<"No current element"<<endl;
			return;
		}
		curr=pos; 
	}
	
	template <typename E>
	const E& AList<E>::getValue() const  
	{
		if(curr<0||curr>=listSize)
		{
			cout<<"No current element"<<endl;
			return 0;
		}
		return listArray[curr];
	}
}

 

main.cpp

#include <iostream>
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
#include"AList.h"
#include"AList.cpp"
using namespace wangzhe;
int main(int argc, char** argv) 
{
	for(int i=1;i<=50;i++) cout<<'-';
	cout<<"\n"<<"基于顺序表实现的线性表基本操作演示\n";
	for(int i=1;i<=50;i++) cout<<'-';
	cout<<endl;
	AList<int> a(10010);
	cout<<"请输入对应的数字实现相关操作：\n";
	cout<<" 0、退出操作\n"; 
	cout<<" 1、在当前位置插入一个元素\n";
	cout<<" 2、在末尾插入一个元素\n";
	cout<<" 3、删除当前位置的元素并输出其值\n";
	cout<<" 4、将当前位置置于第一个元素\n";
	cout<<" 5、将当前位置置于最后一个元素\n";
	cout<<" 6、将当前位置向前移一个\n";
	cout<<" 7、将当前位置向后移一个\n";
	cout<<" 8、输出当前元素个数\n";
	cout<<" 9、输出当前位置\n";
	cout<<"10、将当前位置置于给定位置处\n";
	cout<<"11、输出当前位置的元素\n";
	cout<<"12、输出当前所有元素\n";
	cout<<"13、清空所有元素\n"; 
	for(int i=1;i<=50;i++) cout<<'-';
	cout<<endl;
	int order,temp;
	while(1)
	{
		cin>>order;
		if(!order) break;
		switch (order)
		{
			case 1:
				{
					cout<<"输入要插入的元素：\n";
					cin>>temp;
					a.insert(temp); 
					break;
				}
			case 2:
				{
					cout<<"输入要插入的元素：\n";
					cin>>temp;
					a.append(temp); 
					break;
				}	
			case 3:
				{
					cout<<a.remove()<<endl;
					break;
				}
			case 4:
				{
					a.moveToStart();
					break;
				}
			case 5:
				{
					a.moveToEnd();
					break;
				}
			case 6:
				{
					a.prev();
					break;
				}
			case 7:
				{
					a.next();
					break;
				}
			case 8:
				{
					cout<<a.length()<<endl;
					break;
				}
			case 9:
				{
					cout<<a.currPos()<<endl;
					break;
				}
			case 10:
				{
					cout<<"输入给定位置：\n";
					cin>>temp;
					a.moveToPos(temp);
					break; 
				}
			case 11:
				{
					cout<<a.getValue()<<endl;
					break;
				}
			case 12:
				{
					for(a.moveToStart();a.currPos()<a.length();a.next())
					cout<<a.getValue()<<' ';
					cout<<endl;
					break;
				}
			case 13:
				{
					a.clear();
					break;
				}
			default: break;
		} 
	}
	
	return 0;
	
	
}

 

 

二、基于链表实现的线性表

List.h

同顺序表

 

Link.h

#include <iostream>
using namespace std;
#ifndef _Link
#define _Link
namespace wangzhe
{
	template<typename E> 
	class Link
	{
	    public:
		E element;
		Link *next;
		Link(const E& elemval,Link* nextval =NULL)
		{
		        element=elemval;
			next=nextval;	
		}	
		Link(Link* nextval=NULL)
		{
			next=nextval;
		}
	};
}
#endif

 

LList.h

#include<iostream>
using namespace std;
#include"List.h"
#include"Link.h"
#ifndef _LList
#define _LList
namespace wangzhe
{
	template<typename E>
	class LList:public List<E>
	{
		private:
			Link<E>* head;
			Link<E>* tail;
			Link<E>* curr;
			int cnt;
			void init();
			void removeall();
		public:
			LList(int size);
			~LList();
			void print() const;
			void clear();
			void insert(const E& it); 
			void append(const E& it);
			E remove();
			void moveToStart();
			void moveToEnd();
			void prev();
			void next();
			int length() const;
			int currPos() const;
			void moveToPos(int pos);
			const E& getValue() const;
			
	};
}
#endif

 

LList.cpp

#include<iostream>
using namespace std;
#include"LList.h"
namespace wangzhe
{
	template<typename E>
	void LList<E>::init()
	{
		curr=tail=head=new Link<E>;
		head->next=NULL;
		cnt=0;
	}
	
	template<typename E>
	void LList<E>::removeall()
	{
		while(head!=NULL)
		{
			curr=head;
			head=head->next;
			delete curr;
		}
	}
	
	template<typename E>
	LList<E>::LList(int size)
	{
		init();
	}
	
	template<typename E>
	LList<E>::~LList()
	{
		removeall();
	}
	
	template<typename E>
	void LList<E>::print() const
	{
		Link<E>* temp=head->next;
		while(temp!=NULL)
		{
			cout<<temp->element<<' ';
			temp=temp->next;
		}
	}
	
	template<typename E>
	void LList<E>::clear()
	{
		removeall();
		init();
	}
	
	template<typename E>
	void LList<E>::insert(const E& it)
	{
		curr->next=new Link<E>(it,curr->next);
		if(tail==curr) tail=curr->next;
		cnt++;
	}
	
	template<typename E>
	void LList<E>::append(const E& it)
	{
		tail=tail->next=new Link<E>(it,NULL);
		cnt++;
	}
	
	template<typename E>
	E LList<E>::remove()//删除当前指向的下一个结点 
	{
		if(curr->next==NULL)
		{
			cout<<"No element"<<endl;
			return 0;
		}
		E it=curr->next->element;
		Link<E>* temp=curr->next;
		if(tail==curr->next) tail=curr;
		curr->next=curr->next->next;
		delete temp;
		cnt--;
		return it;
	}
	
	template<typename E>
	void LList<E>::moveToStart()
	{
		curr=head;
	}
	
	template<typename E>
	void LList<E>::moveToEnd()
	{
		curr=tail;
	}
	
	template<typename E>
	void LList<E>::prev()
	{
		if(curr==head)
		{
			cout<<"curr is the head\n";
			return;
		} 
		Link<E>* temp=head;
		while(temp->next!=curr) temp=temp->next;
		curr=temp;
	}
	
	template<typename E>
	void LList<E>::next()
	{
		if(curr==tail)
		{
			cout<<"curr is the tail\n";
			return;
		}
		curr=curr->next;
	}
	
	template<typename E>
	int LList<E>::length() const
	{
		return cnt;
	}
	
	template<typename E>
	int LList<E>::currPos() const
	{
		Link<E>* temp=head;
		int i;
	    for(i=0;temp!=curr;i++)
	    temp=temp->next;
	    return i;
	}
	
	template<typename E>
	void LList<E>::moveToPos(int pos)
	{
		if(pos<0||pos>cnt)
		{
			cout<<"Position out of tange\n";
		}
		curr=head;
		for(int i=0;i<pos;i++) curr=curr->next;
	}
	
	template<typename E>
	const E& LList<E>::getValue() const
	{
		if(curr->next==NULL)
		{
			cout<<"No value\n";
			return -1;
		}
		return curr->next->element;
	}
}

 

main.cpp

参考顺序表

 

三、实验中遇到的问题（&DevC++中的骚操作）

1、注意函数声明与定义的区别；

2、有#include"XXX.cpp"的骚操作（类模板的定义和声明是能在.h和.cpp分离的！！，只不过在main.cpp中除了需要包括.h之外还要包括相应的.cpp！！！）；

3、某个.h里的构造函数名与类名中的一个字母大小写不同，devC++竟然不报错，着实可恶，因此应该注意大小写。

 

参考文献

【1】Clifford A.Shaffer.数据结构与算法分析【M】.北京：电子工业出版社，2013：62-68.

就算过了一载春秋
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链式表的实现（C++）
ThetaQing的博客
09-06 1166
linklist.cpp文件 主要包括基本操作，初始化、销毁链表等。 #include <iostream> # include"linklist.h" using namespace std; /****************************** * 链式表 * * */ /* *初始化链式表 */ void InitLinkList(LinkLi...
一元多项式的基本操作
慢慢的专栏
07-24 1972
#include #include"LinkList.h" #define NUM 4 using namespace std; class Polynomial{ public: //输入m项的系数和指数，建立表示一元多项式的有序链表P void CreatePolyn(polynomial &P,int m); //销毁一元多项式 void DestroyPolyn(polynomi
【数据结构与算法】线性结构
公众号『机器感知』
10-05 904
线性结构 1. 单链表 #ifndef __LINK1__H__ #define __LINK1__H__ #include &amp;amp;amp;lt;iostream&amp;amp;amp;gt; using namespace std; template&amp;amp;amp;lt;typename T&amp;amp;amp;gt; struct sigleLink { T value; struct sigleLink&
link链表类实验（多文件模式）
keyboardnobug的博客
04-20 2552
实验讲义 一、实验目的 1．掌握使用new运算符创建对象的方法； 2．掌握使用delete运算符释放对象内存的方法； 3．掌握使用面向对象思想实现链表类并对链表进行操作的方法。 二、实验内容 1．设计并编写链表类，能够实现链表的初始化（建立）、输出释放等功能。 三、实验指导 （1）链表由若干个结点【Node类对象】构成（每个结点有data域和next域，假设每个结点的data域是一个整数，并且没有...
数据结构 线性表实验
sinb妃的博客
09-11 6728
实验目的： 1、掌握线性表的定义； 2、掌握线性表的基本操作，如建立、查找、插入和删除等。 实验内容： 定义一个包含学生信息（学号，姓名，成绩）的的顺序表和链表，使其具有如下功能： (1) 根据指定学生个数，逐个输入学生信息； (2) 逐个显示学生表中所有学生的相关信息； (3) 根据姓名进行查找，返回此学生的学号和成绩； (4) 根据指定的位置可返回相应的学生信息（学号，姓名，成绩）； (5) ...
指针、引用、结构体、线性表（顺序表、单向链表）
05-18
（1）使用指针和引用两种方式，完成两个学生的交换。 （2）定义一个结构体类型student，写一个...（3）完成线性表的基本操作：插入、删除、查找，遍历、以及线性表合并等运算在顺序存储结构和链式存储结构上的运算。
数据结构学习--线性表及其应用--链表
06-25
单向链表是最简单的链表形式，每个节点包含一个数据域和一个指向下一个节点的指针。在本程序中，数据域被定义为字符串类型，这样可以存储各种文本信息。链表的头节点是一个特殊的节点，其指针域指向链表的第一个实际...
西南交通大学数据结构实验之单向链表算法练习
02-01
本资源总结了西南交通大学数据结构实验报告的单向链表算法练习，涵盖了链表的基本操作、算法设计、输入/输出设计、编程语言说明等方面的知识点。 一、链表的基本操作 * 单向链表的插入操作：在链表的第 i 个元素...
简单介绍线性表以及如何实现双链表
09-03
2. 单向链表：单向链表由一系列节点组成，每个节点包含数据和指向下一个节点的指针。相比于数组，链表的插入和删除操作更为灵活，因为只需要改变相邻节点的指针即可，但随机访问性能较差。在单链表中，删除一个节点...
8.顺序表和链表新1
最新发布
08-03
顺序表是线性表的一种具体实现，它使用一段连续的存储空间来存放元素。顺序表通常分为静态顺序表和动态顺序表。静态顺序表使用预先定义大小的定长数组存储数据，适用于已知数据量的场景，但可能导致空间浪费或不足。...
《数据结构》实验二：线性表的实验（实验报告）
热门推荐
denise94的专栏
10-23 2万+
一．实验目的      巩固线性表的数据结构，学会线性表的应用。 1.回顾线性表的逻辑结构，线性表的物理存储结构和常见操作。 2.学习运用线性表的知识来解决实际问题。 3.进一步巩固程序调试方法。 4.进一步巩固模板程序设计。 二．实验时间    准备时间为第2周到第4周，具体集中实验时间为第4周第2次课。2个学时。 三．.实验内容 1.建立一
线性表实验
weixin_46226815的博客
10-30 478
窗口问题 【问题描述】 在某图形操作系统中，有N个窗口，每个窗口都是一个两边与坐标轴分别平行的矩形区域。窗口的边界上的点也属于该窗口。窗口之间有层次的区别，在多于一个窗口重叠的区域里，只会显示位于顶层的窗口里的内容。 当你点击屏幕上一个点的时候，你就选择了处于被点击位置的最顶层窗口，并且这个窗口就会被移到所有窗口的最顶层，而剩余的窗口的层次顺序不变。如果你点击的位置不属于任何窗口，则系统会忽略你这次点击。 现在我们希望你写一个程序模拟点击窗口的过程。 【输入形式】 输入的第一行有两个正整数，即N和M。（1.
数据结构笔记——链表
yaoning6768的博客
03-07 226
1、 利用指针实现的线性表。是动态的（dynamic），即能按照需要为表中新的元素分配存储空间。 2、 链表由一系列结点（node）组成。 3、 单链表。Link类：包含一个存储元素值的element域和储存表中下一个指针的next域。 template &amp;lt;typename E&amp;gt; class Link { public: E element; Link *next; Link(c...
删除线性表指定位置的元素（单链表实现）
此号停用
11-18 4906
4.1假设一个线性表包含下列元素：，使用图4.1的List ADT编写一些C++语句，删除值为15的元素。 #include "stdafx.h" #include #include #incl
数据结构（1）线性表之顺序表的表示和实现
小姚的博客
08-08 1257
线性表顺序存储结构的表示和实现
线性表的基本操作及其应用
梦想还是要有的
12-05 6566
线性表的基本操作及其应用 一、实验目的 1、帮助读者复习C++语言程序设计中的知识。 2、熟悉线性表的逻辑结构。 3、熟悉线性表的基本运算在两种存储结构上的实现，其中以熟悉链表的操作为侧重点。   二、实验内容 本次实验提供4个题目，每个题目都标有难度系数，*越多难度越大，学生可以根据自己的情况选做！ 题目一：单链表的基本操作（*） [问题描述] 实现带头结点的单链表的建立
实验一线性表的基本操作实现及其应用
Srx198的博客
09-21 457
一、实验目的 1、熟练掌握线性表的结构特点，掌握顺序表的基本操作。 2、巩固 C++相关的程序设计方法与技术。 3、学会使用顺序表解决实际问题。  二、实验内容   顺序表的建立与操作实现建立 n 个元素的顺序表，实现相关的操作：输出，插入，删除，查找等功能。编写完整程序实现，程序语言不限定，使用技术形式不定。 三、实验步骤 1、依据实验内容分别说明实验程序中用到的数据类型的定义；
线性表的实验
夏曦
11-26 698
问题： 1.建立一个带头结点的单链表，结点的值域为整型数据。要求将用户输入的数据按尾插入法来建立相应单链表。 2.设计一个函数在链表中查找元素x的位置，如果x不在链表中则返回-1。 3.设计一个函数将元素x插入第i个元素的后面。如果i大于链表的长度，则将x插入链表的末尾；如果i小于或等于0，则将x直接插入表头之后。 #include<iostream> #include<algo...
第2章线性表的基本操作实现（算法）及实验一参考.doc
05-30
第2章线性表的基本操作实现（算法）及实验一参考.doc

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值