C++实现顺序表&单链表&双链表

最新推荐文章于 2021-08-01 00:09:32 发布

weixin_37922654

最新推荐文章于 2021-08-01 00:09:32 发布

阅读量302

点赞数 1

分类专栏： c++

本文链接：https://blog.csdn.net/weixin_37922654/article/details/75905380

版权

c++ 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

c++实现顺序表

#include<iostream>
#include<assert.h>
using namespace std;

typedef int DataType;
class Seqlist
{
public:
	Seqlist() //构造函数
		:_arr(NULL)
		, _capacity(0)
		, _size(0)
	{}
	Seqlist(const Seqlist& s)  //拷贝构造
	{
		_arr = new DataType[s._size];
		memcpy(_arr, s._arr, s._size*sizeof(DataType));
		_size = s._size;
		_capacity = _size;
	}
	void Release()
	{
		if (_arr)
		{
			delete[] _arr;
			_size = 0;
			_capacity = 0;
			_arr = NULL;
		}
	}
	~Seqlist()  //析构函数
	{
		Release();
	}
	Seqlist& operator=(Seqlist s)  //赋值运算符重载
	{
		swap(_arr, s._arr);
		swap(_size, s._size);
	    swap(_capacity, s._capacity);
		return *this;
	}
	void check_capacity();
	void Print();
	void PushBack(DataType x);
	void PushFront(DataType x);
	void PopBack();
	void PopFront();
	void Insert(size_t pos, DataType x);
	void Erase(size_t pos);
	size_t Find(DataType x);
private:
	DataType* _arr;
	size_t _capacity;
	size_t _size;
};
void Seqlist::check_capacity()
{
	if (_size == _capacity)
	{
		_capacity = 2 * _capacity + 1;
		_arr = (DataType*)realloc(_arr, _capacity*sizeof(DataType));
	}
}
void Seqlist::Print()
{
	size_t i = 0;
	for (i = 0; i < _size; i++)
	{
		cout << _arr[i] << " ";
	}
	cout << endl;
}
void Seqlist::PushBack(DataType x)
{
	check_capacity();
	_arr[_size++] = x;
}
void Seqlist::PushFront(DataType x)
{
	check_capacity();
	int i = 0;
	for (i = _size; i > 0; i--)
	{
		_arr[i] = _arr[i - 1];
	}
	_arr[0] = x;
	_size++;
}
void Seqlist::PopBack()
{
	if (_size == 0)
	{
		return;
	}
	_size--;
}
void Seqlist::PopFront()
{
	if (_size == 0)
	{
		return;
	}
	size_t i = 0;
	for (i = 0; i < _size; i++)
	{
		_arr[i] = _arr[i + 1];
	}
	_size--;
}
void Seqlist::Insert(size_t pos, DataType x)
{
	    assert(pos<_size);
		check_capacity();
		size_t i = 0;
		for (i = _size; i > pos; i--)
		{
			_arr[i] = _arr[i - 1];
		}
		_arr[pos] = x;
		_size++;
}
size_t Seqlist::Find(DataType x)
{
	size_t i = 0;
	for (i = 0; i < _size; i++)
	{
		if (_arr[i] == x)
		{
			return i;
		}
	}
	return -1;
}
void Seqlist::Erase(size_t pos)
{
	    if (_size == 0)
		return;	
		size_t i = 0;
		for (i = pos; i < _size; i++)
		{
			_arr[i] = _arr[i + 1];
		}
		_size--;
}

void test()
{
	Seqlist s;
	s.PushBack(1);
	s.PushBack(2);
	s.PushBack(3);
	s.PushBack(4);
	s.PushFront(5);
	s.PushFront(6);
	s.Print();
	cout << "- - - - - - - - - - - - - -" << endl;
	s.PopBack();
	s.Print();
	s.PopFront();
	s.Print();
	s.Insert(2, 8);
	s.Print();
	s.Erase(2);
	s.Print();
}
int main()
{
	test();
	system("pause");
	return 0;
}

运行结果

C++实现单链表

#include<iostream>
#include<assert.h>
using namespace std;

typedef int DataType;
struct SListNode
{
	DataType _data;
	SListNode* _next;
	SListNode(DataType x) //构造函数
		:_data(x)
	    ,_next(NULL)
	{}
};

class Slist
{
	typedef SListNode Node;
public:
	Slist()  //构造函数
		:_head(NULL)
		,_tail(NULL)
	{}
	Slist(const Slist& s)  //拷贝构造
	{
		Node* cur = s._head;
		while (cur)
		{
			PushBack(cur->_data);
			cur = cur->_next;
		}
	}
	void Release()
	{
		Node* cur = _head;
		while (cur)
		{
			Node* next = cur->_next;
			delete cur;
			cur = next;
		}
		_head = NULL;
		_tail = NULL;
	}
	~Slist()
	{
		Release();
	}
	Slist& operator=(const Slist& s)
	{
		if (this != &s)
		{
			Release();
			Node* tmp = s._head;
			while (tmp)
			{
				PushBack(tmp->_data);
				tmp = tmp->_next;
			}
		}
		return *this;
	}
	Node* BuyNode(DataType x)
	{
		Node* Newnode = (Node*)malloc(sizeof(Node));
		Newnode->_data = x;
		Newnode->_next = NULL;
		return Newnode;
	}
	void PushBack(DataType x)
	{
		//1 空链表
		//2 只有一个结点
		//3 多个结点
		if ((_head == NULL) && (_tail==NULL))
		{
			_head = _tail = new Node(x);
		}
		else
		{
			_tail->_next = new Node(x);
			_tail = _tail->_next;
		}
	}
	void Print()
	{
		Node* cur = _head;
		while (cur)
		{
			cout << cur->_data << "->";
			cur = cur->_next;
		}
		cout << "NULL" << endl;
	}
	void PushFront(DataType x)
	{
		//1 空链表
		//2 至少有一个结点
		if ((_head == NULL) && (_tail == NULL))
		{
			_head = _tail = new Node(x);
		}
		else
		{
			Node* tmp = new Node(x);
			tmp->_next = _head;
			_head = tmp;
		}
	}
	void PopBack()//尾删
	{
		//1 空链表
		//2 只有一个结点
		//3 多个结点
		if (_head == NULL)
		{
			return;
		}
		else if (_head == _tail)
		{
			delete _head;
			_head = NULL;
			_tail = NULL;
		}
		else
		{
			Node* tmp = _head;
			while (tmp->_next!=_tail)
			{
				tmp = tmp->_next;
			}
			delete _tail;
			tmp->_next = NULL;
		}
	}
	void PopFront()
	{
		if (_head == NULL)
		{
			return;
		}
		else if (_head == _tail)
		{
			delete _head;
			_head = NULL;
			_tail = NULL;
		}
		else
		{
			Node* next = _head->_next;
			delete _head;
			_head = next;
		}
	}
	Node* Find(DataType x)
	{
		Node* cur = _head;
		while (cur)
		{
			if (cur->_data == x)
			{
				return cur;
			}
			cur = cur->_next;
		}
		return NULL;
	}

	void Insert(Node* pos, DataType x)
	{
		assert(pos);
		assert(_head);
		//1 头插
		//2 中间插
		if (pos == _head)
		{
			PushFront(x);
		}
		else
		{
			Node* cur = _head;
			while (cur->_next != pos)
			{
				cur = cur->_next;
			}
			Node* tmp = new Node(x);
			cur->_next = tmp;
			tmp->_next = pos;
		}
	}
	void Erase(Node* pos)
	{
		assert(pos);
		assert(_head);
		//1 头删
		//2 尾删
		//3 从中间删
		if (pos == _head)
		{
			PopFront();
		}
		else if (pos == _tail)
		{
			PopBack();
		}
		else
		{
			Node* cur = _head;
			while (cur->_next != pos)
			{
				cur = cur->_next;
			}
			cur->_next = pos->_next;
			delete pos;
			pos = NULL;
		}
	}
private:
	SListNode* _head;
	SListNode* _tail;
};

void test()
{
	Slist s;
	s.PushBack(1);
	s.PushBack(2);
	s.PushBack(3);
	s.PushBack(4);
	s.Print();
	s.PushFront(5);
	s.PushFront(6);
	s.Print();
	cout << "- - - - - - - - - - - -" << endl;
	s.PopBack();
	s.Print();
	s.PopFront();
	s.Print();
	s.Insert(s.Find(3), 4);
	s.Print();
	s.Erase(s.Find(2));
	s.Print();
}
int main()
{
	test();
	system("pause");
	return 0;
}

运行结果

C++实现双链表

#pragma once
#include<iostream>
#include<assert.h>
using namespace std;
typedef int DataType;
struct Node
{
	Node(const DataType& data)
	:_next(NULL)
	, _prev(NULL)
	, _data(data)
	{}
	Node* _next;
	Node* _prev;
	DataType _data;
};

class List
{
public:
	List()
	:_head(NULL)
	, _tail(NULL)
	{}
	List(const List& l) //拷贝构造
	: _head(NULL)
	, _tail(NULL)
	{
		Node* cur = l._head;
		if (l._head != NULL)
		{
			while (cur)
			{
				PushBack(cur->_data);
			    cur = cur->_next;
			}				
		}
	}
	~List()
	{
		if (_head != NULL)
		{
			Node* cur = _head;
			delete _head;
			_head = cur;
			_head = NULL;
			_tail = NULL;
		}
	}
	List& operator=(const List& l)
	{
		if (this->_head != l._head)
		{
			List tmp(l);
			swap(_head, tmp._head);
			swap(_tail, tmp._tail);
		}
	}
	List(size_t n, DataType data);
	void PushBack(const DataType& data)
	{
		//1 没有结点
		//2 有一个结点
		//3 有多个结点
		if (_head == NULL)
		{
			_head = _tail = new Node(data);
		}
		else if (_head->_next == NULL)
		{
			_head->_next = new Node(data);
			_tail = _head->_next;
			_tail->_prev = _head;
		}
		else
		{
			Node* cur = _tail;
			_tail->_next = new Node(data);
			_tail = _tail->_next;
			_tail->_prev = cur;
		}
	}
	void Print()
	{
		Node* cur = _head;
		while (cur)
		{
			cout << cur->_data << "->";
			cur = cur->_next;
		}
		cout << "NULL" << endl;
	}
	void PopBack() //尾删
	{
		//1 没有结点
		//2 有一个结点
		//3 有多个结点
		if (_head == NULL)
			return;
		else if (_head->_next == NULL)
		{
			delete _head;
			_head = NULL;
			_tail = NULL;
		}
		else
		{
			Node* tmp = _tail;
			_tail = _tail->_prev;
			_tail->_next = NULL;
			delete tmp;
		}
	}
	void PushFront(const DataType& data) //头插
	{
		//1 没有结点
		//2 有一个结点
		//3 有多个结点
		if (_head == NULL)
		{
			_head = _tail = new Node(data);
		}
		else
		{
			Node* cur = _head;
			_head = new Node(data);
			_head->_next=cur;			
		}
	}
	void PopFront() //头删
	{
		//1 没有结点
		//2 有一个结点
		//3 有多个结点
		if (_head == NULL)
			return;
		else if (_head->_next == NULL)
		{
			delete _head;
			_head = NULL;
			_tail = NULL;
		}
		else
		{
			Node* tmp = _head;
			_head = _head->_next;
			delete tmp;
		}
	}
	Node* Find(const DataType& data)
	{
		Node* cur = _head;
		while (cur)
		{
			if (cur->_data == data)
				return cur;
			else
				cur = cur->_next;
		}
		return NULL;
	}
	void Insert(Node* pos, const DataType& data)
	{
		assert(pos);
		assert(_head);
		if (pos == _head)
			PushFront(data);
		else
		{
			Node* tmp = new Node(data);
			pos->_prev->_next = tmp;
			tmp->_prev = pos->_prev;
			tmp->_next = pos;
			pos->_prev = tmp;
		}
	}
	void Erase(Node* pos)
	{
		assert(pos);
		assert(_head);
		if (pos == _head || pos->_prev == NULL)
			PopFront();
		else if (pos == _tail || pos->_next == NULL)
			PopBack();
		else
		{
			Node* front = pos->_prev;
			Node* back = pos->_next;
			front->_next = back;
			back->_prev = front;
		}
	}
	void Empty() 
	{
		Node* cur = _head;
		Node* tmp = NULL;
		while (cur)
		{
			tmp = cur;
			cur= cur->_next;
			delete tmp;
		}
		_head = _tail = NULL;
		cout << "clear" << endl;
	}
		
private:
	Node* BuyNode(const DataType& data)
	{
		return new Node(data);
	}
private:
	Node* _head;
	Node* _tail;
};

void test()
{
	List l;
	l.PushBack(4);
	l.PushBack(3);
	l.PushBack(2);
	l.PushBack(1);
	l.PushBack(5);
	l.Print();
	l.PopBack();
	l.Print();
	l.PushFront(5);
	l.PushFront(6);
	l.Print();
	l.PopFront();
	l.Print();
	cout << "- - - - - - - - - - " << endl;
	l.Insert(l.Find(2), 0);
	l.Print();
	l.Erase(l.Find(3));
	l.Print();
	l.Empty();
	

}
int main()
{
	test();
	system("pause");
	return 0;
}

运行结果