Lesson 11 - doubly linked list
1. The single list of limitations
(1) a single linked list node only one point to the next node pointer.
(2) a single list of data elements can not access their precursor elements directly.
l Reverse access a single list of elements is extremely time-consuming operation!
len = LinkList_Length(list);
for (i = len-1; len> = 0; I--)
{
LinkListNode* p = LinkList_Get(list,i);
// access the data elements in the elements p
}
2. Definition of a doubly linked list
In the node to add a single list pointer pointing to its pre prodromal.
3. doubly linked list has a single list of all operations
(1) to create lists.
(2) the destruction of the list.
(3) obtaining the length of the list.
(4) Clear list.
(5) obtaining a first operation element pos.
(6) inserting the element into the position pos.
(7) Delete position p.
4. The two-way linked list insert
current->next = node;
node->next =next;
next->pre = node;
node->pre = current;
5. doubly linked list deletion
current->next = next;
next-> = current;
6. The new operating doubly linked list
(1) Get current point of the cursor data elements.
(2) reset the cursor points to the first data element of the list.
(3) Move the cursor to point to the next data element of the list.
(4) Move the cursor to point to a linked list of data elements.
(5) directly specifying a data element to delete the list.
DLinkListNode* DLinkList_DeleteNode(DLinkList* list, DLinkListNode* node);
DLinkListNode* DLinkList_Reset(DLinkList* list);
DLinkListNode* DLinkList_Current(DLinkList* list);
DLinkListNode* DLinkList_Next(DLinkList* list);
DLinkListNode* DLinkList_Pre(DLinkList* list);
DLinkList.h
#ifndef _DLINKLIST_H_
#define _DLINKLIST_H_
typedef void DLinkList;
typedef struct _tag_DLinkListNode DLinkListNode;
struct _tag_DLinkListNode
{
DLinkListNode* next;
DLinkListNode * for;
};
DLinkList* DLinkList_Create();
void DLinkList_Destroy(DLinkList* list);
void DLinkList_Clear(DLinkList* list);
int DLinkList_Length(DLinkList* list);
int DLinkList_Insert(DLinkList* list, DLinkListNode* node, int pos);
DLinkListNode* DLinkList_Get(DLinkList* list, int pos);
DLinkListNode* DLinkList_Delete(DLinkList* list, int pos);
DLinkListNode* DLinkList_DeleteNode(DLinkList* list, DLinkListNode* node);
DLinkListNode* DLinkList_Reset(DLinkList* list);
DLinkListNode* DLinkList_Current(DLinkList* list);
DLinkListNode* DLinkList_Next(DLinkList* list);
DLinkListNode* DLinkList_Pre(DLinkList* list);
#endif
DLinkList.c
#include <stdio.h>
#include <malloc.h>
#include "DLinkList.h"
typedef struct _tag_DLinkList
{
DLinkListNode header;
DLinkListNode* slider;
int length;
} TDLinkList;
DLinkList* DLinkList_Create() // O(1)
{
TDLinkList* ret = (TDLinkList*)malloc(sizeof(TDLinkList));
if( ret != NULL )
{
ret->length = 0;
ret->header.next = NULL;
ret->header.pre = NULL;
direction> slider = NULL;
}
Return the right;
}
void DLinkList_Destroy(DLinkList* list) // O(1)
{
free(list);
}
void DLinkList_Clear(DLinkList* list) // O(1)
{
TDLinkList* sList = (TDLinkList*)list;
if( sList != NULL )
{
sList->length = 0;
sList->header.next = NULL;
sList->header.pre = NULL;
sList->slider = NULL;
}
}
int DLinkList_Length(DLinkList* list) // O(1)
{
TDLinkList* sList = (TDLinkList*)list;
int ret = -1;
if( sList != NULL )
{
ret = sList->length;
}
Return the right;
}
int DLinkList_Insert(DLinkList* list, DLinkListNode* node, int pos) // O(n)
{
TDLinkList* sList = (TDLinkList*)list;
int ret = (sList != NULL) && (pos >= 0) && (node != NULL);
int i = 0;
if( ret )
{
DLinkListNode* current = (DLinkListNode*)sList;
DLinkListNode* next = NULL;
for(i=0; (i<pos) && (current->next != NULL); i++)
{
current = current->next;
}
next = current->next;
current->next = node;
node->next = next;
if( next != NULL )
{
next->pre = node;
}
node->pre = current;
if( sList->length == 0 )
{
node->pre = NULL;
sList->slider = node;
}
sList->length++;
}
Return the right;
}
DLinkListNode* DLinkList_Get(DLinkList* list, int pos) // O(n)
{
TDLinkList* sList = (TDLinkList*)list;
DLinkListNode * right = NULL;
int i = 0;
if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )
{
DLinkListNode* current = (DLinkListNode*)sList;
for(i=0; i<pos; i++)
{
current = current->next;
}
ret = current->next;
}
Return the right;
}
DLinkListNode* DLinkList_Delete(DLinkList* list, int pos) // O(n)
{
TDLinkList* sList = (TDLinkList*)list;
DLinkListNode * right = NULL;
int i = 0;
if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )
{
DLinkListNode* current = (DLinkListNode*)sList;
DLinkListNode* next = NULL;
for(i=0; i<pos; i++)
{
current = current->next;
}
ret = current->next;
next = ret->next;
current->next = next;
if( next != NULL )
{
next->pre = current;
if( current == (DLinkListNode*)sList )
{
next->pre = NULL;
}
}
if (sList-> == right slider)
{
sList->slider = next;
}
sList->length--;
}
Return the right;
}
DLinkListNode* DLinkList_DeleteNode(DLinkList* list, DLinkListNode* node)
{
TDLinkList* sList = (TDLinkList*)list;
DLinkListNode * right = NULL;
int i = 0;
if( sList != NULL )
{
DLinkListNode* current = (DLinkListNode*)sList;
for(i=0; i<sList->length; i++)
{
if( current->next == node )
{
ret = current->next;
break;
}
current = current->next;
}
if( ret != NULL )
{
DLinkList_Delete(sList, i);
}
}
Return the right;
}
DLinkListNode* DLinkList_Reset(DLinkList* list)
{
TDLinkList* sList = (TDLinkList*)list;
DLinkListNode * right = NULL;
if( sList != NULL )
{
sList->slider = sList->header.next;
K = sList-> slider;
}
Return the right;
}
DLinkListNode* DLinkList_Current(DLinkList* list)
{
TDLinkList* sList = (TDLinkList*)list;
DLinkListNode * right = NULL;
if( sList != NULL )
{
K = sList-> slider;
}
Return the right;
}
DLinkListNode* DLinkList_Next(DLinkList* list)
{
TDLinkList* sList = (TDLinkList*)list;
DLinkListNode * right = NULL;
if( (sList != NULL) && (sList->slider != NULL) )
{
K = sList-> slider;
sList->slider = ret->next;
}
Return the right;
}
DLinkListNode* DLinkList_Pre(DLinkList* list)
{
TDLinkList* sList = (TDLinkList*)list;
DLinkListNode * right = NULL;
if( (sList != NULL) && (sList->slider != NULL) )
{
K = sList-> slider;
sList-> direction slider => pre;
}
Return the right;
}
main.c
#include <stdio.h>
#include <stdlib.h>
#include "DLinkList.h"
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
struct Value
{
DLinkListNode header;
int v;
};
int main(int argc, char *argv[])
{
int i = 0;
DLinkList* list = DLinkList_Create();
struct Value* pv = NULL;
struct Value v1;
struct Value v2;
struct Value v3;
struct Value v4;
struct Value v5;
v1.v = 1;
v2.v = 2;
v3.v = 3;
v4.v = 4;
v5.v = 5;
DLinkList_Insert(list, (DLinkListNode*)&v1, DLinkList_Length(list));
DLinkList_Insert(list, (DLinkListNode*)&v2, DLinkList_Length(list));
DLinkList_Insert(list, (DLinkListNode*)&v3, DLinkList_Length(list));
DLinkList_Insert(list, (DLinkListNode*)&v4, DLinkList_Length(list));
DLinkList_Insert(list, (DLinkListNode*)&v5, DLinkList_Length(list));
for(i=0; i<DLinkList_Length(list); i++)
{
pv = (struct Value*)DLinkList_Get(list, i);
printf("%d\n", pv->v);
}
printf("\n");
DLinkList_Delete(list, DLinkList_Length(list)-1);
DLinkList_Delete(list, 0);
for(i=0; i<DLinkList_Length(list); i++)
{
pv = (struct Value*)DLinkList_Next(list);
printf("%d\n", pv->v);
}
printf("\n");
DLinkList_Reset(list);
DLinkList_Next(list);
pv = (struct Value*)DLinkList_Current(list);
printf("%d\n", pv->v);
DLinkList_DeleteNode(list, (DLinkListNode*)pv);
pv = (struct Value*)DLinkList_Current(list);
printf("%d\n", pv->v);
DLinkList_Pre(list);
pv = (struct Value*)DLinkList_Current(list);
printf("%d\n", pv->v);
printf("Length: %d\n", DLinkList_Length(list));
DLinkList_Destroy(list);
return 0;
}
summary
l doubly linked list based on a single list pointer points to the predecessor increased.
L The function doubly linked list can completely replace the use of a single list.
l circular list Next, Pre operation can be efficiently and Current.
l traversing all the elements in the list.