数据结构——链表

学数据结构之前按照自己的理解写的链表模板，不好勿喷。图省事就把所有的函数写在了类里面，这不是个好的做法

/*
* My_list.h
*
*  Created on: 2016年2月3日
*      Author: triose
*/
#include<iostream>
using namespace std;

#ifndef MY_LIST_H_
#define MY_LIST_H_

/* Define of  elements */
template <class T>
class ListElmt {
public:
T data;
ListElmt * next;
ListElmt(T data_) {
data = data_;
next = NULL;
}
};

/* Define of My_list */
template <class T>
class My_list {
private :
int size;
ListElmt<T> *head;
ListElmt<T> *tail;
public :
My_list() {												//构造函数
size = 0;
head = NULL;
tail = NULL;
}

~My_list() {												//析构函数,移除并删除每个结点(删除操作在移除函数里就已完成)
this->delete_all();
}

void ins_next(ListElmt<T> *element, int pos) {				//插入函数,把element插入到第pos个结点的后面
if(size == 0) {										//空表的情况
head = element;
tail = element;
size ++;
return ;
}
if(pos == -1 ) {										//插入表头
element->next = head;
head = element;
size ++;
return ;
}
ListElmt<T> *current_elmt = head;						//插入表中
int index = 0;
while(current_elmt->next != NULL && index < pos) {
index ++;
current_elmt = current_elmt->next;
}
if(index == pos) {
element->next = current_elmt->next;
current_elmt->next = element;
if(pos == size - 1) {
tail = element;
}
size++;
return ;
}
}

ListElmt<T> * rem_next(int pos) {							//移除函数，移除并返回pos位置之后的结点
ListElmt<T> * re_element = head;
ListElmt<T> * delete_element = head;
if(size == 0) {										//空表，操作失败
return NULL;
}
if(pos == -1) {										//移除表头元素
head = head->next;
size--;
delete delete_element;
return re_element;
}
ListElmt<T> *current_elmt = head;						//移除其他位置元素
int index = 0;
while(current_elmt->next != NULL && index < pos) {
index++;
current_elmt = current_elmt->next;
}
if(index == pos) {
re_element = current_elmt->next;
delete_element = current_elmt->next;
current_elmt->next = current_elmt->next->next;
if(pos == size - 2) {
tail = current_elmt;
}
delete delete_element;
size--;
}
return re_element;
}

void delete_all() {									//移除所有元素
while(size > 0) {
this->rem_next(-1);
}
}

void output(){										/* For debug	*/
ListElmt<T> * current_elmt = head;
int index = 0;
while((index++) < size) {
cout << current_elmt->data << ' ';
current_elmt = current_elmt->next;
}
cout << endl;
cout << "tou:\n" << head->data << endl;
cout << "wei:\n" << tail->data << endl;
cout << "size:\n" << size << endl;
}
};

#endif /* MY_LIST_H_ */

接下来是双向链表的模板

/*
* DList.h
*
*  Created on: 2016年2月3日
*      Author: triose
*/

#ifndef DLIST_H_
#define DLIST_H_

#include <iostream>
using namespace std;

template <class T>
class DListElmt {
public:
T data;
DListElmt * prev;
DListElmt * next;
DListElmt(T data_) {
data = data_;
prev = NULL;
next = NULL;
}
};

template <class T>
class DList {
private:
DListElmt<T> *head;
DListElmt<T> *tail;
int size;
public:

DList() {
head = NULL ;
tail = NULL;
size = 0;
}

~DList() {
if(size)
delete_all();
}

/*	public Interface*/
void ins_next(DListElmt<T> * element, int pos) {
if(size == 0) {
head = element;
tail = element;
size++;
return ;
}
if(pos == -1) {
element->next = head;
head->prev = element;
head = element;
size++;
return ;
}
DListElmt<T> *current_elmt = head;
int index = 0;
while(current_elmt->next != NULL && index < pos) {
index++;
current_elmt = current_elmt->next;
}
if(index == pos) {
element->prev = current_elmt;
element->next = current_elmt->next;
current_elmt->next = element;
if(current_elmt->next->next != NULL) {
current_elmt->next->next->prev = element;
}
if(pos == size - 1) {
tail = element;
}
size++;
return ;
}
}

DListElmt<T> *rem_next(int pos) {
DListElmt<T> * re_element = head;
DListElmt<T> * delete_elmt = head;
if(size == 0) {
return NULL;
}
if(pos == -1) {
head = head->next;
delete delete_elmt;
size--;
return re_element;
}
DListElmt<T> * current_elmt = head;
int index = 0;
while(current_elmt->next != NULL && index < pos) {
current_elmt = current_elmt->next;
index++;
}
if(index == pos) {
delete_elmt = current_elmt->next;
re_element = current_elmt->next;
current_elmt->next = current_elmt->next->next;
if(current_elmt->next != NULL)
current_elmt->next->prev = current_elmt;
if(pos == size - 2) {
tail = current_elmt;
}
size--;
}
return re_element;
}

void delete_all() {
while(size > 0) {
this->rem_next(-1);
}
}

void output() {										/*For debug*/
cout << "从前往后:" << endl;
DListElmt<T> * current_elmt = head;
for(int i = 0; i < size; i++) {
cout << current_elmt->data << " " ;
current_elmt = current_elmt->next;
}
cout << endl;
cout << "从后往前:" << endl;
current_elmt = tail;
for(int i = 0; i < size; i++) {
cout << current_elmt->data << " ";
current_elmt = current_elmt->prev;
}
cout << endl;
cout << "head : " << endl;
cout << head->data << endl;
cout << "tail : " << endl;
cout << tail->data << endl;
cout << "size : " << endl;
cout << size << endl;
}
};

#endif /* DLIST_H_ */

以下为2016.4.8编辑：

贴一个数据结构作业的代码，双向链表，纯C。

/*
* List.h
*
* Created on: 2016年3月28日
* Author: Triose
*/

#ifndef LIST_H_
#define LIST_H_

#include<stdlib.h>
#include"Book.h"

typedef struct ListElmt_ {
void *data;
struct ListElmt_ *next;
struct ListElmt_ *prev;
}ListElmt;
#define pfElmt(current_elmt) (printf("%s\t%s\t%lf\n", ((Book*)(current_elmt->data))->ISBN, ((Book*)(current_elmt->data))->name, ((Book*)(current_elmt->data))->price))
#define pfElmt_to_file(current_elmt, fptr_out) (fprintf(fptr_out, "%s\t%s\t%lf\n", ((Book*)(current_elmt->data))->ISBN, ((Book*)(current_elmt->data))->name, ((Book*)(current_elmt->data))->price))

/* Public Interface. */
ListElmt * new_Elmt(const void *data_) {
ListElmt * newelement = (ListElmt *) malloc (sizeof(ListElmt));
newelement->data = (void *)data_;
newelement->prev = NULL;
newelement->next = NULL;
return newelement;
}

typedef struct List_ {
ListElmt * head;
ListElmt * tail;
int size;
}List;

/* Public Interface. */
#define List_size(list) ((list)->size)
#define List_head(list) ((list)->head)
#define List_tail(list) ((list)->tail)

/* List_init. */
void List_init(List * list) {
list->head = NULL;
list->tail = NULL;
list->size = 0;
}

/* List_ins. */
int List_ins(List * list, ListElmt * newelement, int pos) {
pos--;
if(pos < 0 || pos > list->size) {
return -1;
}
if(pos && !list->size) {
return -1;
}
if(!pos) {
newelement->next = list->head;
if(list->head) { //如果list->head != NULL 证明不是空表，至少有一个元素
list->head->prev = newelement;
}
else { //否则就是空表，只需让尾指针也指向newelement即可
list->tail = newelement;
}
list->head = newelement; //头指针指向插入表头的节点
list->size++; //维护表长
return 0; //正确返回
}
ListElmt * current_elmt = list->head;
int index = 0;
while(current_elmt->next && index < pos - 1) {
index++;
current_elmt = current_elmt->next;
}
if(index == pos - 1) { //此时current_elmt指向插入位置的前一个元素
// current_elmt->next = newelement;
newelement->next = current_elmt->next;
newelement->prev = current_elmt;
if(current_elmt->next) { //如果current_elmt->next != NULL 那么current_elmt不是表尾元素
current_elmt->next->prev = newelement;
}
else { //current_elmt是表尾元素
list->tail = newelement;
}
current_elmt->next = newelement;
list->size++; //维护表长
return 0; //正确返回
}
return -1; //除所有限定正确情况之外全都是不正确
}

/* List_rem. */
int List_rem(List * list, int pos) {
pos--;
if(!list->size) { //空表
return -1;
}
if(pos < 0 || pos >= list->size) { //位置不正确
return -1;
}
if(!pos) { //删除头结点
ListElmt *delete_elmt = list->head;
list->head = list->head->next; //头指针指向第一个元素
if(list->head) { //如果第一个元素不是空，即删除第0个元素之后链表还有元素
list->head->prev = NULL; //把现在的头结点的前指针置空
}
else { //否则，即链表之有要删除的一个元素，那么把链表尾指针也置空
list->tail = NULL;
}
free(delete_elmt); //删除待删除元素
list->size--;
return 0; //返回正确
}
ListElmt *current_elmt = list->head;
int index = 0;
while(current_elmt->next && index < pos - 1) { //遍历，令current_elmt指向被删除的前一个元素
current_elmt = current_elmt->next;
index++;
}
if(index == pos - 1) {
ListElmt *delete_elmt = current_elmt->next;
current_elmt->next = current_elmt->next->next;
if(current_elmt->next) { //同理
current_elmt->next->prev = current_elmt;
}
else {
list->tail = current_elmt;
}
free(delete_elmt);
list->size--;
return 0;
}
return -1; //所有非限定情况全部返回错误
}

/* List_Inverse. */
void List_Inverse(List * list) {
if(!list->size || list->size == 0) { //空表或者单元素表直接返回
return ;
}
/* 至少有两个元素. */
ListElmt * current_elmt = list->head;
ListElmt * next_elmt = current_elmt->next;
int index = 0;
while(index < list->size - 2) { //交换前后指针
ListElmt * tmp_elmt = next_elmt->next;
next_elmt->prev = tmp_elmt;
next_elmt->next = current_elmt;
current_elmt = next_elmt;
next_elmt = tmp_elmt;
index++;
}
list->head->prev = list->head->next; //处理头尾指针和指向
list->head->next = NULL;
list->tail->next = list->tail->prev;
list->tail->prev = NULL;
ListElmt *tmp_elmt = list->head;
list->head = list->tail;
list->tail = tmp_elmt;
return ;
}

/* List_get_elmt. */
ListElmt * List_get_elmt(List * list, int pos) {
pos--;
if(pos < 0 || pos >= list->size){
return NULL;
}
ListElmt * current_elmt = list->head;
int index = 0;
while(index < pos) {
index++;
current_elmt = current_elmt->next;
}
return current_elmt;
}

/*****************************************************************************
* 链表的快速排序采用快排并不是最优方案（对，我亲身实践了，因为指针的确会乱而且不止是交换数据那么简单，所以我放弃采用快排而自学了归并）
* c++ list头文件里默认排序是堆排序。
* 这三个函数是我读了list头文件里的_Sort函数写出来的。
* 毕竟这不是工业级代码。。。所以可能会有Bug
*****************************************************************************/

int cmp(const ListElmt * u, const ListElmt * v) { //用于归并排序的比较函数
return (((Book *)u->data)->price > ((Book *)v->data)->price ? 1 : 0);
}

ListElmt * get_mid(ListElmt * start, int lenth) { //给定头结点，找出中间节点的函数
int mid = 1;
ListElmt * current_elmt = start;
while(mid < lenth ) {
mid++;
current_elmt = current_elmt->next;
}
return current_elmt;
}
void cut_down(ListElmt * elmt, int len) { //切断指向范围之外的指针，主要是头结点的prev指针和尾结点的next指针
ListElmt * current_elmt = elmt;
current_elmt->prev = NULL;
int i = 1;
while(i < len) {
i++;
current_elmt = current_elmt->next;
}
current_elmt->next = NULL;
}

ListElmt * merge(ListElmt * u, ListElmt * v, int (*cmp)(const ListElmt *u, const ListElmt *v), int uLen, int vLen) {
/*这个函数用来归并两段链表，两段链表的头结点分别是u和v. */
cut_down(u, uLen); //为了避免死循环，必须切断指向这两段链表范围之外的指针
cut_down(v, vLen);
int i = 0,
j = 0;
ListElmt * _newstart = v; //先把v作为合并后的头结点
if(cmp(u, v)) { //如果u比v大（这里以由降序为例），则合并后的头节点为u
_newstart = u;
}
ListElmt * index = 0; //用来连接各个节点的指针
while(i < uLen && j < vLen) { //合并过程，连接各个指针
if(cmp(u,v)) {
if(!index) {
index = u;
}
else {
index->next = u;
u->prev = index;
index = index->next;
}
i++;
if(i == uLen) {
index->next = v;
v->prev = index;
}
u = u->next;
}
else {
if(!index) {
index = v;
}
else {
index->next = v;
v->prev = index;
index = index->next;
}
j++;
if(j == vLen) {
index->next = u;
u->prev = index;
}
v = v->next;
}
}
return _newstart;
}

ListElmt * merge_sort(List * list, ListElmt * start, ListElmt * end, int (*cmp)(const ListElmt *u, const ListElmt *v), int lenth) {
if(lenth < 2) { //只剩一个元素的时候，直接return就好
return start;
}
int uLen = lenth / 2 + (lenth % 2); //二分的两部分的长度
int vLen = lenth - uLen;
ListElmt * mid = get_mid(start, uLen); //二分之前首先得找到中间的元素
ListElmt * _newstart = merge(merge_sort(list, start, mid, cmp, uLen), merge_sort(list, mid->next, end, cmp, vLen), cmp, uLen, vLen);
list->head = _newstart; //更新原链表的头结点和尾结点(这段比较啰嗦)
ListElmt * current_elmt = list->head;
while(current_elmt->next) {
current_elmt = current_elmt->next;
}
list->tail = current_elmt;
return _newstart;
}

void find_name(List *list, char * name_) {
ListElmt * current_elmt = list->head;
int index = 0;
while(current_elmt) { //遍历链表，所有重名的书全部输出
if(strcmp(((Book *)current_elmt->data)->name, name_) == 0) {
index = 1;
printf("%s\t%s\t%lf\n", ((Book *)current_elmt->data)->ISBN, ((Book *)current_elmt->data)->name, ((Book *)current_elmt->data)->price);
}
current_elmt = current_elmt->next;
}
if(!index) {
printf("找不到名字为：%s的书\n", name_);
}
return ;
}

void find_ISBN(List *list, char * isbn_) {
ListElmt * current_elmt = list->head;
int index = 0;
while(current_elmt) { //遍历链表，所有ISBN相同的全部输出(不排除有相同的ISBN)
if(strcmp(((Book *)current_elmt->data)->ISBN, isbn_) == 0) {
index = 1;
printf("%s\t%s\t%lf\n", ((Book *)current_elmt->data)->ISBN, ((Book *)current_elmt->data)->name, ((Book *)current_elmt->data)->price);
}
current_elmt = current_elmt->next;
}
if(!index) {
printf("找不到标号为：%s的书\n", isbn_);
}
return ;
}

/* List_destroy. */
void List_destroy(List * list) { //析构函数,移除所有节点
while(list->size) {
List_rem(list, 1);
}
}

#endif /* LIST_H_ */