/********************************************************
*************** 实验四 链式描述线性表/链表操作**************
****************插入操作:1 插入数*************************
****************删除操作:2 删除数*************************
****************查找操作:3 查找数*************************
****************输出操作:4*******************************
****************逆序输出操作:5***************************
****************合并链表操作:6***************************
****************链表一元素数 [链表一所有元素]**************
****************链表二元素数 [链表二所有元素]**************
************************created by fsy*********************
*/
#include<iostream>
#include<numeric> //accumulate函数
#include<algorithm>
#include <stack>
using namespace std;
int h[1000021];
//结构体功能:表示链表的节点
template <class T>
struct chainNode
{
// data members
T element;
chainNode<T>* next;
// methods
chainNode() {}
chainNode(const T& element)
{
this->element = element;
}
chainNode(const T& element, chainNode<T>* next)
{
this->element = element;
this->next = next;
}
};
//类功能:链表的定义
template<class T>
class chain
{
protected:
chainNode<T>* firstNode;//指向列表的头节点的指针
//当链表为空时,firstNode指向NULL
int listSize; //线性表的元素个数
public:
chain(int initialCapacity = 10);
chain(const chain<T>&);
~chain();
//抽象数据类型ADT的方法
bool checkIndex(const int theIndex);
bool empty() const { return listSize == 0; }
int size() const { return listSize; }
T& get(int theIndex) const;
int indexOf(const T& theElement) const;
void erase(int theIndex);
void insert(int theIndex, const T& theElement);
void print();
int size();
//链表迭代器
class iterator
{
public:
//C++语言的向前迭代器所需要的typedefs
typedef forward_iterator_tag iterator_category;
typedef T value_type;
typedef ptrdiff_t difference_type;
typedef T* pointer;
typedef T& reference;
//构造函数
iterator(chainNode<T>* theNode = NULL)
{node = theNode;}
//解引用操作符
T& operator*() const {return node->element;}
T* operator->() const {return &node->element;}
//迭代器加法操作
iterator& operator++() // preincrement
{node = node->next; return *this;}
iterator operator++(int) // postincrement
{iterator old = *this;
node = node->next;
return old;
}
//相等检验
bool operator!=(const iterator right) const
{return node != right.node;}
bool operator==(const iterator right) const
{return node == right.node;}
protected:
chainNode<T>* node;
}; //链表结尾
class iterator;
iterator begin() {return iterator(firstNode);}
iterator end() {return iterator(NULL);}
};
//函数功能:单项链表的构造函数
template<class T>
chain<T>::chain(int initialCapacity)
{
if (initialCapacity < 1)
{
cout << "Initial capacity = " << initialCapacity << " Must be > 0";
cout << "请重新输入一个初始大小" << endl;
cin >> initialCapacity;
chain(initialCapacity);
}
firstNode = NULL;
listSize = 0;
}
//函数功能:单向链表的复制构造函数
template<class T>
chain<T>::chain(const chain<T>& theList)
{
listSize = theList.listSize;
//如果链表本身是空的
if (listSize == 0)
{
firstNode = NULL;
return;
}
//链表theList不是空的
//复制链表的首节点
chainNode<T>* sourceNode = theList.firstNode;
//复制链表的首元素
firstNode = new chainNode<T>(sourceNode->element);
sourceNode = sourceNode->next;
//当前链表*this的最后一个节点
chainNode<T>* targetNode = firstNode;
//复制链表的剩余的元素
//如果链表没有到末尾(末尾为null)
//就复制后继续往前指向
while (sourceNode != NULL)
{
targetNode->next = new chainNode<T>(sourceNode->element);
targetNode = targetNode->next;
sourceNode = sourceNode->next;
}
targetNode->next = NULL;//链表的结尾
}
//函数功能:链表的析构函数
//删除链表的所有节点
template<class T>
chain<T>::~chain()
{
chainNode<T> *nextNode;
//如果链表当前节点指的不是NULL(结尾是NULL)
//就删除掉这个节点后继续往前指
while (firstNode != NULL)
{
//指向节点的指针
//用变量nextNode保存第二个节点的指针
nextNode = firstNode->next;
delete firstNode;
firstNode = nextNode;
}
}
//检查该节点是否有元素
//易证这里的选择应该是>而不是>=
template<class T>
bool chain<T>::checkIndex(const int theIndex)
{// Verify that theIndex is between 0 and listSize - 1.
if (theIndex < 0 || theIndex > listSize)
{
cout << "index = " << theIndex << " size = " << listSize<<endl;
return false;
}
else
return true;
}
//功能:返回索引为theIndex处的元素
//如果不存在则返回一场
template<class T>
T& chain<T>::get(int theIndex) const
{
if (checkIndex(theIndex))
{
chainNode<T>* currentNode = firstNode;
for (int i = 0; i < theIndex; i++)
{
currentNode = currentNode->next;
}
return currentNode->element;
}
}
//功能:返回元素theElement第一次出现时的索引
//若该元素不存在,则返回-1
template<class T>
int chain<T>::indexOf(const T& theElement) const
{
//查找元素theElement
chainNode<T>* currentNode = firstNode;
int index = 0; //现在所在的索引
//如果指针没有走到结尾且指针所指的元素不是要找的元素
//指向结尾,或指向要找元素时退出
while (currentNode != NULL &&
currentNode->element != theElement)
{
//指针指向下一个元素
currentNode = currentNode->next;
index++;//该指针的索引加一
}
//确定元素theElement是否被找到
if (currentNode == NULL)
return -1;
else
return index;
}
//删除其索引为theIndex的元素
template<class T>
void chain<T>::erase(int theIndex)
{
if (checkIndex(theIndex))
{
chainNode<T>* deleteNode;
if (theIndex == 0)
{//删除指针指向首元素
//第二个元素取代第一个元素成为首元素
deleteNode = firstNode;
firstNode = firstNode->next;
}
else
{//使用指针p指向要删除节点的前驱节点
chainNode<T>* p = firstNode;
for (int i = 0; i < theIndex - 1; i++)
{
p = p->next;
}
//删除指针指向要删除元素
deleteNode = p->next;
//前驱节点的下一个元素变为要删除元素的后一个元素
p->next = p->next->next;
}
listSize--; //链表元素数减一
delete deleteNode;
}
}
//在索引为theIndex的位置上插入元素theElement
template<class T>
void chain<T>::insert(int theIndex, const T& theElement)
{
if (theIndex == 0)
{
//如果theIndex为0则在链表头插入
//这是结构体中默认的插在表头的元素函数
firstNode = new chainNode<T>(theElement, firstNode);
listSize++;//链表元素数量++
}
else
{
if (checkIndex(theIndex))
{
//寻找新元素的前驱
chainNode<T>* p = firstNode;
for (int i = 0; i < theIndex - 1; i++)
{//p指向插入位置的前一个元素
p = p->next;
}
//在插入位置使用链表结构体里的自带函数
p->next = new chainNode<T>(theElement, p->next);
listSize++;
}
}
}
//函数功能:打印链表
template<class T>
void chain<T>::print()
{
//把链表放入输出流
//这是一个for循环
for (chainNode<T>* currentNode = firstNode;
currentNode != NULL;
currentNode = currentNode->next)
{
cout << currentNode->element << " ";
}
}
template<class T>
int chain<T>::size()
{
return listSize;
}
int main()
{
int n;//有多少次操作
cin >> n;
int operation;
int list1number; //合并链表时链表一的元素数
int list2number; //合并链表时链表二的元素数
int indexNumber;//数的序号
int number;//插入,删除,查找的各个数
int ans; //查找结果
chain<int> a;
stack<int> s1;
while (n--)
{
cin >> operation;
//插入操作:1 插入数
if (operation == 1)
{
cin >> number;
a.insert((int)0,number);
}
//删除操作:2 删除数
if (operation == 2)
{
cin >> number;
indexNumber = a.indexOf(number);
a.erase(indexNumber);
}
//查找操作:3 查找数
if (operation == 3)
{
cin >> number;
ans = a.indexOf(number);
cout << ans << endl;
}
//输出操作:4
if (operation == 4)
{
for (chain<int>::iterator i = a.begin();
i != a.end(); i++)
{
cout << *i<<" ";
}
cout << endl;
}
//逆序输出操作:5
if (operation == 5)
{
for (chain<int>::iterator i = a.begin();
i != a.end(); i++)
{
s1.push(*i);
}
while(s1.empty()==false)
{
number = s1.top();
cout << number << " ";
s1.pop();
}
cout << endl;
}
//合并链表操作:6
//链表一元素数 [链表一所有元素]
//链表二元素数[链表二所有元素]
if (operation == 6)
{
cin >> list1number;
chain<int> a1;
for (int i = 0;i < list1number;i++)
{
cin >> h[i];
}
cin >> list2number;
chain<int> a2;
for (int i = list1number;i < list1number + list2number;i++)
{
cin >> h[i];
}
sort(h, h + list1number + list2number);
for (int i = 0;i < list1number + list2number; i++)
{
cout<<h[i]<<" ";
}
cout << endl;
}
}
return 0;
}
链式描述线性表/链表操作
最新推荐文章于 2022-04-27 21:22:03 发布