[数据结构]链表的实现-C++

昨天写了链表，目前只写了单链表，等有时间把循环链表什么的变异产品再写出来

只有头指针（没有头结点）的单链表

//SingleLinkedList.h

#pragma once


template <class T>
struct Node {
	T value;
	Node *next;
};

template <class T> 
class SingleLinkedList {
private:
	Node<T> *head;
public:
	SingleLinkedList();
	bool deleteByIndex(int index);
	bool insertByIndex(int index, T value);
	bool add(T value);
	T getValueByIndex(int index);
	Node<T>* getNodeByIndex(int index);
	Node<T>* getNodeByValue(T value);
	bool replaceByIndex(int index, T value);
};

//SingleLinkedList.cpp

#include"SingleLinkedList.h"

template <class T> SingleLinkedList<T>::SingleLinkedList() {
	head = NULL;
}

template <class T> bool SingleLinkedList<T>::deleteByIndex(int index) {
	if (index == 0) {
		head = head->next;
		return true;
	}
	else {
		Node<T> *p = head, *q = NULL;
		int i = 0;
		while (i != index - 1 && p != NULL) {
			p = p->next;
			i++;
		}
		if (p == NULL) {
			return false;
		}
		q = p->next;
		if (q == NULL) {
			return false;
		}
		p->next = q->next;
		return true;
	}
	
}

template <class T> bool SingleLinkedList<T>::insertByIndex(int index,T value) {
	if (index == 0) {
		Node<T> *n = new Node<T>;
		n->value = value;
		n->next = head;
		head = n;
		return true;
	}
	else {
		Node<T> *p = head;
		int i = 0;
		while (i != index - 1 && p != NULL) {
			p = p->next;
			i++;
		}
		if (p == NULL) {
			return false;
		}
		Node<T> *n = new Node<T>;
		n->value = value;
		n->next = p->next;
		p->next = n;
		return true;
	}
	}
	

template <class T> bool SingleLinkedList<T>::add(T value) {
	if (head == NULL) {
		head = new Node<T>;
		head->value = value;
		head->next = NULL;
	}
	else {
		Node<T> *p = head;
		while (p->next != NULL) {
			p = p->next;
		}
		Node<T> *n = new Node<T>;
		n->value = value;
		n->next = NULL;
		p->next = n;
	}
	return true;
}

template <class T> T SingleLinkedList<T>::getValueByIndex(int index) {
	Node<T> *p = head;
	int i = 0;
	while (i!=index&&p != NULL) {
		p = p->next;
		i++;
	}
	return p->Value;
}

template <class T> Node<T>* SingleLinkedList<T>::getNodeByIndex(int index) {
	Node<T> *p = head;
	int i = 0;
	while (i != index&&p != NULL) {
		p = p->next;
		i++;
	}
	return p;
}

template <class T> Node<T>* SingleLinkedList<T>::getNodeByValue(T value) {
	Node<T> *p = head;
	int i = 0;
	while (p != NULL&&p->value!=value) {
		p = p->next;
	}
	return p;
}

template <class T> bool SingleLinkedList<T>::replaceByIndex(int index,T value) {
	Node<T> *p = head;
	int i = 0;
	while (i != index&&p != NULL) {
		p = p->next;
	}
	if (p == NULL){
		return false;
	}else {
		p->value = value;
		return true;
	}
}

循环双指针链表：

CycleLinkedList.h：

#pragma once


template <class T>
struct Node {
	T value;
	Node *left;
	Node *right;
};

template <class T>
class CycleLinkedList {
private:
	Node<T> *head;
public:
	CycleLinkedList();
	bool addAtHead(T value);
	bool addAtTail(T value);
	bool isEmpty();
	bool deleteHead();
	bool deleteTail();
	T getHead();
	T getTail();
	T getByIndex(int index);
	T getByValue(T value);
};

CycleLinkedList.cpp：

#include"CycleLinkedList.h"

template <class T> CycleLinkedList<T>::CycleLinkedList() {
	head = NULL;
}

template <class T> bool CycleLinkedList<T>::addAtHead(T value) {
	if (isEmpty()) {
		head = new Node<T>;
		head->value = value;
		head->right = head;
		head->left = head;
	}
	else {
		Node<T> *tail = head->left;
		Node<T> *n = new Node<T>;
		n->value = value;
		n->right = head;
		head->left = n;
		tail->right = n;
		n->left = tail;
		head = n;
	}
	return true;
}

template <class T> bool CycleLinkedList<T>::addAtTail(T value) {
	if (isEmpty()) {
		head = new Node<T>;
		head->value = value;
		head->right = head;
		head->left = head;
	}
	else {
		Node<T> *tail = head->left;
		Node<T> *n = new Node<T>;
		n->value = value;
		n->right = head;
		head->left = n;
		tail->right = n;
		n->left = tail;
	}
	return true;
}

template <class T> bool CycleLinkedList<T>::isEmpty() {
	if (head == NULL) {
		return true;
	}
	else {
		return false;
	}
}

template <class T> bool CycleLinkedList<T>::deleteHead() {
	if (isEmpty()) {
		return false;
	}
	else {
		if (head->right == head) {
			head = NULL;
		}
		else {
			Node<T> *tail = head->left;
			head = head->right;
			head->left = tail;
			tail->right = head;
		}
		return true;
	}
}

template <class T> bool CycleLinkedList<T>::deleteTail() {
	if (isEmpty()) {
		return false;
	}
	else {
		if (head->right == head) {
			head = NULL;
		}
		else {
			Node<T> *tail = head->left;
			tail = tail->left;
			tail->right = head;
			head->left = tail;
		}
		return true;
	}
}

template <class T> T CycleLinkedList<T>::getHead() {
	if (isEmpty()) {
		return NULL;
	}
	else {
		return head->value;
	}
}

template <class T> T CycleLinkedList<T>::getTail() {
	if (isEmpty()) {
		return NULL;
	}
	else {
		return head->left->value;
	}
}

template <class T> T CycleLinkedList<T>::getByIndex(int index) {
	if (isEmpty()) {
		return NULL;
	}
	Node<T> p = head;
	int i = 0;
	while (p != head) {
		if (i == index) {
			return p;
		}
		i++;
		p = p->right;
	}
	return NULL;
}

template <class T> T CycleLinkedList<T>::getByValue(T value) {
	if (isEmpty()) {
		return NULL;
	}
	Node<T> p = head;
	while (p != head) {
		if (p->value == value) {
			return p->value;
		}
		p = p->right;
	}
	return NULL;
}