单链表
#include <iostream>
using namespace std;
typedef int dt;
struct Node {
Node* link;
dt data;
Node(Node* ptr = NULL) { link = ptr; }
Node(const dt& item, Node* ptr = NULL) { data = item, link = ptr; }
};
class List {
public:
List() { first = new Node; }
List(const dt& x) { first = new Node(x); }
List(const List& ln);
~List() { makeEmpty(); };
void makeEmpty();
bool Insert(int, dt&);
bool Remove(int i, dt& x);
bool isEmpty()const { return first->link == NULL ? 1 : 0; }
int size()const { return length; }
void show();
Node* getHead()const { return first; }
Node* Search(dt);
Node* Locate(int)const;
bool getDate(int i, dt& x)const;
void setDate(int i, dt& x);
void output();
void Create(int n);
protected:
Node* first;
int length;
};
List::List(const List& ln) {
dt value;
Node* srcptr = ln.getHead();
Node* destptr = first = new Node;
while (srcptr->link) {
value = srcptr->link->data;
destptr->link = new Node(value);
destptr = destptr->link;
srcptr = srcptr->link;
length++;
}
destptr->link = NULL;
}
void List::makeEmpty() {
Node* q;
while (first->link) {
q = first->link;
first->link = q->link;
delete q;
}
}
Node* List::Search(dt x) {
Node* p = first->link;
while (p) {
if (p->data == x)break;
else p = p->link;
}
return p;
}
Node* List::Locate(int i) const{
Node* p = first->link;
if (i < 0)return NULL;
int k = 0;
while (p && k < i) {
p = p->link;
k++;
}
return p;
}
bool List::getDate(int i, dt& x)const {
if (i < 0)return NULL;
Node* p = Locate(i);
if (p == NULL)return 0;
else { x = p->data; return 1; }
}
void List::setDate(int i, dt& x) {
if (i <= 0)return;
Node* p = Locate(i);
if (p == NULL)return ;
else p->data = x;
}
bool List::Insert(int i, dt& x) {
if (first == NULL || i == 0) {
Node* newnode = new Node(x);
if (newnode == NULL) { cerr << "存储分配错误!" << endl; exit(1); }
newnode->link = first;
first = newnode;
}
else {
Node* p = Locate(i - 1);
if (p == NULL)return 0;
Node* newnode = new Node(x);
if (newnode == NULL) { cerr << "存储分配错误!" << endl; exit(1); }
newnode->link = p->link;
p->link = newnode;
}
length++;
return 1;
}
bool List::Remove(int i, dt& x) {
Node* p = Locate(i - 1);
if (p == NULL || p->link == NULL)return 0;
Node* del = p->link;
p->link = del->link;
x = del->data; delete del; length--; return 1;
}
void List::output() {
Node* p = first->link;
while (p) {
cout << p->data << " ";
p = p->link;
}
cout << endl;
}
void List::Create(int n)
{
if (n < 0) {
printf("error\n");
return;
}
Node* ptemp = NULL;
Node* pnew = NULL;
this->length = n;
ptemp = this->first;
for (int i = 0; i < n; i++) {
pnew = new Node;
pnew->link = NULL;
cout << "输入第" << i + 1 << "个节点值" << endl;
dt x;
cin >> x;
pnew->data = x;
ptemp->link = pnew;
ptemp = pnew;
}
cout << "创建完成" << endl;
return;
}
int main() {
List ls1;
ls1.Create(5);
ls1.output();
cout << ls1.size() << endl;
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int a;
cin >> a;
ls1.Insert(i, a);
}
ls1.output();
cout << ls1.size() << endl;
}
循环链表
#include <iostream>
using namespace std;
template <class T>
class Node{
public:
Node<T>* next;
Node<T>* prev;
T data;
};
template <class T>
class List{
public:
List();
List(const List& ln);
~List();
void add(T e);
void ascSort();
void remove(T index);
T find(int index);
bool isEmpty();
int size();
void show();
void resShow();
void removeAll();
private:
Node<T>* head;
Node<T>* tail;
int length;
};
template <typename T>
List<T>::List(){
head = new Node<T>;
tail = new Node<T>;
head->next = tail;
head->prev = nullptr;
tail->next = nullptr;
tail->prev = head;
length = 0;
}
template <typename T>
List<T>::List(const List& ln){
head = new Node<T>;
head->prev = nullptr;
tail = new Node<T>;
head->next = tail;
tail->prev = head;
length = 0;
Node<T>* temp = ln.head;
while (temp->next != ln.tail){
temp = temp->next;
tail->data = temp->data;
Node<T>* p = new Node<T>;
p->prev = tail;
tail->next = p;
tail = p;
length++;
}
tail->next = nullptr;
}
template <typename T>
void List<T>::add(T e){
Node<T>* temp = this->tail;
tail->data = e;
tail->next = new Node<T>;
Node<T>* p = tail;
tail = tail->next;
tail->prev = p;
tail->next = nullptr;
length++;
}
template <typename T>
T List<T>::find(int index){
if (length == 0){
std::cout << "List is empty";
return NULL;
}
if (index >= length){
std::cout << "Out of bounds";
return NULL;
}
int x = 0;
T data;
Node<T>* p;
if (index < length / 2){
p = head->next;
while (p->next != nullptr && x++ != index){
p = p->next;
}
}
else {
p = tail->prev;
while (p->prev != nullptr && x++ != index){
p = p->prev;
}
}
return p->data;
}
template <typename T>
void List<T>::remove(T index){
if (length == 0){
std::cout << "List is empty";
return;
}
Node<T>* p = head;
while (p->next != nullptr){
p = p->next;
if (p->data == index){
Node<T>* temp = p->prev;
temp->next = p->next;
p->next->prev = temp;
delete p;
length--;
return;
}
}
}
template <typename T>
void List<T>::removeAll(){
if (length == 0){
return;
}
Node<T>* p = head->next;
while (p != tail){
Node<T>* temp = p;
p = p->next;
delete temp;
}
head->next = tail;
tail->prev = head;
length = 0;
}
template <typename T>
void List<T>::ascSort(){
if (length <= 1) return;
Node<T>* p = head->next;
for (int i = 0; i < length - 1; i++){
Node<T>* q = p->next;
for (int j = i + 1; j < length; j++){
if (p->data > q->data){
T temp = q->data;
q->data = p->data;
p->data = temp;
}
q = q->next;
}
p = p->next;
}
}
template <typename T>
bool List<T>::isEmpty(){
return length == 0 ? true : false;
}
template <typename T>
int List<T>::size(){
return length;
}
template <typename T>
void List<T>::show(){
if (length == 0){
std::cout << "List is empty" << std::endl;
return;
}
Node<T>* p = head->next;
while (p != tail){
std::cout << p->data << " ";
p = p->next;
}
std::cout << std::endl;
}
template <typename T>
void List<T>::resShow(){
if (length == 0)return;
Node<T>* p = tail->prev;
while (p != head){
std::cout << p->data << " ";
p = p->prev;
}
std::cout << std::endl;
}
template <typename T>
List<T>::~List(){
if (length == 0){
delete head;
delete tail;
head = nullptr;
tail = nullptr;
return;
}
while (head->next != nullptr){
Node<T>* temp = head;
head = head->next;
delete temp;
}
delete head;
head = nullptr;
}
int main(){
List<float> ls1;
ls1.add(1.1);
ls1.add(0.1);
ls1.add(6);
ls1.add(3.3);
List<float> ls2(ls1);
ls2.resShow();
std::cout << ls2.size() << std::endl;
std::cout << ls2.find(00) << std::endl;
ls2.remove(6);
ls1.resShow();
ls2.show();
system("pause");
return 0;
}