参照了Redis里面的双链表结构,可以说是完全复制粘贴,redis的双链表还是写的很通俗易懂的,没有什么花里胡哨的东西,但是redis还有个iter迭代器的结构来遍历链表。我这里就没有实现了,只是实现了双链表的基本操作
redis双链表结构有如下特点
- 多态:可以储存多种数据类型
- 双端
- 无环:也就是说head->pre==NULL tail->next=NULL
- 带有长度计数器
- 有头指针和尾指针
实现
注意,这里的链表有一个迭代器结构,方便遍历链表
#include<iostream>
#include<stdlib.h>
using namespace std;
#define START_HEAD 0
#define START_TAIL 1
struct listNode{
listNode* prev;
listNode* next;
int value; //可以是void void*类型 实现多态链表
};
struct list{
listNode* head;
listNode* tail;
int len;
};
//迭代器模式
typedef struct listIter {
listNode *next;
int direction; //遍历方向
};
//创建迭代器
listIter *listGetIterator(list *myList, int direction)
{
listIter *iter = (listIter*)malloc(sizeof(listIter));
if (direction == START_HEAD)
iter->next = myList->head;
else
iter->next = myList->tail;
iter->direction = direction;
return iter;
}
/* Release the iterator memory */
void listReleaseIterator(listIter *iter) {
free(iter);
}
//将迭代器指向开头节点
void listRewind(list *myList, listIter *li) {
li->next = myList->head;
li->direction = START_HEAD;
}
//迭代器指向尾部节点
void listRewindTail(list *myList, listIter *li) {
li->next = myList->tail;
li->direction = START_TAIL;
}
//用迭代器遍历下一个节点
listNode *listNext(listIter *iter)
{
listNode *current = iter->next;
if (current != NULL) {
if (iter->direction == START_HEAD)
iter->next = current->next;
else
iter->next = current->prev;
}
return current;
}
//初始化链表
list* listCreate(){
list* myList;
myList = (list*)malloc(sizeof(list));
myList->head = myList->tail=NULL;
myList->len=0;
return myList;
}
//移除链表元素
void listEmpty(list* list){
int len = 0;
listNode* current,*next;
current = list->head;
while(len--){
next = current->next;
free(current);
current = next;
}
list->head=list->tail=NULL;
list->len=0;
}
void listRelease(list* list){
listEmpty(list);
free(list);
list = NULL;
}
//头插
list* listAddNodeHead(list* list,int val){
listNode* node = (listNode*)malloc(sizeof(listNode));
node->value = val;
if(list->len==0){
list->head = list->tail=node;
node->prev=node->next=NULL;
}else{
node->prev = NULL;
node->next = list->head;
list->head->prev = node;
list->head = node;
}
list->len++;
return list;
}
//尾插
list* listAddNodeTail(list* myList,int val){
listNode* node = (listNode*)malloc(sizeof(listNode));
node->value = val;
if(myList->len==0){
myList->head = myList->tail = node;
node->prev=node->next=NULL;
}else{
node->prev = myList->tail;
myList->tail->next = node;
node->next=NULL;
myList->tail = node;
}
myList->len++;
return myList;
}
//插入到指定节点前面或后面
list* listInsertNode(list* list,listNode* old_node,int val,bool after){
listNode* node = (listNode*)malloc(sizeof(listNode));
node->value = val;
if(after){
node->prev = old_node;
node->next = old_node->next;
if(list->tail==old_node){
list->tail = node;
}
}else{
node->next = old_node;
node->prev = old_node->prev;
if(list->head==old_node){
list->head = node;
}
}
if(node->prev!=NULL){
node->prev->next = node;
}
if(node->next!=NULL){
node->next->prev = node;
}
list->len++;
return list;
}
//删除指定节点
void listDelNode(list* list,listNode* node){
if(node->prev)
node->prev->next = node->next;
else //是头节点
list->head = node->next;
if(node->next) //如果不是尾节点
node->next->prev = node->prev;
else
list->tail = node->prev;
free(node);
node = NULL;
list->len--;
}
//链表的复制
list* listCopy(list* old_list){
list* new_list = listCreate();
listNode* node;
listIter iter;
listRewind(old_list,&iter); //指向开头节点
while((node=listNext(&iter))!=NULL){
listAddNodeTail(new_list,node->value);
}
//listRelease(old_list);
return new_list;
}
//根据值查找节点
listNode* listSearchKey(list* myList,int val){
listNode* node;
listIter iter;
listRewind(myList,&iter);
while((node=listNext(&iter))!=NULL && node->value!=val)
;
if(node)
return node;
else
return NULL;
}
//根据索引查找节点 支持倒排序索引
listNode* listIndex(list* list,int index){
listNode* node;
if(index<0){
index = (-index)-1;
node = list->tail;
while(index-- && node) node =node->prev;
}
else{
node = list->head;
while(index-- && node) node = node->next;
}
return node;
}
//second连接到first
list* listJoin(list* first,list* second){
if(second->head)
second->head->prev = first->tail;
if(first->tail)
first->tail->next = second->head;
else //first链表是空的
first->head = second->head;
if(second->tail)
first->tail = second->tail;
first->len +=second->len;
second->head = second->tail = NULL;
second->len = 0;
return first;
}
#define dlist_for_each(pos, head)
for (pos = (head)->next; pos != NULL; pos = pos->next)
#define dlist_reverse_for_each(pos, head)
for (pos = (head)->next; pos!=NULL; pos = pos->next)
void Show_Int_List(list* myList){
listNode* node;
dlist_for_each(node,myList->head){
cout<<node->value<<endl;
}
}
int main(){
list* myList1 = listCreate();
for(int i=1;i<=5;i++)
listAddNodeTail(myList1,i);
Show_Int_List(myList1);
cout<<endl;
list* myList2 = listCreate();
for(int i=6;i<=10;i++)
listAddNodeTail(myList2,i);
Show_Int_List(myList2);
cout<<endl;
listJoin(myList1,myList2);
Show_Int_List(myList1);
cout<<endl;
cout<<listIndex(myList1,-2)->value<<endl;
cout<<endl;
list* myList3=NULL;
myList3 = listCopy(myList1);
listAddNodeHead(myList3,99);
listDelNode(myList3,listSearchKey(myList3,10));
Show_Int_List(myList3);
cout<<endl;
cout<<"len:"<<myList3->len<<endl;
return 0;
}