精华内容
下载资源
问答
  • C语言双向链表讲解

    千次阅读 2020-04-14 11:53:37
    C语言双向链表讲解 一、双向链表的概念 双向链表基于单链表。单链表是单向的,有一个头结点,一个尾结点,要访问任何结点,都必须知道头结点,不能逆着进行。而双链表添加了一个指针域,通过两个指针域,分别指向...

    lfylcj

    C语言双向链表讲解

     

     

     

    上图对应如下代码:

    pnode->prev = pindex->prev;
     pnode->pNext = pindex;
     pindex->prev->pNext = pnode;
     pindex->prev = pnode;

     

     

    上图对应如下代码:

    pnode->prev = phead;

    pnode->pNext = phead->pNext;

    phead->pNext->prev = pnode;

    phead->pNext = pnode;

     

    上图对应如下代码:

    pnode->pNext = phead;

     pnode->prev = phead->prev;

     phead->prev->pNext = pnode;

     phead->prev = pnode;

     

     

    上图对应如下代码:

    pindex->pNext->prev = pindex->prev;

    pindex->prev->pNext = pindex->pNext;

     

    一、双向链表的概念

        双向链表基于单链表。单链表是单向的,有一个头结点,一个尾结点,要访问任何结点,都必须知道头结点,不能逆着进行。而双链表添加了一个指针域,通过两个指针域,分别指向结点的前结点和后结点。这样的话,可以通过双链表的任何结点,访问到它的前结点和后结点。

        在双向链表中,结点除含有数据域外,还有两个链域,一个存储直接后继结点的地址,一般称为右链域;一个存储直接前驱结点地址,一般称之为左链域。

        双向链表结构示意图

        

    表头为空,表头的后继节点为"节点10"(数据为10的节点);"节点10"的后继节点是"节点20"(数据为10的节点),"节点20"的前继节点是"节点10";"节点20"的后继节点是"节点30","节点30"的前继节点是"节点20";...;末尾节点的后继节点是表头。

    双链表删除节点

    删除"节点30"
    删除之前:"节点20"的后继节点为"节点30","节点30" 的前继节点为"节点20"。"节点30"的后继节点为"节点40","节点40" 的前继节点为"节点30"。
    删除之后:"节点20"的后继节点为"节点40","节点40" 的前继节点为"节点20"。

     

    双链表添加节点

    在"节点10"与"节点20"之间添加"节点15"
    添加之前:"节点10"的后继节点为"节点20","节点20" 的前继节点为"节点10"。
    添加之后:"节点10"的后继节点为"节点15","节点15" 的前继节点为"节点10"。"节点15"的后继节点为"节点20","节点20" 的前继节点为"节点15"。

    二、C语言实现双向链表

    2.1 头文件

    复制代码

     1 #pragma once
     2 //新建双向链表。成功返回链表头,否则,返回NULL
     3 extern int create_dLink();
     4 //撤销双向链表,成功返回0,否则返回-1
     5 extern int destory_dLink();
     6 //双向列表是否为空,为空返回1,否则返回0
     7 extern int  is_empty_dLink();
     8 //双向链表的大小
     9 extern int dLink_size();
    10 //获取索引index位置的元素,成功返回节点指针,否则返回NULL
    11 extern  void* dLink_get(int index);
    12 //获取双向链表中第一个元素,成功返回节点指针,否则返回NULL
    13 extern void* dLink_getFirst();
    14 //获取双向链表中最后一个元素,成功返回节点指针,否则返回NULL
    15 extern void* dLink_getTail();
    16 /*
    17 链表中增加
    18 */
    19 //在Index位置插值value,成功返回0,否则返回-1;
    20 extern int dLink_insert(int index,void * pVal);
    21 //在表头插入值
    22 extern int dLink_insert_head(void *pVal);
    23 //在表尾插入值
    24 extern int dLink_insert_tail(void *pVal);
    25 /*
    26 链表中删除
    27 */
    28 //在index处删除
    29 extern int  dLink_delete(int index);
    30 //删除第一个节点
    31 extern int dLink_delete_first();
    32 //闪电湖第二个节点
    33 extern int dLink_delete_tail();

    复制代码

    2.2 .c

    复制代码

      1 #include<stdio.h>
      2 #include "double_link.h"
      3 #include<malloc.h>
      4 
      5 //双向链表节点
      6 typedef struct My_node
      7 {
      8     struct My_node *prev;
      9     struct  My_node *pNext;
     10     void * p;
     11 }my_node;
     12 //b表头不存放元素值
     13 my_node *phead = NULL;
     14 //节点的个数
     15 int node_count = 0;
     16 //创建节点,成功返回节点指针,否则,返回NULL
     17 my_node* create_node(void *pVal)
     18 {
     19     my_node *pnode = NULL;
     20     pnode = (my_node*)malloc(sizeof(My_node));
     21     if (!pnode)
     22     {
     23         printf("create pnode error\n");
     24         return NULL;
     25     }
     26     //默认的,pnode的前一节点和后一节点都指向他自己
     27     pnode->prev  = pnode->pNext = pnode;
     28     //节点的值为pVal
     29     pnode->p = pVal;
     30     return pnode;
     31 }
     32 
     33 //新建双向链表 成功返回0 否则返回-1
     34 int create_dLink()
     35 {
     36     phead = create_node(NULL);
     37     if (!phead)
     38         return -1;
     39     //设置节点的个数
     40     node_count = 0;
     41     return 0;
     42 }
     43 
     44 int destory_dLink()
     45 {
     46     if (!phead)
     47     {
     48         printf("%s failed! dlink is null!\n", __func__);
     49          return -1;
     50     }
     51     My_node*pnode = phead->pNext;
     52     my_node* ptmp = NULL;
     53     if (pnode!=phead)
     54     {
     55         ptmp = pnode;
     56         pnode = pnode->pNext;
     57         free(pnode);
     58     }
     59     free(phead);
     60     phead = NULL;
     61     node_count = 0;
     62     return 0;
     63 }
     64 
     65 int is_empty_dLink()
     66 {
     67     return node_count==0;
     68 }
     69 
     70 int dLink_size()
     71 {
     72     return node_count;
     73 }
    
     74 //获取双向链表中第Index位置的节点
     75 my_node* get_node(int index)
     76 {
     77     if (index<0 || index >= node_count)
     78     {
     79         printf("%s failed ! index out of bound\n", __func__);
     80         return NULL;
     81     }
     82     //正向查找
     83     if (index <= (node_count / 2))
     84     {
     85         int i = 0;
     86         my_node *pnode = phead->pNext;
     87         while ((i++)<index)
     88         {
     89             pnode = pnode->pNext;
     90         }
     91         return pnode;
     92     }
     93     //反向查找
     94     int j = 0;
     95     int rindex = node_count - index - 1;
     96     my_node *rnode = phead->prev;
     97     while ((j++)<rindex)
     98     {
     99         rnode = rnode->prev;
    100     }
    101     return rnode;
    102 }
    103 void * dLink_get(int index)
    104 {
    105     my_node *pindex = get_node(index);
    106     if (!pindex)
    107     {
    108         printf("%s failed!\n", __func__);
    109         return NULL;
    110     }
    111     return pindex->p;
    112 }
    113 
    114 //获取第一个节点
    115 void * dLink_getFirst()
    116 {
    117     return get_node(0) ;
    118 }
    119 //获取最后一个节点
    120 void * dLink_getTail()
    121 {
    122     return get_node(node_count-1);
    123 }
    
    124 //将值插入到index位置,成功返回0;否则 返回-1
    125 int dLink_insert(int index, void * pVal)
    126 {
    127     //插入表头
    128     if (index == 0)
    129         return dLink_insert_head(pVal);
    130     //获取要插入位置对应的节点
    131     my_node* pindex = get_node(index);
    132     if (!pindex)
    133         return -1;
    134     //创建节点
    135     my_node* pnode = create_node(pVal);
    136     if (!pnode)
    137         return -1;
    138     pnode->prev = pindex->prev;
    139     pnode->pNext = pindex;
    140     pindex->prev->pNext = pnode;
    141     pindex->prev = pnode;
    142     node_count++;
    143     return 0;
    144 }
    145 //数值插入表头
    146 int dLink_insert_head(void * pVal)
    147 {
    148     my_node* pnode = create_node(pVal);
    149     if (!pnode)
    150         return -1;
    151     pnode->prev = phead;
    152     pnode->pNext = phead->pNext;
    153     
    154     phead->pNext->prev = pnode;
    155     phead->pNext = pnode;
    156     node_count++;
    157     return 0;
    158 }
    159 
    160 int dLink_insert_tail(void * pVal)
    161 {
    162     my_node* pnode = create_node(pVal);
    163     if (!pnode)
    164         return -1;
    165     pnode->pNext = phead;
    166     pnode->prev = phead->prev;
    167     phead->prev->pNext = pnode;
    168     phead->prev = pnode;
    169     return 0;
    170 }
    171 
    172 int dLink_delete(int index)
    173 {
    174     my_node* pindex = get_node(index);
    175     if (!pindex)
    176     {
    177         printf("%s failed! the index in out of bound\n",__func__);
    178         return -1;
    179     }
    180     pindex->pNext->prev = pindex->prev;
    181     pindex->prev->pNext = pindex->pNext;
    182     free(pindex);
    183     node_count--;
    184     return 0;
    185 }
    186 
    187 int dLink_delete_first()
    188 {
    189     return dLink_delete(0);
    190 }
    191 
    192 int dLink_delete_tail()
    193 {
    194     return dLink_delete(node_count-1);
    195 }

    复制代码

    2.3 test测试代码

    复制代码

     1 #include<stdio.h>
     2 #include"double_link.h"
     3 //1.双向链表操作数为int
     4 void int_test()
     5 {
     6     int arr[10] = {11,55,67,90,21,45,23,59,79,10};
     7     printf("xxxxxxxxxxxxxxxxx\n");
     8     create_dLink();                    //创建链表
     9     dLink_insert(0, &arr[0]);        //双向链表表头插入
    10     dLink_insert(0, &arr[1]);        //双向链表表头插入
    11     dLink_insert(0, &arr[2]);        //双向链表表头插入
    12     dLink_insert(0, &arr[3]);        //双向链表表头插入
    13     dLink_insert(0, &arr[4]);        //双向链表表头插入
    14     dLink_insert(0, &arr[5]);        //双向链表表头插入
    15     printf("is_empty_dLink()=%d\n",is_empty_dLink());    //双向链表是否为空
    16     printf("dLink_size()=%d\n", dLink_size());                    //双向链表的大小
    17     //遍历双向链表
    18     int i ;
    19     int * p ;
    20     int sz = dLink_size();
    21     for ( i = 0; i < sz; i++)
    22     {
    23         p = (int*)dLink_get(i);
    24         printf("dLink_get(%d)=%d\n",i,*p);
    25     }
    26     destory_dLink();
    27 }
    28 
    29 //2.操作数为字符串
    30 void string_test()
    31 {
    32     char* str[] = {"one","two","three","four","five"};
    33     create_dLink();                    //创建链表
    34     dLink_insert(0, str[0]);        //双向链表表头插入
    35     dLink_insert(0, str[1]);        //双向链表表头插入
    36     dLink_insert(0, str[2]);        //双向链表表头插入
    37     printf("is_empty_dLink()=%d\n", is_empty_dLink());    //双向链表是否为空
    38     printf("dLink_size()=%d\n", dLink_size());                    //双向链表的大小
    39                                                                 //遍历双向链表
    40     int i ;
    41     char * p ;
    42     int sz = dLink_size();
    43     for (i = 0; i < sz; i++)
    44     {
    45         p = (char*)dLink_get(i);
    46         printf("dLink_get(%d)=%s\n", i, p);
    47     }
    48     destory_dLink();
    49 }
    50 //3.双向链表为结构体
    51 typedef struct MyStruct
    52 {
    53     int id;
    54     char name[20];
    55 } stu;
    56 stu arr_stu[] =
    57 {
    58     {1000,"lii"},
    59     { 1001,"mike" },
    60     { 1002,"lucky" },
    61     { 1003,"eric" },
    62 };
    63 #define arr_stu_size  ((sizeof(arr_stu))/(sizeof(arr_stu[0])))
    64 void stuc_test()
    65 {
    66     create_dLink();                    //创建链表
    67     dLink_insert(0, &arr_stu[0]);        //双向链表表头插入
    68     dLink_insert(0, &arr_stu[1]);        //双向链表表头插入
    69     dLink_insert(0, &arr_stu[2]);        //双向链表表头插入
    70     printf("is_empty_dLink()=%d\n", is_empty_dLink());    //双向链表是否为空
    71     printf("dLink_size()=%d\n", dLink_size());                    //双向链表的大小
    72                                                                 //遍历双向链表
    73     int i ;
    74     stu * p ;
    75     int sz = dLink_size();
    76     for (i = 0; i < sz; i++)
    77     {
    78         p = (stu*)dLink_get(i);
    79         printf("dLink_get(%d)=[%d,%s]\n", i, p->id,p->name);
    80     }
    81     destory_dLink();
    82 }
    83 int main()
    84 {
    85     int_test();
    86     string_test();
    87     stuc_test();
    88     
    89     return 0;
    90 }

    复制代码

    2.34结果显示

    展开全文
  • C语言实现双向列表的创建,删除,添加节点,删除节点,插入节点,遍历节点,打印节点,并结合插入排序法实现了基于双向链表的升序排序。
  • 数据结构复习1.2——双向链表的插入与删除 插入元素 删除元素 代码:和单链表差不多,不会就画一画,就写出来了 //双向链表的插入与删除 #include<stdio.h> #include<stdlib.h> typedef struct node{...

    数据结构复习1.2——双向链表的插入与删除
    插入元素
    在这里插入图片描述
    删除元素
    在这里插入图片描述
    代码:和单链表差不多,不会就画一画,就写出来了

    //双向链表的插入与删除
    #include<stdio.h>
    #include<stdlib.h>
    
    typedef struct node{
    	int data;
    	struct node *prior; 
    	struct node *next;
    }Lnode,*Linklist; 
    
    //双向链表初始化,定义一个Linklist(Lnode*)型函数,由其带回头指针地址 
    Linklist InitList()
    {
    	Lnode *L;
    	L=(Lnode*)malloc(sizeof(Lnode));
    	if(L==NULL)
    	{
    		printf("申请空间失败\n");
    		exit(0);
    	}
    	L->next ==NULL;
    	L->prior==NULL; 
    	return L;
    }
    //尾插法创建双向链表
    void CreatList(Linklist L)
    {
    	Lnode *s,*r=L;
    	int i,n,num;
    	printf("请输入元素个数n:");
    	scanf("%d",&n);
    	for(i=0;i<n;i++)
    	{
    		printf("请输入第%d个数:",i+1);
    		scanf("%d",&num);
    		s=(Lnode*)malloc(sizeof(Lnode));
    		s->data =num;
    		s->prior=r;//与单链表相比就多了这一句 
    		r->next=s;
    		r=s;
    	}
    	r->next=NULL;
     } 
    //判断链表长度,与单链表相同 
    int LongthList(Linklist L)
    {
    	int i=0;
    	Lnode *p;
    	p=L->next;//带头结点的单链表,头结点按第0个节点算 
    	while(p!=NULL)
    	{
    		p=p->next;
    		i++;
    	}
    	return i;
     }
    //在链表的第i个位置之后插入元素x
    Linklist Insert(Linklist &L,int i,int x)
     {
     	int j;
     	Lnode *s,*p=L;
     	if(i<0||i>LongthList(L))
     	{
     		printf("插入位置错误\n");
     		return 0;
    	}
    	s=(Lnode*)malloc(sizeof(Lnode));
    	s->data=x;
    	for(j=0;j<i;j++)
    	//定位;若要在第i个元素之前插入,则j=1;(或者j=0,j<i-1;)少循环一次就可以了 
    	{
    	 	p=p->next;
    	}
    	//在i前插入 
        /*
        s->prior=p->prior;
    	p->prior->next=s;
    	s->next=p; 
    	p->prior=s;
    	*/
    	//在i之后 
    	p->next->prior = s;
        s->next = p->next;
        p->next = s;
        s->prior = p;
    }  
     //删除第i个节点,并释放
     int DeleteLnode(Linklist L,int i,int &x)
     {
     	Lnode *p=L;
     	int j=0;
     	if(i<0||i>LongthList(L))
     	{
     		printf("删除位置错误\n");
     		return 0;
    	}
    	//找到p,即要删除的元素 
     	while(p&&j<i)
     	{
     		p=p->next;
     		j++;
    	}
    	x=p->data;//如果不加取地址符,直接free
    	p->prior->next=p->next;
    	p->next->prior=p->prior; 
    	free(p); 
      } 
    
    //遍历链表,与遍历单链表相同 
    void PrintList(Linklist L)
    {
        Lnode *p;
        p=L->next;
     	while(p!=NULL)
     	{
     		printf("%d\n",p->data);
     		p=p->next;
    	}
    } 
     
    int main()
    {
    	Linklist S;int l,x; 
    	S=InitList();
    	CreatList(S);
    	l=LongthList(S);
    	printf("链表长为%d\n",l);
    	PrintList(S);
    	
    	Insert(S,2,4);
    	printf("插入新元素之后,遍历\n");
    	PrintList(S);
    	
    	DeleteLnode(S,3,x);
    	printf("%d已经删除\n",x); 
    	printf("删除元素之后,遍历\n");
    	PrintList(S);
    }
    

    运行结果
    在这里插入图片描述

    展开全文
  • #include#includetypedef struct DoubleLinkedList{int data;struct DoubleLinkedList *pre;struct DoubleLinkedList *next;...//建立链表DlinkedList_Node* createDLink(){DlinkedList_Node *head,*p,*s...

    #include

    #include

    typedef struct DoubleLinkedList

    {

    int data;

    struct DoubleLinkedList *pre;

    struct DoubleLinkedList *next;

    }DlinkedList_Node;

    //建立链表

    DlinkedList_Node* createDLink()

    {

    DlinkedList_Node *head,*p,*s;

    int x;

    head = (DlinkedList_Node*)malloc(sizeof(DlinkedList_Node));

    p = head;

    while(1)

    {

    printf("please input the data:

    ");

    scanf("%d",&x);

    if(x != 65535)

    {

    s = (DlinkedList_Node*)malloc(sizeof(DlinkedList_Node));

    s ->data = x;

    s-> pre = p;

    p->next = s;

    p=s;

    }

    else

    {

    printf("

    数据输入结束

    ");

    break;

    }

    }

    p->next = NULL;

    head = head ->next;

    head->pre = NULL;

    return head;

    }

    //顺序、反序打印链表

    void printDLink(DlinkedList_Node *head)

    {

    DlinkedList_Node *p,*s;

    p = head;

    printf("正序输出双向链表:

    ");

    while(p)

    {

    printf("%d ",p->data);

    s = p;

    p = p->next;

    }

    printf("

    逆序输出双向链表:

    ");

    while(s)

    {

    printf("%d ",s->data);

    s = s->pre;

    }

    printf("

    ");

    }

    //删除一个结点

    DlinkedList_Node* deleteDlinkedList_Node(DlinkedList_Node *head,int i)

    {

    DlinkedList_Node *p;

    p = head;

    if(p->data == i)

    {

    head = p->next;

    head->pre = NULL;

    free(p);

    return head;

    }

    while(p)

    {

    if(p->data == i)

    {

    p->pre->next = p->next;

    p->next->pre = p->pre;

    free(p);

    return head;

    }

    p = p->next;

    }

    printf("没有找到想要删除的数据

    ");

    return head;

    }

    //插入一个结点

    DlinkedList_Node* insertDlinkedList_Node(DlinkedList_Node *head,int i)

    {

    DlinkedList_Node *p,*temp;

    p = head;

    temp = (DlinkedList_Node*)malloc(sizeof(DlinkedList_Node));

    temp ->data = i;

    if(i < p->data)//比头结点数据小,插入到链表头部

    {

    head = temp;

    head->next = p;//此处p为原来的head

    head->pre = NULL;

    p->pre = head;//此处p为原来的head

    return head;

    }

    while(p != NULL && i > p->data)//寻找合适的插入位置

    {

    p = p->next;

    }

    if(i < p->data)//在链表中间某处找到合适插入位置

    {

    temp ->next = p;

    temp ->pre = p->pre;

    p ->pre->next = temp;

    p ->pre = temp;

    return head;

    }

    else//没有找到合适的位置,只有将数据插入到链表尾部

    {

    p->next = temp; //遍历到链表尾部,p==NULL

    temp ->pre = p;

    temp ->next = NULL;

    return head;

    }

    }

    int main()

    {

    DlinkedList_Node *head;

    head = createDLink();

    printDLink(head);

    head = insertDlinkedList_Node(head,1012);

    head = deleteDlinkedList_Node(head,1991);

    printDLink(head);

    }

    /*****************************

    运行结果如下:

    please input the data:

    1991

    please input the data:

    1992

    please input the data:

    2013

    please input the data:

    2014

    please input the data:

    512

    please input the data:

    420

    please input the data:

    65535

    数据输入结束

    正序输出双向链表:

    1991 1992 2013 2014 512 420

    逆序输出双向链表:

    420 512 2014 2013 1992 1991

    正序输出双向链表:

    1012 1992 2013 2014 512 420

    逆序输出双向链表:

    420 512 2014 2013 1992 1012

    ******************************/

    展开全文
  • c语言双向链表的实现

    2020-07-12 23:40:32
    实现了头插法建立双向链表,尾插法建立双向链表,节点的增删改查,链表的顺序遍历,逆序遍历等 代码如下 #include <stdio.h> #include <stdlib.h> #define TRUE 1; #define FALSE 0; typedef ...

    实现了头插法建立双向链表,尾插法建立双向链表,节点的增删改查,链表的顺序遍历,逆序遍历等

    代码如下

    #include <stdio.h>
    #include <stdlib.h>
    
    #define TRUE 1;
    #define FALSE 0;
    
    typedef struct DuLNode{
        int data;
        struct DuLNode *prior, *next;
    }DuLNode, *DuLinklist;
    
    
    //尾插法创建双向链表
    void CreateTailList(DuLinklist *L, int n){//创建大小长度为n的链表
        DuLinklist p, r;
        (*L) = (DuLNode *)malloc(sizeof(DuLNode));
        (*L)->next = NULL;
        (*L)->prior = NULL;
        (*L)->data = n;
        r = (*L);
        int i = 0;
        for(i = 0; i < n; i ++){
            p = (DuLNode *)malloc(sizeof(DuLNode));
            p->data = i;
            r->next = p;
            p->prior = r;
            r = p;
    
    
        }
        r->next = NULL;
    }
    //头插法建立双向链表
    void CreteHeadList(DuLinklist *L, int n){
        DuLinklist p, r;
        (*L) = (DuLNode *)malloc(sizeof(DuLNode));
        (*L)->next = NULL;
        (*L)->prior = NULL;
        (*L)->data = n;
        r = (*L);
        int i = 0;
        for(i = 0; i < n; i ++){
            p = (DuLNode *)malloc(sizeof(DuLNode));
            p->data = i;
            if(r->next == NULL){//插入第一个节点时与其他方法不一样
                r->next = p;
                p->prior = r;
                p->next = NULL;
            }
            else{
                p->next = r->next;
                r->next->prior = p;
                r->next = p;
                p->prior = r;
            }
        }
    }
    
    //在第i个位置插入元素e
    void InsertElem(DuLinklist *L, int i, int e){
        if(i <= (*L)->data){
            DuLinklist p, r;
            r = (*L);//指向头节点的头节点
            p = (DuLNode *)malloc(sizeof(DuLNode));//为要插入的元素申请空间
            p->data = e;
            int j = 0;
            for(j = 0; j < i; j ++){//通过遍历,找到要插入的元素位置,当前r的位置
                r = r->next;
            }
            if(r->next != NULL){//节点后面有节点的时候
                p->next = r->next;
                r->next->prior = p;
                r->next = p;
                p->prior = r;
    
            }
            else{//节点后面没有节点的情况,在最后插入元素
                r->next = p;
                p->prior = r;
                p->next = NULL;
            }
        }
        else{
            printf("插入下标不合理,请重新输入\n");
        }
    }
    
    //删除第i个位置的元素
    void DeleteElem(DuLinklist *L, int i){
        if(i < (*L)->data && i >= 0){
            DuLinklist p, r;
            p = (*L);
            int j = 0;
            for(j = 0; j < i; j ++){
                p = p->next;
            }
            if(p->next->next == NULL){//如果是最后一个节点
                r = p->next;//要删除的下标
                p->next = NULL;
                free(r);//释放该节点的内存
            }
            else{
                r = p->next;
                p->next = r->next;
                r->next->prior = p;
                free(r);
            }
        }
        else{
            printf("下标错误\n");
        }
    
    }
    //获取第i个元素
    int GetElem(DuLinklist *L, int i){
        if(i >= 0 && i < (*L)->data){
            DuLinklist p;
            p = (*L);
            int j = 0;
            int elem;
            for(j = 0; j < i; j ++){
                p = p->next;
            }
            elem = p->next->data;
            return elem;
        }
        else{
            printf("error\n");
            return FALSE;
        }
    
    
    
    }
    //获取返回最后一个节点
    DuLinklist GetLast(DuLinklist *L){
        DuLinklist p;
        p = (*L);
        while(p->next != NULL){
            p = p->next;
        }
        return p;
    }
    //顺序遍历链表
    void TraverseList(DuLinklist *L){
        DuLinklist p;
        p = (*L);
        while(p->next != NULL){
            printf("%d\n", p->next->data);
            p = p->next;
        }
    }
    //逆序遍历链表,从尾部遍历到头部,借助prior节点
    void ReverTraverse(DuLinklist *L){
        DuLinklist p;
        p = GetLast(L);
        while(p->prior != NULL){
            printf("%d\n", p->data);
            p = p->prior;
        }
    }
    
    int main()
    {
    
        DuLinklist La;
        CreateTailList(&La, 5);
    
       // DuLinklist lb = GetLast(&La);
        ReverTraverse(&La);
    
        //TraverseList(&La);
        return 0;
    }
    

     

    展开全文
  • 完成双向链表的插入、删除以及查找,将学生管理系统使用的数组,以双向链表的方式实现,能够支持无限制的学生人数的增删改查以及保存。 3,代码实现。 #include #include #include #include typedef struct ...
  • 实现双向链表删除一个指定元素。  4.在非递减有序双向链表中实现插入元素e仍有序算法。  5.判断双向链表中元素是否对称若对称返回1否则返回0。  6.设元素为正整型,实现算法把所有奇数排列在偶数之前。  ...
  • C语言双向链表应用 前言: 平时使用音乐播放器时,播放列表中的歌曲可以很方便地进行增添,删除,去重等操作。但其本质都可以抽象成一个双向链表。为了更方便用户的使用,我认为还可以增加一个将最常播放的音乐放在...
  • //创建双向链表函数 void Insert_DNodelist(DNodelist &l, int i, int e); //向双链表中第i个结点插入元素e void Delete_DNodelist(DNodelist &l, int i, int e); //删除链表中第i个结点的元素,并用e返回 int ...
  • C语言双向链表的代码操作步骤是爱站技术频道小编根据自己的理解和认识为大家整理的知识,其实这个知识在我们看来是比不可少的,下面就随着小编的步伐一起来学习吧!1.概述:C语言中一种更复杂的链表是“双向链表”或...
  • //定义双向链表的节点typedef structNode{intdata;struct Node *prior;struct Node *next;}Node;//初始化一个链表的节点、Node* create_node(void){Node*p;p= (Node*)malloc(sizeof(Node));if(p ==NULL){printf(...
  • ElementType Eject(Deque D) // 表尾部删除 { if (D->Front == D->Rear) // 如果空队列的情况 return ERROR; PtrToNode Temp; int X; Temp = D->Rear; X = Temp->Element; D->Rear = Temp->Last; Temp->...
  • 1.概述:C语言中一种更复杂的链表是“双向链表”或“双面链表”。其表中的每个节点有两个连接:一个指向前一个节点,(当这个“连接”为第一个“连接”时,指向空值或者空列表);而另一个指向下一个节点,(当这个...
  • C语言双向链表

    2015-08-13 20:02:00
    双向链表创建,可对 链表元素进行删除、查询、添加、修改
  • c语言实现双向链表

    千次阅读 2018-09-05 13:42:13
    链表操作 开发环境codeblocks12.11 xxwu */ #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;stdbool.h&gt; typedef int ElemType; typedef struct DNode{  ...
  • C语言 双向链表的增删改查

    千次阅读 2019-02-10 17:18:07
    主题:双向链表 功能:分别实链表的插入、删除、查找、打印(正序、逆序)操作 提示:如果需要进入下一步操作,输入3个ctrl z即可 //主题:双向链表 //功能:分别实链表的插入、删除、查找操作 //提示:如果需要进入...
  • 双向链表与单向链表相比,多了一个前驱(指向前一个节点的指针,初始化多加一个前驱指针即可) 双向链表增、删、改、查demon #include<stdio.h> #include<stdlib.h> typedef struct double_list{ ...
  • C语言实现双向链表

    2020-01-16 22:04:34
    目前我们所学到的链表,无论是动态链表还是静态链表,表中各节点中都只包含一个指针(游标),且都统一指向直接后继节点,通常称这类链表为单向链表(或单链表)。 虽然使用单链表能 100% 解决逻辑关系为 “一对一...
  • 数据结构之C语言实现双向链表

    千次阅读 多人点赞 2018-07-07 12:17:29
    C语言实现双向链表 双向链表主要实现以下功能: 双向链表创建 节点头插 节点尾插 指定位置插入节点 节点删除 链表排序 链表求长 /********************************************************************...
  • /*==============================================================================* 操作 :清空链表,释放结点内存,将链表重置为空表* 操作前:ppHeadNode为链表头指针的二级指针* 操作后:(*ppHeadNode)所指...
  • // 带头+双向+循环链表增删查改实现typedef int LTDataType;typedef struct ListNode{LTDataType _data;struct ListNode* _next;struct ListNode* _prev;}ListNode;1、创建返回链表的头结点ListNode* ListCreate(){...
  • 详解双向链表的基本操作(C语言)

    万次阅读 多人点赞 2020-04-06 22:06:19
    1.双向链表的定义 上一节学习了单向链表单链表详解。今天学习双链表。学习之前先对单向链表和双向链表做个回顾。 单向链表特点:   1.我们可以轻松的到达下一个节点, 但是回到前一个节点是很难的.   2.只能从头...
  • C语言-双向链表

    2021-06-16 10:35:21
    双向链表删除节点: 遍历双链表,并打印元素数据: 双向链表插入节点: 使用双向链表对数据进行“增删查改”的完整操作代码: 双向链表及其创建、双向链表基本操作 可以看出,双向链表中各节点包括: ① ...
  • #ifndef DLIST_H #define DLIST_H typedef struct NODE { int data; struct NODE *pre; struct NODE *next; }node; node *createhead(void); node *createnode(int data);...void insertbyhead(node* hea...
  • 数据结构-双向链表的创建、插入和删除双向链表是数据结构中重要的结构,也是线性结构中常用的数据结构,双向指针,方便用户从首结点开始沿指针链向后依次遍历每一个结点,结点的前驱和后继查找方便。#include #...
  • 链表是一种最普遍的数据组织方式,他不需要连续的大片内存也可以存储大量的数据,而且对于数据的插入和删除运算响应速度也够快,但是查找性能一般。 红黑树是一种更加高大上的数据组织方式,他虽然逻辑稍显复杂,但...
  • 双向链表结点中有两个指针,分别指向其前驱结点和后继结点,这样就可以实现链表的双向遍历了。 2.双向链表的具体实现过程 #include<stdio.h> #include<malloc.h> #define ElemType int typedef ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,235
精华内容 6,094
关键字:

c语言双向链表的删除

c语言 订阅