美文网首页
自己实现C语言双向向链表

自己实现C语言双向向链表

作者: 三三At你 | 来源:发表于2017-05-11 21:16 被阅读0次
#include<iostream>  
#include<stdio.h>  
#include<string.h>  
#include<malloc.h>  
#include<list>  
#define CHAR char  
#define VARTYPE CHAR //默认存放char类型  
  
using namespace std;  
  
struct myNode;  
typedef struct myNode Node;  
typedef Node* List;  
typedef Node* PtrToNode;  
  
  
struct myNode  
{  
    VARTYPE data;  
    PtrToNode next;  
    PtrToNode prev;  
};  
//在p位置后插入元素  
void _insert(List T,int p,VARTYPE x);  
//头插入元素  
void _push_front(List T,VARTYPE x);  
//尾部插入元素  
void _push_back(List T,VARTYPE x);  
//移除内容为x的元素  
void _removec(List T,VARTYPE x);  
//移除内容为编号为p的元素  
void _removep(List T,int p);  
//删除链表  
void _dellist(List T);  
//打印char类型链表内容  
#ifdef CHAR  
void _print(List T);  
#endif  
//清空链表  
void _clear(List T);  
//创建链表  
List createlist();  
//返回编号为p的元素  
VARTYPE _findc(List T,int p);  
//链表元素个数  
int _size(List T);  
int main()  
{  
    List T = createlist();  
    _push_back(T,'a');  
    _push_back(T,'b');  
    _push_back(T,'c');  
    _push_back(T,'d');  
    _push_back(T,'e');  
    _push_back(T,'e');  
    _push_back(T,'d');  
    _push_front(T,'x');  
    //_insert(T,2,'p');  
    //_removec(T,'e');  
    //_removep(T,3);  
    //_print(T);  
    //_clear(T);  
    _push_back(T,'p');  
    _push_back(T,'q');  
    //printf("%d",_size(T));  
    //printf("%c",_findc(T,3));  
    _print(T);  
    _dellist(T);  
    return 0;  
}  
  
//在p位置后插入元素  
void _insert(List T,int p,VARTYPE x)  
{  
    PtrToNode tmp;  
    int i = 0;  
    while(NULL!=T)  
    {  
        T = T->next;  
        if(++i==p)  
            break;  
    }  
    tmp = (PtrToNode)malloc(sizeof(Node));  
    if(NULL==tmp)  
        perror("malloc");  
    else  
    {  
        tmp->data = x;  
        tmp->next = T;  
        tmp->prev = T->prev;  
        T->prev->next = tmp;  
        T->prev = tmp;  
    }  
};  
//尾部插入元素  
void _push_back(List T,VARTYPE x)  
{  
    while(NULL!=T->next)  
        T = T->next;  
    PtrToNode tmp = (PtrToNode)malloc(sizeof(Node));  
    if(NULL==tmp)  
        perror("malloc");  
    else  
    {  
        tmp->data = x;  
        tmp->next = NULL;  
        tmp->prev = T;  
        T->next = tmp;  
    }  
};  
//头部插入元素  
void _push_front(List T,VARTYPE x)  
{  
    PtrToNode tmp = (PtrToNode)malloc(sizeof(Node));  
    if(NULL==tmp)  
        perror("malloc");  
    else  
    {  
        tmp->data = x;  
        tmp->prev = T;  
        tmp->next = T->next;  
        T->next = tmp;  
        tmp->next->prev = tmp;  
    }  
};  
//移除内容为x的元素  
void _removec(List T,VARTYPE x)  
{  
    T = T->next;  
    while(NULL!=T)  
    {  
        if(T->data==x)  
        {  
            T = T->prev;  
            T->next = T->next->next;  
            free(T->next->prev);  
            T->next->prev = T;  
        }  
        T = T->next;  
    }  
};  
//移除内容为编号为p的元素  
void _removep(List T,int p)  
{  
    int i = 0;  
    while(NULL!=T)  
    {  
        T = T->next;  
        if(++i==p)  
            break;  
    }  
    T->prev->next = T->next;  
    T->next->prev = T->prev;  
    free(T);  
};  
//删除链表  
void _dellist(List T)  
{  
    PtrToNode tmp = T;  
    while(NULL!=T)  
    {  
        tmp = T->next;  
        free(T);  
        T = tmp;  
    }  
};  
//打印char类型链表内容  
#ifdef CHAR  
void _print(List T)  
{  
    T = T->next;  
    while(NULL!=T)  
    {  
        printf("%c ",T->data);  
        T=T->next;  
    }  
};  
#endif  
//清空链表  
void _clear(List T)  
{  
    _dellist(*&T->next);  
    T->next = NULL;  
    T->prev = NULL;  
}  
//创建链表  
List createlist()  
{  
    PtrToNode tmp = (PtrToNode)malloc(sizeof(Node));  
    tmp->next = NULL;  
    tmp->prev = NULL;  
    return tmp;  
}  
//返回编号为p的元素  
VARTYPE _findc(List T,int p)  
{  
    int i = 0;  
    while(NULL!=T)  
    {  
        T = T->next;  
        if(++i==p)  
            break;  
    }  
    return T->data;  
}  
//链表元素个数  
int _size(List T)  
{  
    int i = -1;  
    while(NULL!=T)  
    {  
        T = T->next;  
        ++i;  
    }  
    return i;  
}

2014/10/15更新

#include<iostream>  
#include<cstdio>  
#include<string>  
#include<malloc.h>  
using namespace std;  
  
struct mynode;  
typedef struct mynode Node;  
struct mynode  
{  
    int data;  
    Node *next;  
    Node *prev;  
};  
  
char str[] = {"\  
-------------------------------------------------\n\  
-------C：创建链表-------------------------------\n\  
-------D：删除节点-------------------------------\n\  
-------I：插入新节点-----------------------------\n\  
-------P：输出节点-------------------------------\n\  
-------Q：撤销链表-------------------------------\n\  
-------E：退出-----------------------------------\n\  
-------------------------------------------------\n\  
"  
             };  
  
Node* createlist()  
{  
    Node* head,*temp,*p;  
    int n;  
    head = (Node *)malloc(sizeof(Node));  
    if(NULL==head)  
    {  
        perror("out of space");  
        exit(1);  
    }  
    head->data = -1;  
    head->next = NULL;  
    head->prev = NULL;  
    printf("请输入节点个数：");  
    scanf("%d",&n);  
    p = head;  
    for(int i=1; i<=n; ++i)  
    {  
        temp = (Node *)malloc(sizeof(Node));  
        if(NULL==temp)  
        {  
            perror("out of space");  
            exit(1);  
        }  
        temp->next = NULL;  
        temp->prev = p;  
        printf("data%2d:",i);  
        scanf("%d",&temp->data);  
        p->next = temp;  
        p = temp;  
    }  
    return head;  
}  
  
void dellist(Node *head)  
{  
    Node *p;  
    while(head)  
    {  
        p = head->next;  
        free(head);  
        head = p;  
    }  
}  
  
void printlist(Node *head)  
{  
    int i = 1;  
    Node *p;  
    head = head->next;  
    while(head)  
    {  
        printf("data%2d: %d\n",i++,head->data);  
        p = head;  
        head = head->next;  
    }  
    printf("反向\n");  
    while(p)//测试反向是正确连接  
    {  
        printf("data%2d: %d\n",--i,p->data);  
        p = p->prev;  
    }  
  
}  
  
void _insert(Node *head)  
{  
    int pos;  
    Node* temp;  
    printf("输入插入节点的位置:");  
    scanf("%d",&pos);  
    if(pos<0)  
        return ;  
    while(head->next&&pos--)  
    {  
        head = head->next;  
    }  
    temp = (Node *)malloc(sizeof(Node));  
    if(NULL==temp)  
    {  
        perror("out of space");  
        exit(1);  
    }  
    printf("输入data:");  
    scanf("%d",&temp->data);  
    temp->prev = head;  
    temp->next = head->next;  
    head->next->prev = temp;  
    head->next = temp;  
}  
  
void delnode(Node *head)  
{  
    int pos;  
    printf("输入删除节点位置:");  
    scanf("%d",&pos);  
    if(pos<1)  
        return ;  
    while(pos--)  
    {  
        head = head->next;  
    }  
    head->prev->next = head->next;  
    head->next->prev = head->prev;  
    free(head);  
}  
  
int main()  
{  
    char p;  
    printf(str);  
    while(scanf("%c",&p)!=EOF)  
    {  
        if(p>='a'&&p<='z')p = p-('a'-'A');  
        Node *_list;  
        switch(p)  
        {  
        case 'C':  
            dellist(_list);  
            _list = createlist();  
            break;  
        case 'D':  
            delnode(_list);  
            break;  
        case 'I':  
            _insert(_list);  
            break;  
        case 'P':  
            printlist(_list);  
            break;  
        case 'Q':  
            dellist(_list);  
            break;  
        case 'E':  
            dellist(_list);  
            return 0;  
            break;  
        default:  
            printf(str);  
            break;  
        }  
    }  
}  

![](https://img.haomeiwen.com/i6000430/62ea3691520306a5.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

相关文章

  • 自己实现C语言双向向链表

    2014/10/15更新

  • Redis 源码--链表。

    因为C语言是一个比较底层的语言，库内没有实现链表，于是Redis自己实现了链表。Redis的链表是一个双向链表。 ...

  • C++实现双向循环链表

    本次博文是关于利用C++模板的方式实现的双向循环链表以及双向循环链表的基本操作，在之前的博文C++语言实现双向链表...

  • C++语言实现双向链表

    这篇文章是关于利用C++模板的方式实现的双向链表以及双向链表的基本操作，在之前的博文C语言实现双向链表中，已经给大...

  • C语言实现双向循环链表

    在之前的文章中，我写过一篇关于C语言实现双向链表博文，介绍了双向链表的实现过程以及双向链表的优势，接下来我首先给大...

  • C语言实现双向链表

    C语言的标准库并没有实现链表，所以需要我们通过所学的知识来实现链表。先来看看双向链表的定义，来源于百度百科。 双向...

  • 数据结构之双向链表

    1.双向链表 1.1双向链表创建示意图 分析 双向链表的遍历，添加，修改，删除的操作思路===》代码实现： 遍历 ...

  • C语言实现双向链表

    关于双向链表的解释就不多说了，书本上介绍的挺详细的了，只需要记住每个节点有一个指向下一个节点的指针变量和指向前一个...

  • C语言实现双向链表

    目前我们所学到的链表，无论是动态链表还是静态链表，表中各节点中都只包含一个指针（游标），且都统一指向直接后继节点，...

  • JavaScript数据结构与算法-链表练习

    链表的实现 一. 单向链表 二. 双向链表 三. 循环链表 练习 一. 实现advance(n)方法，使当前节点向...

网友评论

      本文标题：自己实现C语言双向向链表

      本文链接：https://www.haomeiwen.com/subject/qgdatxtx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|自己实现C语言双向向链表|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！