C++数据结构实验一线性表

实验内容：

1.建立一个顺序表，随机产生 10 个 100 以内的整数，并按要求完成：

（1）编写显示函数，在屏幕上显示顺序表中的 10 个整数；

（2）编写查找函数，从键盘输入任一整数在顺序表中查找，若找到，返回该元素在顺序表中的位置，否则提示无此元素；

（3）编写插入函数，从键盘输入待插入元素及插入位置，将完成插入后的顺序表输出；

（4）编写删除函数，从键盘输入待删除元素位置，将该位置元素删除后的顺序表输出。

2.有两个有序排序的单链表 L1 和 L2，分别存放 10 个数据元素，设计算法实现两个单链表的合并，要求合并后的单链表仍然有序排序，并输出合并结果。

---

实验代码：

// SequenceList.h
#pragma once
#include<iostream>

template<typename T>
class SequenceList
{
    
    
public:
	// 构造函数
	SequenceList() :
		mMaxSize(10), mLength(0), mData(nullptr)
	{
    
    
		mData = new T[mMaxSize]();
	}
	SequenceList(T* data, int length) :
		mMaxSize(length + 10), mLength(length), mData(nullptr)
	{
    
    
		// 申请一块比源数据元素多10个元素的堆空间
		mData = new T[mMaxSize]();
		for (size_t i = 0; i < length; i++)
		{
    
    
			mData[i] = data[i];
		}
	}
	// 析构函数
	~SequenceList()
	{
    
    
		delete[] mData;
	}

	// 显示函数
	void Display();
	// 查找函数
	int Find(T element);
	// 插入函数
	void Insert(T data, int pos);
	// 删除函数
	T Delete(int pos);

	// Getter/Setter
	int GetLength() {
    
     return mLength; }
	int GetMaxSize() {
    
     return mMaxSize; }

private:
	int mMaxSize;
	int mLength;
	T* mData;
};

template<typename T>
void SequenceList<T>::Display()
{
    
    
	for (size_t i = 0; i < mLength; i++)
	{
    
    
		std::cout << mData[i] << " ";
	}
	std::cout << std::endl;
}

template<typename T>
int SequenceList<T>::Find(T element)
{
    
    
	for (size_t i = 0; i < mLength; i++)
	{
    
    
		if (mData[i] == element)
		{
    
    
			return i;
		}
	}
	std::cout << "元素查找失败！" << std::endl;
	return -1;
}

template<typename T>
void SequenceList<T>::Insert(T data, int pos)
{
    
    
	if (mLength == mMaxSize)
	{
    
    
		std::cout << "顺序表在执行插入元素时错误：顺序表已满！" << std::endl;
		return;
	}
	if (pos < 0)
	{
    
    
		std::cout << "顺序表在执行插入元素时错误：非法的位置！" << std::endl;
		return;
	}
	if (pos >= mLength)
	{
    
    
		// pos如果超出范围则插入到顺序表尾部
		pos = mLength;
	}
	for (size_t i = mLength; i > 0; i--)
	{
    
    
		if (i + 1 == pos)
		{
    
    
			mData[i] = data;
			break;
		}
		mData[i] = mData[i - 1];
	}
	mLength++;
}

// 传入顺序表并返回插入数据后的该顺序表
template<typename T>
SequenceList<T>& InsertSeq(SequenceList<T>& seq, T data, int pos)
{
    
    
	seq.Insert(data, pos);
	return seq;
}


template<typename T>
T SequenceList<T>::Delete(int pos)
{
    
    
	T* temp1 = new T();
	T temp2 = *temp1;
	delete temp1;
	int index = pos - 1;
	if (mLength == 0)
	{
    
    
		std::cout << "顺序表在执行删除元素时错误：顺序表为空！" << std::endl;
		return temp2;
	}
	if (index < 0 || index >= mLength)
	{
    
    
		std::cout << "顺序表在执行删除元素时错误：非法的位置！" << std::endl;
		return temp2;
	}

	temp2 = mData[index];
	for (size_t i = index; i < mLength; i++)
	{
    
    
		if (i == mLength)
		{
    
    
			mData[i] = 0;
		}
		else
		{
    
    
			mData[i] = mData[i + 1];
		}
	}
	mLength--;
	return temp2;
}

// 传入顺序表并返回删除数据后的该顺序表
template<typename T>
SequenceList<T>& DeleteSeq(SequenceList<T>& seq, int pos)
{
    
    
	seq.Delete(pos);
	return seq;
}

// main.cpp
#include<iostream>
#include<cstdlib>
#include<ctime>
#include"SequenceList.h"

int* RandomDataGenerator(int* a, int length = 10);

int main()
{
    
    
	// 产生随机数据
	int randomData[10];
	RandomDataGenerator(randomData);

	SequenceList<int> seqList(randomData, 10);

	// 显示
	seqList.Display();
	// 查找
	int data;
	std::cout << "请输入要查找的元素：";
	std::cin >> data;
	int index = seqList.Find(data);
	if(index < 0)
	{
    
     
		std::cout << "没有查找到此元素！" << std::endl;
	}
	else
	{
    
    
		std::cout << "元素" << data << "在顺序表中的位置为" << index + 1 << std::endl;
	}
	// 插入
	std::cout << "在第6个位置插入42" << std::endl;
	InsertSeq(seqList, 42, 6);
	seqList.Display();
	// 删除
	std::cout << "删除第8个元素" << std::endl;
	DeleteSeq(seqList, 8);
	seqList.Display();

	return 0;
}

int* RandomDataGenerator(int *a, int length)
{
    
    
	std::srand((unsigned int)time(0));
	for (int i = 0; i < length; i++)
	{
    
    
		a[i] = rand() % 101;
	}

	return a;
}

---

总结：

顺序表没什么好说的，老基础了，就是非常普通的写法而已。就是使用随机数的时候注意随机数种子是否每次都给了一个一样的。