数据结构练习-链表

最近开始学数据结构，准备把做的习题代码屯博客里。

单链表

#pragma once
#include <iostream>
//#include <memory>
using namespace std;

//复合类
/*
class List;

class LinkNode {
	friend class list;
private:
	int data;
	LinkNode* link;
};

class List {
public:
	//公共操作
private:
	LinkNode* first;
};
*/

//嵌套类
/*
class List {
public:
	//公共操作
private:
	class LinkNode {
	public:
		int data;
		LinkNode* link;
	};
	LinkNode* first;
};
*/

//用struct定义LinkNode
class LinkNode {
public:
	friend class List;
	LinkNode() = default;
	LinkNode(int a) :data(a) {}
private:
	int data;
	LinkNode* link;
};

class List {
public:
	List() = default;
	bool Insert(int, int&);
	bool Remove(int,int&);
private:
	LinkNode* first;
};
//插入算法
bool List::Insert(int i, int& x) {
	//将新元素x插入到第i个结点之后，i=0表示插入到第1个结点之前；
	if (first == NULL || i == 0) {
		LinkNode* newNode = new LinkNode(x);
		//shared_ptr<LinkNode> newNode = make_shared<LinkNode>();
		if (newNode == NULL) { cerr << "存储分配错误\n"; exit(1); }
		newNode->link = first; first = newNode;
	}
	else {
		LinkNode* Current = first;
		for (int k = 1; k < i; k++) {
			if (Current == NULL)break;
			else Current = Current->link;
		}
		if (Current == NULL) {
			cerr << "无效的插入位置\n"; return false;
		}
		else {
			LinkNode* newNode = new LinkNode(x);
			if (newNode == NULL) { cerr << "存储分配错误\n"; exit(1); }
			newNode->link = Current->link; Current->link = newNode;
		}
	}
	return true;
}
//删除算法
bool List::Remove(int i,int& x){
	//删除第i个结点，将值传给x
	LinkNode* Current = first, * del;
	if (i == 1) {
		del = first;
		first = first->link;
	}
	else {
		for (int k = 1; k < i-1; k++) {			
			if (Current == NULL)
				break;
			else
			Current = Current->link;
		}
			if (Current == NULL || Current->link == NULL) {
				cerr << "无效的删除位置\n";
				return false;
			}
			del = Current->link;
			Current->link =del->link;
	}
	x = del->data;
	delete del;
	return true;
}

附带头结点的单链表

#pragma once
#include <iostream>
#include <memory>
#include <vector>
using namespace std;
class LinkNode;
class List {
public:
	List() = default;
	bool Insert(int,int&);//插入
	bool Delete(int,int&);//删除
	void Print();//输出链表
	void Print(int i);//输出第i个结点
	shared_ptr<LinkNode> Locate(int i);//返回第i个结点
	int FindMax();//返回最大值
	int FindMax(int& x);//返回最大值并将其所在结点位置i存入x;
	vector<int> find_number(int x);//查找具有给定值的结点,返回具有给定值的结点的vector
	bool create(vector<int>);//根据vector建立链表
	void tidyup();//删除非递减有序链表中值相同的结点
	void sort();//将链表从大到小排序
private:
	shared_ptr<LinkNode> FindMaxLocation();//返回指向最大值结点前一个结点的指针
	shared_ptr<LinkNode> head_node = make_shared<LinkNode>();
};

class LinkNode {
public:
	LinkNode() { data = 0; link = NULL; }
	friend class List;
private:
	int data;
	shared_ptr<LinkNode> link;
};

bool List::Insert(int i,int& x){
	//将x插入到第i个结点之后
	if (i < 0) {
		cerr << "参数无效\n" << endl;
		return false;
	}
	shared_ptr<LinkNode> Current=head_node;
	for (int a = 0; a < i; a++) {
		if (Current == NULL)
			break;
		else
		Current = Current->link;
	}
	if (Current == NULL){
		cerr << "没有这个结点" << endl;
		return false;
	}
	else{
	shared_ptr<LinkNode> new_node = make_shared<LinkNode>();
	new_node->data = x;
	new_node->link = Current->link;
	Current->link= new_node;
	return true;
	}
}
bool List::Delete(int i,int& x) {
	//删除第i个结点，返回第i个结点的data
	if (i <= 0){
		cerr << "参数无效\n" << endl;
		return false;
	}
	else {
		shared_ptr<LinkNode> Current = head_node;
		for (int a = 0; a < i-1; a++) {
			if (Current == NULL)
				break;
			Current = Current->link;
		}
		if(Current==NULL||Current->link==NULL){
			cerr << "参数无效\n" << endl;
			return false;
		}
		x = Current->link->data;
		Current->link = Current->link->link;
	}
	return true;
}
void List::Print() {
	 shared_ptr<LinkNode> Current = head_node->link;
	while (Current!= NULL) {
		cout << Current->data << ends;
		Current = Current->link;
	}
	cout << endl;
}
void List::Print(int i) {
	shared_ptr<LinkNode> Current = Locate(i);
	cout << Current->data << endl;
}
shared_ptr<LinkNode> List::Locate(int i) {
	//返回第i个结点的地址，若找不到返回NULL
	shared_ptr<LinkNode> Current = head_node;
	for (int a = 0; a < i; a++){
		if (Current == NULL)
			break;
		else
		Current = Current->link;
	}
	if (Current == NULL) {
		return NULL;
	}
	return Current;
}
shared_ptr<LinkNode> List::FindMaxLocation() {
	shared_ptr<LinkNode> Current = head_node;
	shared_ptr<LinkNode> max = head_node;
	while (Current->link != NULL) {
		if (max->link->data < Current->link->data)
			max = Current;
		Current = Current->link;
	}
	return max;
}
int List::FindMax(int& x) {
	int CurNode = 1;
	shared_ptr<LinkNode> Current = head_node->link;
	shared_ptr<LinkNode> max = Current;
	while (Current != NULL) {
		if (max->data < Current->data) {
			max = Current;
			x = CurNode;
		}
		Current = Current->link;
		CurNode++;
	}
	return max->data;
}
int List::FindMax() {
	shared_ptr<LinkNode> Current = head_node->link;
	shared_ptr<LinkNode> max = Current;
	while (Current != NULL) {
		if (max->data < Current->data) {
			max = Current;
		}
		Current = Current->link;
	}
	return max->data;
}
vector<int> List::find_number(int x) {
	vector<int> node;
	int count = 0;
	shared_ptr<LinkNode> Current = head_node->link;
	for (Current; Current != NULL; Current = Current->link) {
		count++;
		if (Current->data == x)
			node.push_back(count);
	}
	return node;
}
bool List::create(vector<int> vec) {
	for (int i = vec.size()-1;i>=0;i--) {
		Insert(0, vec[i]);
	}
	return true;
}
void List::tidyup() {
	shared_ptr<LinkNode> Current = head_node->link;
	while (Current->link != NULL) {
		if (Current->data == Current->link->data) {
			Current->link = Current->link->link;
		}
		else
			Current = Current->link;
	}
}
void List::sort() {
	shared_ptr<LinkNode> Current_find = head_node, max_find;
	shared_ptr<LinkNode> Current = head_node,max_before,max,temp;
	while(Current->link->link!=NULL){
		Current_find = Current;
		max_find = Current;
		while (Current_find->link != NULL) {
			if (max_find->link->data < Current_find->link->data)
				max_find = Current_find;
			Current_find = Current_find->link;
		}
	max_before = max_find;
		temp = Current->link;
		max = max_before->link;
		Current->link = max_before->link;
		max_before->link = max->link;
		max->link = temp;
		Current = max;
	}
}

双向循环链表

只写了一个方向上的插入和输出，删除有点懒得写了。

#pragma once
#include<iostream>
#include<memory>
using namespace std;

class LinkNode {
public:
	LinkNode() { data = 0; l_link = NULL, r_link = NULL; }
	friend class dList;
private:
	int data;
	shared_ptr<LinkNode> l_link, r_link;
};

class dList {
public:
	dList() { shared_ptr<LinkNode>h_node = make_shared<LinkNode>(); h_node->l_link = h_node->r_link = h_node; head_node = h_node; }
	bool Insert(int i, int& x);//将x插入到第i个结点之后
	void Print();//输出链表
private:
	shared_ptr<LinkNode> head_node;
};



bool dList::Insert(int i, int& x) {
	//将x插入到第i个结点之后
	if (i < 0) {
		cerr << "参数无效\n" << endl;
		return false;
	}
	shared_ptr<LinkNode> Current = head_node;
	//插入空表
	if (head_node->r_link == head_node) {
		if (i == 0) {
			shared_ptr<LinkNode> new_node = make_shared<LinkNode>();
			new_node->data = x;
			new_node->r_link = head_node->r_link;
			head_node->r_link = new_node;
			new_node->l_link = head_node;
			head_node->l_link = new_node;
			return true;
		}
		else
			return false;
	}
	//非空表
	for (int a = 0; a < i; a++) {
			Current = Current->r_link;
			if (Current == head_node)
				break;
	}
	if (Current == head_node&&i!=0) {
		cerr << "没有这个结点" << endl;
		return false;
	}
	else {
		shared_ptr<LinkNode> new_node = make_shared<LinkNode>();
		new_node->data = x;
		new_node->r_link = Current->r_link;
		new_node->l_link = Current;
		if (Current->r_link == head_node)
			head_node->l_link = new_node;
		Current->r_link = new_node;
		return true;
	}
}
void dList::Print() {
	shared_ptr<LinkNode> Current = head_node->r_link;
	while (Current!= head_node) {
		cout << Current->data << ends;
		Current = Current->r_link;
	}
}