双向链表
2014-10-14 14:51
260 查看
双向链表需要定义一个结构体，结构体有3个属性
typedef struct __Node{
int data; 数据
struct __Node *pre; 指向前一个结点指针
struct __Node *next; 指向下一个结点指针
}Node;
其中 pre和next指针是嵌套定义。
一般链表定义一个头指针
Node *head；
指向链表第一个结点，如果链表为空的话，那么head == NULL。
双向链表一般分为init，insert, delete, search, destroy等几种操作
1、init
初始化：将头指针head置为NULL即可
2、insert
插入：这里我只实现了在表头位置插入新元素。在表头位置插入元素的话，需要注意区别处理空表和非空表的情况。
1）空表的话，因为有init过程，所以head为NULL，新元素的next指针指向head（NULL），同时设置新元素的pre指针为NULL即可。
2）非空表的话，需要设置以前的头结点元素的pre指针，因为头结点的pre指针都是NULL。其他和空表一样操作。
如果要实现在链表的指定位置插入的话，需要先遍历链表找到那个位置，然后再插入。
3、delete
删除：这里我实现了删除第一个元素和删除指定的元素。其中删除指定的元素需要查找。
4、search
查找：遍历链表进行查找即可
5、destroy
销毁：将每个结点开辟的内存分别释放，最后将头结点指针head置为NULL即可。
在以上操作过程中，要注意当链表非空时，一定要保证尾结点的next域为NULL，头结点的pre域为NULL，否则容易导致错误！
//代码部分
#include <stdio.h>
#include <stdlib.h>
//定义结点
typedef struct __Node{
int data;
struct __Node *pre;
struct __Node *next;
}Node;
//定义带头结点的双向链表
typedef struct __doublyLinkedList{
Node * head;
}dLinkedList;
//初始化：头结点置空
void init(dLinkedList *L){
if(L == NULL){
printf("链表异常/n");
return;
}
L->head = NULL;
}
//
void insert(dLinkedList *L, int data){
Node *p = NULL;
if(L == NULL){
printf("双向链表不存在/n");
return;
}
p = (Node*)malloc(sizeof(Node));
if(p == NULL){
printf("内存分配失败!/n");
return;
}
p->data = data;
p->next = L->head;
if(L->head != NULL){
L->head->pre = p;
}
p->pre = NULL;
L->head = p;
}
Node *search(dLinkedList L, int data){
Node *p = NULL;
if(L.head == NULL){
printf("链表为空/n");
return NULL;
}
p = L.head;
while(p != NULL && p->data != data){
p = p->next;
}
if(p != NULL){
printf("查找值为 %d的元素成功/n", data);
return p;
}
else{
printf("查找值为 %d的元素失败/n", data);
return NULL;
}
}
void deleteFirstData(dLinkedList *L){
Node *p = NULL;
if(L == NULL){
printf("双向链表异常!/n");
return;
}
if(L->head == NULL){
printf("双向链表为空!/n");
return;
}
p = L->head;
//only one element
if(p->next == NULL){
L->head = NULL;
free(p);
p = NULL;
printf("成功删除第一个元素!/n");
return;
}
else{
L->head = p->next;
L->head->pre = NULL;
free(p);
p = NULL;
printf("成功删除第一个元素!/n");
return;
}
}
void deleteData(dLinkedList *L, int data){
Node *p = NULL;
Node *pre = NULL;
printf("删除查找中.../n");
if((p = search(*L, data)) == NULL){
printf("删除值为 %d的元素失败/n", data);
return;
}
else{
//first element
if(p == L->head){
deleteFirstData(L, data);
return;
}
//last element
else if(p->next == NULL){
pre = p->pre;
pre->next = NULL;
free(p);
p = NULL;
printf("删除最后一个元素成功/n/n");
return;
}
else{
pre = p->pre;
pre->next = p->next;
p->next->pre = pre;
free(p);
p = NULL;
printf("删除值为 %d的元素成功/n/n", data);
return;
}
}
}
void traversal(dLinkedList L){
Node *p = NULL;
if(L.head == NULL){
printf("双向链表为空!/n");
return;
}
p = L.head;
while(p != NULL){
printf("%d ", p->data);
p = p->next;
}
printf("/n遍历成功/n/n");
}
void destroy(dLinkedList *L){
Node *p = NULL;
Node *temp = NULL;
if(L == NULL){
printf("链表异常/n");
return;
}
printf("开始销毁链表.../n");
p = L->head;
while(p != NULL){
temp = p;
p = p->next;
free(temp);
temp = NULL;
}
L->head = NULL;
printf("销毁成功!/n");
}
int main(int argc, char **args){
dLinkedList L;
int i;
memset(&L, 0, sizeof(dLinkedList));
init(&L);
traversal(L);
for(i=0;i<20;++i){
insert(&L, i);
}
traversal(L);
deleteFirstData(&L);
deleteFirstData(&L);
traversal(L);
deleteFirstData(&L);
deleteData(&L, 10);
deleteData(&L, 16);
deleteData(&L, 0);
traversal(L);
insert(&L, 100);
insert(&L, 99);
insert(&L, 98);
insert(&L, 97);
traversal(L);
deleteData(&L, 99);
deleteData(&L, 97);
deleteData(&L, 96);
traversal(L);
destroy(&L);
return 0;
}
输出如下
双向链表为空!
19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
遍历成功
成功删除第一个元素!
成功删除第一个元素!
17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
遍历成功
成功删除第一个元素!
删除查找中...
查找值为 10的元素成功
删除值为 10的元素成功
删除查找中...
查找值为 16的元素成功
成功删除第一个元素!
删除查找中...
查找值为 0的元素成功
删除最后一个元素成功
15 14 13 12 11 9 8 7 6 5 4 3 2 1
遍历成功
97 98 99 100 15 14 13 12 11 9 8 7 6 5 4 3 2 1
遍历成功
删除查找中...
查找值为 99的元素成功
删除值为 99的元素成功
删除查找中...
查找值为 97的元素成功
成功删除第一个元素!
删除查找中...
查找值为 96的元素失败
删除值为 96的元素失败
98 100 15 14 13 12 11 9 8 7 6 5 4 3 2 1
遍历成功
开始销毁链表...
销毁成功!
Press any key to continue
typedef struct __Node{
int data; 数据
struct __Node *pre; 指向前一个结点指针
struct __Node *next; 指向下一个结点指针
}Node;
其中 pre和next指针是嵌套定义。
一般链表定义一个头指针
Node *head；
指向链表第一个结点，如果链表为空的话，那么head == NULL。
双向链表一般分为init，insert, delete, search, destroy等几种操作
1、init
初始化：将头指针head置为NULL即可
2、insert
插入：这里我只实现了在表头位置插入新元素。在表头位置插入元素的话，需要注意区别处理空表和非空表的情况。
1）空表的话，因为有init过程，所以head为NULL，新元素的next指针指向head（NULL），同时设置新元素的pre指针为NULL即可。
2）非空表的话，需要设置以前的头结点元素的pre指针，因为头结点的pre指针都是NULL。其他和空表一样操作。
如果要实现在链表的指定位置插入的话，需要先遍历链表找到那个位置，然后再插入。
3、delete
删除：这里我实现了删除第一个元素和删除指定的元素。其中删除指定的元素需要查找。
4、search
查找：遍历链表进行查找即可
5、destroy
销毁：将每个结点开辟的内存分别释放，最后将头结点指针head置为NULL即可。
在以上操作过程中，要注意当链表非空时，一定要保证尾结点的next域为NULL，头结点的pre域为NULL，否则容易导致错误！
//代码部分
#include <stdio.h>
#include <stdlib.h>
//定义结点
typedef struct __Node{
int data;
struct __Node *pre;
struct __Node *next;
}Node;
//定义带头结点的双向链表
typedef struct __doublyLinkedList{
Node * head;
}dLinkedList;
//初始化：头结点置空
void init(dLinkedList *L){
if(L == NULL){
printf("链表异常/n");
return;
}
L->head = NULL;
}
//
void insert(dLinkedList *L, int data){
Node *p = NULL;
if(L == NULL){
printf("双向链表不存在/n");
return;
}
p = (Node*)malloc(sizeof(Node));
if(p == NULL){
printf("内存分配失败!/n");
return;
}
p->data = data;
p->next = L->head;
if(L->head != NULL){
L->head->pre = p;
}
p->pre = NULL;
L->head = p;
}
Node *search(dLinkedList L, int data){
Node *p = NULL;
if(L.head == NULL){
printf("链表为空/n");
return NULL;
}
p = L.head;
while(p != NULL && p->data != data){
p = p->next;
}
if(p != NULL){
printf("查找值为 %d的元素成功/n", data);
return p;
}
else{
printf("查找值为 %d的元素失败/n", data);
return NULL;
}
}
void deleteFirstData(dLinkedList *L){
Node *p = NULL;
if(L == NULL){
printf("双向链表异常!/n");
return;
}
if(L->head == NULL){
printf("双向链表为空!/n");
return;
}
p = L->head;
//only one element
if(p->next == NULL){
L->head = NULL;
free(p);
p = NULL;
printf("成功删除第一个元素!/n");
return;
}
else{
L->head = p->next;
L->head->pre = NULL;
free(p);
p = NULL;
printf("成功删除第一个元素!/n");
return;
}
}
void deleteData(dLinkedList *L, int data){
Node *p = NULL;
Node *pre = NULL;
printf("删除查找中.../n");
if((p = search(*L, data)) == NULL){
printf("删除值为 %d的元素失败/n", data);
return;
}
else{
//first element
if(p == L->head){
deleteFirstData(L, data);
return;
}
//last element
else if(p->next == NULL){
pre = p->pre;
pre->next = NULL;
free(p);
p = NULL;
printf("删除最后一个元素成功/n/n");
return;
}
else{
pre = p->pre;
pre->next = p->next;
p->next->pre = pre;
free(p);
p = NULL;
printf("删除值为 %d的元素成功/n/n", data);
return;
}
}
}
void traversal(dLinkedList L){
Node *p = NULL;
if(L.head == NULL){
printf("双向链表为空!/n");
return;
}
p = L.head;
while(p != NULL){
printf("%d ", p->data);
p = p->next;
}
printf("/n遍历成功/n/n");
}
void destroy(dLinkedList *L){
Node *p = NULL;
Node *temp = NULL;
if(L == NULL){
printf("链表异常/n");
return;
}
printf("开始销毁链表.../n");
p = L->head;
while(p != NULL){
temp = p;
p = p->next;
free(temp);
temp = NULL;
}
L->head = NULL;
printf("销毁成功!/n");
}
int main(int argc, char **args){
dLinkedList L;
int i;
memset(&L, 0, sizeof(dLinkedList));
init(&L);
traversal(L);
for(i=0;i<20;++i){
insert(&L, i);
}
traversal(L);
deleteFirstData(&L);
deleteFirstData(&L);
traversal(L);
deleteFirstData(&L);
deleteData(&L, 10);
deleteData(&L, 16);
deleteData(&L, 0);
traversal(L);
insert(&L, 100);
insert(&L, 99);
insert(&L, 98);
insert(&L, 97);
traversal(L);
deleteData(&L, 99);
deleteData(&L, 97);
deleteData(&L, 96);
traversal(L);
destroy(&L);
return 0;
}
输出如下
双向链表为空!
19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
遍历成功
成功删除第一个元素!
成功删除第一个元素!
17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
遍历成功
成功删除第一个元素!
删除查找中...
查找值为 10的元素成功
删除值为 10的元素成功
删除查找中...
查找值为 16的元素成功
成功删除第一个元素!
删除查找中...
查找值为 0的元素成功
删除最后一个元素成功
15 14 13 12 11 9 8 7 6 5 4 3 2 1
遍历成功
97 98 99 100 15 14 13 12 11 9 8 7 6 5 4 3 2 1
遍历成功
删除查找中...
查找值为 99的元素成功
删除值为 99的元素成功
删除查找中...
查找值为 97的元素成功
成功删除第一个元素!
删除查找中...
查找值为 96的元素失败
删除值为 96的元素失败
98 100 15 14 13 12 11 9 8 7 6 5 4 3 2 1
遍历成功
开始销毁链表...
销毁成功!
Press any key to continue
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 双向链表的操作
- C语言实现双向链表
- 关于双向循环链表基本操作
- 雅虎面试题─有两个双向循环链表A，B，知道其头指针为：pHeadA,pHeadB，请写一函数将两链表中data值相同的结点删除
- 双向链表
- 剑指Offer:面试题27 二叉搜索树与双向链表
- 图文并茂用地址分析双向链表
- 双向链表删除节点
- 双向循环链表长整数加法(大数加减法)
- 【从零单排之微软面试100题系列】01之二叉查找树与双向链表
- 循环列表和双向链表
- Redis中的双向链表的实现
- 数据结构-----双向链表
- 把二元查找树转变成排序的双向链表
- 循环链表及双向链表的c语言实现
- 二叉搜索树与双向链表Java
- 数据结构——12 删除两个双向链表中相同的节点
- 【剑指offer】二叉搜索树与双向链表
- 数组、单链表和双链表介绍 以及 双向链表的C/C++/Java实现
- 双向链表的功能实现：初始化，插入，按位置插入，按位置删除，按值删除，遍历打印等