数据结构--线性表

最新推荐文章于 2023-01-10 22:25:02 发布

墙缝里的草

最新推荐文章于 2023-01-10 22:25:02 发布

阅读量110

点赞数

文章标签：数据结构

本文链接：https://blog.csdn.net/weixin_52465909/article/details/120494669

版权

//线性表：具有相同特性的数据元素的一个有限序列
//有穷性，一致性，序列性。

#include<iostream>
#ifndef SqList_H_ //没有定义"SqList_H_"则编译下面的语句，以防止命名冲突
#define SqList_H_//定义头文件
#define initSize 100//初始化线性表大小
#define increment 10 //增长步长
typedef int ElemType;//定义元素类型(int)
class SqList
{
private:
	ElemType* elem;//申明元素指针
	int length;//元素个数
	int listsize;//表长度
public:
	SqList();//构造函数
	bool isFull()const;//查看表是否空
	bool isEmpty()const;//查看表是否满
	~SqList();//析构函数
	ElemType getElem(int)const;//查看特定位置元素
	bool insert(int, ElemType);//插入特定位置元素
	bool insert(ElemType);//插入表末元素
	void create();//创建表
	void merge(SqList&, SqList&);//合并表排序
	bool del(int);//删除表元素
	void displayem();//显示表情况
};
#endif
#ifndef DYNAMIC_ARRAY_H
#define DYNAMIC_ARRAY_H
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef struct DYNAMICARRAY {
	int* pAddr;//存放数据的地址
	int size;//当前有多少元素
	int capacity;//容量，最大容纳多少元素

}Dynamic_Array;
//初始化
Dynamic_Array* Init_Array();
//插入
void Push_Back_Array(Dynamic_Array* arr, int value);
//根据位置删除
void RemoveByPos_Array(Dynamic_Array* arr, int pos);
//根据值删除
void RemoveByValue_Array(Dynamic_Array* arr, int value);

//查找
int Find_Array(Dynamic_Array* arr);

//打印
void Print_Array(Dynamic_Array* arr);

//释放动态数组的内存
void FreeSpace_Array(Dynamic_Array* arr);

//清空数组
void Clear_Array(Dynamic_Array* arr);

//获得动态数组容量
int Capacity_Array(Dynamic_Array* arr);
//获得动态数组当前元素个数
int Size_Array(Dynamic_Array* arr);
//根据位置获得某个位置元素
int At_Array(Dynamic_Array* arr, int pos);



#endif

#include"DynamicArray.h"

Dynamic_Array* Init_Array() {
	Dynamic_Array* myArray = (Dynamic_Array*)malloc(sizeof(Dynamic_Array));
//初始化
	myArray->size = 0;
	myArray->capacity = 20;
	myArray->pAddr = malloc(sizeof(int) * myArray->capacity);
	
return myArray;

}
//插入
void Push_Back_Array(Dynamic_Array* arr, int value) {
	if (arr == NULL) {
		return;
	}
	//判断空间是否足够
	if (arr->size==arr->capacity) {
		//申请更大的内存空间，2倍；
		int* newSpace = malloc(sizeof(int) * arr->capacity * 2);
		//拷贝数据到新空间
		memcpy(newSpace, arr->pAddr, arr->capacity * sizeof(int));
		//释放旧空间
		free(arr->pAddr);
		//更新容量
		arr->capacity = arr->capacity * 2;
		arr->pAddr = newSpace;


	}
	//插入
	arr->pAddr[arr->size] = value;
	arr->size++;


}
//根据位置删除
void RemoveByPos_Array(Dynamic_Array* arr, int pos) {
	if (arr == NULL) {
		return;
	}
	//位置是否有效
	if (pos < 0 || pos >= arr->size) {
		return;
	}
	//删除元素
	for (int i = pos; i < arr->size-1; i++) {
		arr->pAddr[i] = arr->pAddr[i + 1];
	}
	arr->size--;
}
//根据值删除
void RemoveByValue_Array(Dynamic_Array* arr, int value) {
	if (arr == NULL) {
		return;
	}
	//找到值的位置
	int pos = -1;
	for (int i = 0; i < arr->size; i++) {
		if (arr->pAddr[i] == value) {
			pos = i; break;
		}
	}

	RemoveByPos_Array(arr, pos);
}

//查找
int Find_Array(Dynamic_Array* arr,int value) {
	if (arr == NULL) {
		return;
	}
	int pos = -1;
	for (int i = 0; i < arr->size; i++) {
		if (arr->pAddr[i] == value) {
			pos = i; break;
		}
	}
	return pos;

}
//打印
void FreeSpace_Array(Dynamic_Array* arr) {
if (arr == NULL) {
		return;
	}

	for (int i = 0; i < arr->size; i++) {
		printf("%d", arr->pAddr[i]);
	}
	printf("\n");
}
//释放动态数组的内存
void FreeSpace_Array(Dynamic_Array* arr) {
	
	if (arr == NULL) {
		return ;
	}
	
	if (arr->pAddr != NULL) {
		free(arr->pAddr);
	}
	free(arr);
}

// 清空数组
void Clear_Array(Dynamic_Array* arr) {
	if (arr == NULL) {
		return;
	}
	//pAddr->空间
	arr->size = 0;
}

//获得动态数组容量
int Capacity_Array(Dynamic_Array* arr) {
	if (arr == NULL) {
		return -1;
	}

	return arr->capacity;
}
//获得动态数组当前元素个数
int Size_Array(Dynamic_Array* arr) {
	if (arr == NULL) {
		return -1;
	}

	return arr->size;

}
//根据位置获得某个位置元素
int At_Array(Dynamic_Array* arr, int pos) {
	if (arr == NULL) {
		return -1;
	}
	return arr->pAddr[pos];
}

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
template<class datatype>
class node;

template<class datatype>
class LinkList
{
private:
	int len;
	node<datatype>* head;
public:
	LinkList();//不带参数的构造函数
	LinkList(datatype x, int n);//初始化有n个val为x的链表
	datatype GetElem(int n);//取链表中第n个元素的值
	int FindElem(datatype value);//找链表中是否存在value的元素，存在返回pos，反之返回-1表示未找到
	void topinsert(datatype value);//头插法插入元素
	void backinsert(datatype value);//尾插法插入元素
	datatype getNthFromEnd(int n);//获取倒数第n个元素的值
	void removeNthFromEnd(int n);//删除链表倒数第n个元素
	void removeNthFromStart(int n);//删除链表第n个元素
	void sortLink1();//排序链表1;
	void sortLink2();//排序链表2;
	node<datatype>* mergesort(node<datatype>* node1);
	node<datatype>* merge(node<datatype>* l1, node<datatype>* l2);
	void reverseList();//反转链表
	bool judgeequal(LinkList& a);//判断两个链表是否相等
	int getlen() //返回链表长度
	{
		return len;
	};
	friend ostream& operator<<(ostream& output, const LinkList& D)//重载输出流
	{
		if (D.len == 0)
		{
			cout << "LinkList is empty" << endl;
			exit(1);
		}
		node<datatype>* p = D.head->next;
		for (int i = 1; i <= D.len; i++)
		{
			output << p->val << ' ';
			p = p->next;
		}
		cout << endl;
		return output;
	}
	~LinkList();//析构函数
};

template<class datatype>
class node
{
	node() {};
	friend class LinkList<datatype>;
public:
	datatype val;
	node<datatype>* next;
	node(datatype x) : val(x), next(NULL) {};
};

//不带参数的构造函数
template<class datatype>
LinkList<datatype>::LinkList()
{
	head = new node<datatype>;
	len = 0;
	head->next = NULL;
}

//初始化有n个val为x的链表
template<class datatype>
LinkList<datatype>::LinkList(datatype x, int n)
{
	head = new node<datatype>;
	len = n;
	head->next = NULL;
	node<datatype>* p = head;
	for (int i = 0; i < n; i++)
	{
		p->next = new node<datatype>(x);
		p = p->next;
	}
}

//析构函数
template<class datatype>
LinkList<datatype>::~LinkList()
{
	node<datatype>* p1 = head, * p2;
	while (p1 != NULL)//排着释放
	{
		p2 = p1->next;
		delete p1;
		p1 = p2;
	}
}

//取链表中第n个元素的值
template<class datatype>
datatype LinkList<datatype>::GetElem(int n)
{
	if (n > len || n < 1)
	{
		cerr << "取值有误";
		return -1;
	}
	else
	{
		node<datatype>* p = head;
		for (int i = 0; i < n; i++)
		{
			p = p->next;
		}
		datatype value = p->val;
		return value;
	}
}

//找链表中是否存在value的元素，存在返回pos，反之返回-1表示未找到
template<class datatype>
int LinkList<datatype>::FindElem(datatype value)
{
	node<datatype>* p = head->next;
	int pos = 1;
	while (p)
	{
		if (p->val == value)
			return pos;
		else
		{
			p = p->next;
			pos++;
		}
	}
	return -1;
}

//头插法插入元素
template<class datatype>
void  LinkList<datatype>::topinsert(datatype value)
{
	node<datatype>* p = new node<datatype>(value);
	node<datatype>* k = head->next;
	head->next = p;
	p->next = k;
	len++;
}

//尾插法插入元素
template<class datatype>
void LinkList<datatype>::backinsert(datatype value)
{
	node<datatype>* p = head;
	for (int i = 0; i < len; i++)
	{
		p = p->next;
	}
	p->next = new node<datatype>(value);
	len++;
}

//获取倒数第n个元素的值
template<class datatype>
datatype LinkList<datatype>::getNthFromEnd(int n)
{
	if (n > len || n < 0)
	{
		cerr << "取值有误";
		return -1;
	}
	else if (n == len)
		return head->next->val;
	else
	{
		node<datatype>* p = head->next;
		for (int i = 0; i < len - n; i++)
		{
			p = p->next;
		}
		return p->val;
	}
}

//删除倒数第n个元素的值
template<class datatype>
void LinkList<datatype>::removeNthFromEnd(int n)
{
	if (n > len || n < 0)
	{
		cerr << "取值有误" << endl;
	}
	else
	{
		if (n == len)
		{
			node<datatype>* p = head->next;
			head->next = head->next->next;
			delete p;
		}
		else if (n == 1)
		{
			node<datatype>* p = head->next;
			for (int i = 1; i < len - 1; i++)
			{
				p = p->next;
			}
			node<datatype>* k = p->next;
			p->next = NULL;
			delete k;
		}
		else
		{
			node<datatype>* p = head;
			for (int i = 0; i < len - n; i++)
			{
				p = p->next;
			}
			node<datatype>* k = p->next;
			p->next = p->next->next;
			delete k;
		}
		len--;
	}
}

//删除第n个元素的值
template<class datatype>
void LinkList<datatype>::removeNthFromStart(int n)
{
	if (n<0 || n>len)
		cerr << "取值有误" << endl;
	else
	{
		if (n == 1)
		{
			node<datatype>* p = head->next;
			head->next = head->next->next;
			delete p;
		}
		else if (n == len)
		{
			node<datatype>* p = head->next;
			for (int i = 1; i < len - 1; i++)
			{
				p = p->next;
			}
			node<datatype>* k = p->next;
			p->next = NULL;
			delete k;
		}
		else
		{
			node<datatype>* p = head;
			for (int i = 0; i < n - 1; i++)
			{
				p = p->next;
			}
			node<datatype>* k = p->next;
			p->next = p->next->next;
			delete k;
		}
		len--;
	}
}

//反转链表
template<class datatype>
void LinkList<datatype>::reverseList()
{
	if (!(head == NULL || head->next == NULL))
	{
		node<datatype>* p = head->next;//遍历节点的上一个节点
		node<datatype>* k = p->next;//当前遍历节点
		head->next->next = NULL;
		head->next = NULL;//更改头
		while (k)
		{
			node<datatype>* temp = k->next;//临时节点保存下一个遍历节点
			k->next = p;
			p = k;
			k = temp;
		}
		head->next = p;
	}
}

//排序1
template<class datatype>
void LinkList<datatype>::sortLink1()
{
	vector<datatype> temp;
	node<datatype>* p = head->next;
	for (int i = 0; i < len; i++)
	{
		temp.push_back(p->val);
		p = p->next;
	}
	sort(temp.begin(), temp.end());
	p = head->next;
	for (int i = 0; i < len; i++)
	{
		p->val = temp[i];
		p = p->next;
	}
}

//排序2
template<class datatype>
void LinkList<datatype>::sortLink2()
{
	head->next = mergesort(head->next);
}

template<class datatype>
node<datatype>* LinkList<datatype>::mergesort(node<datatype>* node1)
{
	if (!node1 || !node1->next) return node1;
	node<datatype>* fast = node1;//快指针走两步
	node<datatype>* slow = node1;//慢指针走一步
	node<datatype>* brek = node1;//断点
	while (fast && fast->next)
	{
		fast = fast->next->next;
		brek = slow;
		slow = slow->next;
	}
	brek->next = nullptr;
	node<datatype>* l1 = mergesort(node1);
	node<datatype>* l2 = mergesort(slow);
	return merge(l1, l2);
}

template<class datatype>
node<datatype>* LinkList<datatype>::merge(node<datatype>* l1, node<datatype>* l2)
{
	if (l1 == NULL)
	{
		return l2;
	}
	if (l2 == NULL)
	{
		return l1;
	}
	if (l1->val < l2->val)
	{
		l1->next = merge(l1->next, l2);
		return l1;
	}
	else
	{
		l2->next = merge(l2->next, l1);
		return l2;
	}
}

//判断两个链表是否相等
template<class datatype>
bool LinkList<datatype>::judgeequal(LinkList& a)
{
	if (a.getlen() != len)
		return false;
	else
	{
		node<datatype>* q = a.head->next;
		node<datatype>* k = head->next;
		for (int i = 0; i < len; i++)
		{
			if (q->val != k->val)
				return false;
			q = q->next;
			k = k->next;
		}
		return true;
	}
}
int main()
{
	//测试
	LinkList<int> A;
	//LinkList<int> B(1,3);
	LinkList<int> B;
	//A.topinsert(2);
	//A.topinsert(1);
	//A.topinsert(3); 
	//A.topinsert(0);
	A.backinsert(2);
	A.backinsert(3);
	A.backinsert(1);
	A.backinsert(1);
	B.backinsert(2);
	B.backinsert(3);
	B.backinsert(1);
	B.backinsert(1);
	cout << "此时链表A元素有：" << A;
	cout << "此时的链表A长度为" << A.getlen() << endl;
	cout << "此时链表A的倒数第二个元素为" << A.getNthFromEnd(2) << endl;
	cout << "此时链表B元素有：" << B;
	//A.removeNthFromEnd(3);
	//A.removeNthFromStart(4);
	//A.reverseList();
	//A.sortLink1();
	//A.sortLink2();
	cout << A;

	if (A.judgeequal(B))
		cout << "两个链表相等" << endl;
	else cout << "两个链表不相等" << endl;
	if (A.FindElem(3) != -1)
	{
		cout << "找到该元素,在第" << A.FindElem(3) << "个位置" << endl;
	}
	else cout << "未找到该元素" << endl;
	if (A.FindElem(1) != -1)
	{
		cout << "找到该元素,在第" << A.FindElem(1) << "个位置" << endl;
	}
	else cout << "未找到该元素" << endl;
	//cout << A.GetElem(1) << " " << A.GetElem(2) << endl;
	//cout << A.GetElem(3) << endl;
	//A.~LinkList();
	system("pause");
	return 0;
}

墙缝里的草

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
数据结构--线性表

//线性表：具有相同特性的数据元素的一个有限序列//有穷性，一致性，序列性。#include<iostream>#ifndef SqList_H_ //没有定义"SqList_H_"则编译下面的语句，以防止命名冲突#define SqList_H_//定义头文件#define initSize 100//初始化线性表大小#define increment 10 //增长步长typedef int ElemType;//定义元素类型(int)class SqList{priv
复制链接

扫一扫