Experimento de estructura de datos C ++ una tabla lineal

Contenido del experimento:

1. Cree una tabla de secuencia, genere aleatoriamente 10 enteros dentro de 100 y complételos según sea necesario:

(1) Escriba una función de visualización para mostrar 10 números enteros en la tabla de secuencia en la pantalla;

(2) Escriba una función de búsqueda, ingrese cualquier número entero desde el teclado para buscar en la tabla de secuencia, si se encuentra, devuelva la posición del elemento en la tabla de secuencia; de lo contrario, indica que no existe tal elemento;

(3) Escriba la función de inserción, ingrese el elemento que se insertará y la posición de inserción desde el teclado, y envíe la tabla de secuencia después de la inserción;

(4) Escriba la función de eliminación, ingrese la posición del elemento a eliminar desde el teclado y envíe la tabla de secuencia después de eliminar el elemento de posición.

2. Hay dos listas enlazadas individualmente ordenadas L1 y L2, que almacenan 10 elementos de datos respectivamente. El algoritmo está diseñado para fusionar las dos listas enlazadas individualmente, y las listas enlazadas individualmente fusionadas deben clasificarse en orden, y el resultado combinado es salida.

---

Código de experimento:

// 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;
}

---

para resumir:

No hay nada que decir sobre la tabla de secuencia, los viejos conceptos básicos son solo una forma muy común de escribir. Cuando utilice números aleatorios, preste atención a si la semilla del número aleatorio es la misma cada vez.