精华内容
下载资源
问答
  • 双向链表创建,插入,删除,销毁等,写的一个代码(包括详细的注释,初学者都看得懂),已经成功测试。及拿即用。
  • 创建含有N各节点的双向链表,实现在链表中插入、删除节点。#include #include<stdlib.h>typedef struct DulNode{ int data; struct DulNode *prior; struct DulNode *next; }DNode,*DLinkList;//创建含有n个节点...

    创建含有N各节点的双向链表,实现在链表中插入、删除节点。

    #include<stdio.h>
    #include<stdlib.h>
    
    typedef struct DulNode{
        int data;
        struct DulNode *prior;
        struct DulNode *next;
    }DNode,*DLinkList;
    
    //创建含有n个节点的双链表
    DLinkList createDulList(int n)
    {
        DLinkList head = (DLinkList)malloc(sizeof(DNode));
        DLinkList p = head;
        head->prior = NULL;
        for(int i=1;i<=n;i++)
        {
            printf("输入第%d个节点",i);
            scanf("%d",&p->data);
            if(i!=n)
            {
                DLinkList q = (DLinkList)malloc(sizeof(DNode));
                p->next = q;
                q->prior = p;
                p = q;
            }
    
        }
        p->next = NULL;
    
        return head;
    }
    
    //双向链表中插入一个节点
    DLinkList insertDulList(DLinkList head,int k,int m)
    {
        DLinkList p = head;
        if(head==NULL)
            return head;
        DLinkList q = (DLinkList)malloc(sizeof(DNode));
        if(q==NULL)
            exit(1);
        int i=1;
        while(i++<k && p!=NULL)
        {
            p = p->next;
        }
    
        q->data = m;
        q->prior = p->prior;
        p->prior->next = q;
        q->next = p;
        p->prior = q;
    
    
        return head;
    
    
    }
    
    //双向链表删除一个节点
    DLinkList deleteDulList(DLinkList head,int k)
    {
        DLinkList p = head;
        if(head==NULL)
            return NULL;
        int i=1;
        while(i++<k && p!=NULL)
        {
            p = p->next;
        }
    
        p->prior->next = p->next;
        p->next->prior = p->prior;
        free(p);
        return head;
    }
    //顺序打印lianbiao链表
    void printDList(DLinkList head)
    {
        if(head==NULL)
            exit(1);
        while(head!=NULL)
        {
            printf("%d ",head->data);
            head = head->next;
        }
    }
    
    
    void main()
    {
        DLinkList head = createDulList(5);
        printDList(head);
        printf("\n");
    
        DLinkList h = insertDulList(head,3,0);
        printDList(h);
        printf("\n");
    
        DLinkList dl = deleteDulList(head,3);
        printDList(dl);
        printf("\n");
    }
    
    展开全文
  • c/c++ 双向链表 创建 插入 删除

    千次阅读 2017-08-03 14:12:14
    同单链表的操作方法类似,不过在结点中加入了一个指向结点前驱的指针。 #include #include #include #include #include using namespace std; typedef struct student { int data; struct student *next...}dno

    同单链表的操作方法类似,不过在结点中加入了一个指向结点前驱的指针。

    #include <iostream>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <conio.h>
    using namespace std;
    typedef struct student
    {
        int data;
        struct student *next;
        struct student *pre;
    }dnode;
    
    dnode* create();
    dnode* delNode(dnode* head, int num);
    dnode* instNode(dnode* head, int num);
    void searchmid(dnode* head,dnode* mid);
    void print(dnode* head);
    
    dnode* create()
    {
        dnode *head;
        head = (dnode*)malloc(sizeof(dnode));
        head->data=0;
        head->pre=nullptr;
        head->next=nullptr;
        int num=1;
        while(num!=0)
        {
            cout << "Please input the data: ";
            cin >> num;
            instNode(head, num);
        }
        cout << "head data: " << head->data << endl;
        return head;
    }
    
    dnode* delNode(dnode* head, int num)
    {
        dnode* p1;
        p1=head;
        while(num!=p1->data && p1->next!=nullptr)
        {
            p1=p1->next;
        }
        if(num == p1->data)
        {
            if(p1 == head)
            {
                head=head->next;
                head->pre=nullptr;
                free(p1);
            }
            else if(p1->next == nullptr)
            {
                p1=p1->pre;
                p1->next=nullptr;
                free(p1);
            }
            else
            {
                p1->next->pre=p1->pre;
                p1->pre->next=p1->next;
            }
        }
        else
        {
            cout << num << " could not found!!!" << endl;
        }
        return head;
    }
    
    dnode* instNode(dnode* head, int num)
    {
        dnode *p0,*p1;
        p1=head;
        p0=(dnode*)malloc(sizeof(dnode));
        p0->data=num;
    
        while((p0->data > p1->data) && (p1->next != nullptr))
        {
            p1=p1->next;
        }
        if(p0->data <= p1->data)
        {
            if(p1==head)
            {
                p0->next=p1;
                p1->pre=p0;
                head=p0;
            }
            else
            {
                p1->pre->next=p0;
                p0->next=p1;
                p0->pre=p1->pre;
                p1->pre=p0;
            }
        }
        else
        {
            p1->next=p0;
            p0->pre=p1;
            p0->next=nullptr;
        }
        return head;
    }
    
    void searchmid(dnode* head,dnode* mid)
    {
        dnode* temp = head;
        while(head->next->next != nullptr)
        {
            head = head->next->next;
            temp = head->next;
            mid = temp;
        }
    }
    
    void print(dnode* head)
    {
        while(head->next!=nullptr)
        {
            cout << head->data << endl;
            head=head->next;
        }
        cout << head->data << endl;
    }
    
    int main()
    {
        dnode* head;
        int del_num,inst_num;
        head = create();
        print(head);
        cout << "Input number would be deleted: ";
        cin >> del_num;
        head = delNode(head,del_num);
        print(head);
        cout << "Insert number would be inserted: ";
        cin >> inst_num;
        head = instNode(head,inst_num);
        print(head);
        return 0;
    }
    
    


    展开全文
  • 双向链表创建、删除某节点

    千次阅读 2017-10-17 11:05:24
    /*链表最后一个节点*/ pNode->pPrev->pNext = NULL; pNode->pPrev = NULL; } else { pNode->pPrev->pNext = pNode->pNext; pNode->pNext->pPrev = pNode->pPrev; } ...

    #include <stdio.h>
    //#include <malloc.h>
    #include <stdlib.h>
    
    #define MAXLEN  10
    
    typedef struct LinkNode
    {
    	struct LinkNode * pNext;
    	struct LinkNode * pPrev;
    	int m_Value;
    }LINKNODE;
    
    void ShowLinkNode(LINKNODE * pHead)
    {
    	if (NULL == pHead)
    	{
    		return;
    	}
    	LINKNODE * pNode = pHead;
    	while (pNode!=NULL)
    	{
    		printf("%d ",pNode->m_Value);
    		pNode = pNode->pNext;
    	}
    }
    
    void CreateLinkNode(LINKNODE * pHead)
    {
    	if(NULL == pHead)
    	{
    		return;
    	}
    	int num = 0;
    	for (int i = 0;i<MAXLEN;i++)
    	{
    		LINKNODE * pNode = (LINKNODE *)malloc(sizeof(LINKNODE));
    		pNode->pNext = NULL;
    		pNode->pPrev = NULL;
    
    		pNode->m_Value = rand()%MAXLEN;
    		if (pHead->pNext == NULL)
    		{
    			pHead->pNext = pNode;
    			pNode->pPrev = pHead;
    		}
    		else
    		{		
    			pNode->pNext   = pHead->pNext;
    			pHead->pNext->pPrev = pNode;
    			pHead->pNext   = pNode;
    			pNode->pPrev   = pHead;
    		}
    	}
    }
    
    LINKNODE *  DeleteLinkNode(LINKNODE * pHead,int key_value)
    {
    	if (NULL == pHead)
    	{
    		return NULL;
    	}
    	LINKNODE * pNode = pHead;
    	LINKNODE * pDeleteNode = pHead;
    	int NeedDelete = 0;
    	while(pNode!=NULL)
    	{
    		if (pNode->m_Value == key_value)
    		{
    			pDeleteNode = pNode;
    			if(pNode == pHead)
    			{
    				/*链表第一个节点*/
    				pHead = pHead->pNext;
    				pNode = pHead;
    			}
    			else
    			{
    				if (pNode->pNext == NULL)
    				{
    					/*链表最后一个节点*/
    					pNode->pPrev->pNext = NULL;
    					pNode->pPrev = NULL;
    				}
    				else
    				{
    					pNode->pPrev->pNext = pNode->pNext;
    					pNode->pNext->pPrev = pNode->pPrev;
    				}
    				pNode = pNode->pNext;
    			}
    			free(pDeleteNode);
    			pDeleteNode = NULL;
    		}
    		else
    		{	
    			pNode = pNode->pNext;
    		}
    			
    	}
    	return pHead;
    }
    
    int main()
    {
    	LINKNODE * pHead = NULL;
    	pHead = (LINKNODE *)malloc(sizeof(LINKNODE));
    	pHead->m_Value = -1;
    	pHead->pNext = NULL;
    	pHead->pPrev = NULL;
    	CreateLinkNode(pHead);
    	ShowLinkNode(pHead);
    	printf("\n");
    	pHead = DeleteLinkNode(pHead,8);
    	printf("After Delete Target Num :\n");
    	ShowLinkNode(pHead);
    }

    展开全文
  • 上午写了下单向循环链表的程序,今天下午我把双向链表的程序写完了。其实双向链表和单向链表也是有很多相似的地方的,听名字可以猜到,每个节点都包含两个指针,一个指针指向上一个节点,一个指针指向下一个节点。...

    上午写了下单向循环链表的程序,今天下午我把双向链表的程序写完了。其实双向链表和单向链表也是有很多相似的地方的,听名字可以猜到,每个节点都包含两个指针,一个指针指向上一个节点,一个指针指向下一个节点。这里有两个特殊的地方,第一就是头节点的一个指针指向NULL空指针(没有前驱节点),第二就是尾节点的一个指针指向NULL指针(没有后继节点)。

    我们可以看下双向链表的示意图(自己画的比较难看):


    所以,我们在编程序的时候,这两个指针的控制就是我们的难点,因为我们始终要让这个链表保持这样的链接不管是在创建的时候、插入的时候、删除的时候等,一定要让节点的两个指针指向正确的节点。下面我们来看下双向链表的代码。

    DbLinkList.h  头文件——包含节点结构的定义和各种操作函数的声明。

    #ifndef DOUBLY_LINKED_LIST_H
    #define DOUBLY_LINKED_LIST_H
    
    typedef struct Node
    {
    	int data;
    	struct Node *pNext;
    	struct Node *pPre;
    }NODE, *pNODE;
    
    //创建双向链表
    pNODE CreateDbLinkList(void);
    
    //打印链表
    void TraverseDbLinkList(pNODE pHead);
    
    //判断链表是否为空
    int IsEmptyDbLinkList(pNODE pHead);
    
    //计算链表长度
    int GetLengthDbLinkList(pNODE pHead);
    
    //向链表插入节点
    int InsertEleDbLinkList(pNODE pHead, int pos, int data);
    
    //从链表删除节点
    int DeleteEleDbLinkList(pNODE pHead, int pos);
    
    //删除整个链表,释放内存
    void FreeMemory(pNODE *ppHead);
    
    #endif

    DbLinkList.cpp 双向链表的源文件——包含了各种操作函数的定义。

    (1)这部分是创建双向链表,和单向链表很相似,但是呢,有些地方还是得注意,就是每创建一个节点的时候都要注意初始化它的两个指针。

    #include <stdio.h>
    #include <stdlib.h>
    #include "DbLinkList.h"
    
    //创建双向链表
    pNODE CreateDbLinkList(void)
    {
    	int i, length = 0, data = 0;
    	pNODE pTail = NULL, p_new = NULL;
    	pNODE pHead = (pNODE)malloc(sizeof(NODE));
    
    	if (NULL == pHead)
    	{
    		printf("内存分配失败!\n");
    		exit(EXIT_FAILURE);
    	}
    	
    	pHead->data = 0;
    	pHead->pPre = NULL;
    	pHead->pNext = NULL;
    	pTail = pHead;
    
    	printf("请输入想要创建链表的长度:");
    	scanf("%d", &length);
    
    	for (i=1; i<length+1; i++)
    	{
    		p_new = (pNODE)malloc(sizeof(NODE));
    
    		if (NULL == p_new)
    		{
    			printf("内存分配失败!\n");
    			exit(EXIT_FAILURE);
    		}
    
    		printf("请输入第%d个元素的值:", i);
    		scanf("%d", &data);
    
    		p_new->data = data;
    		p_new->pNext = NULL;
    		p_new->pPre = pTail;
    		pTail->pNext = p_new;
    		pTail = p_new;
    	}
    
    	return pHead;
    }

    (2)这部分是获得双向链表的信息,这里和单向链表基本一致,因为遍历的时候只用到了一个指针。

    //打印链表
    void TraverseDbLinkList(pNODE pHead)
    {
    	pNODE pt = pHead->pNext;
    
    	printf("打印链表如:");
    	while (pt != NULL)
    	{
    		printf("%d ", pt->data);
    		pt = pt->pNext;
    	}
    	putchar('\n');
    }
    
    //判断链表是否为空
    int IsEmptyDbLinkList(pNODE pHead)
    {
    	pNODE pt = pHead->pNext;
    
    	if (p == NULL)
    		return 1;
    	else
    		return 0;
    }
    
    //计算链表的长度
    int GetLengthDbLinkList(pNODE pHead)
    {
    	int length = 0;
    	pNODE pt = pHead->pNext;
    
    	while (pt != NULL)
    	{
    		length++;
    		pt = pt->pNext;
    	}
    	return length;
    }

    (3)这部分是向双向链表插入节点,也跟单向链表很多相似的地方。我们先来看下插入节点时的示意图:


    从图中可以看到,每次我们添加一个节点都有很多地方要调节的,也就是每个节点的那两个指针,一定要认真仔细自己动手写一遍,有可能有些细节就会出错。这里有一个地方需要注意,是和单向链表不同的地方,单向链表在插入节点的时候不需要判断最后一个节点是否为空,因为这不影响程序的结果,但是对于双向链表就不一样了,因为我们后面要用到最后一个节点的一个指针指向前一个节点,如果最后一个节点是空的话(就是程序中的pt),就不存在pt->pPre了,那么程序运行到这里时就会报错,所以我们要加个判断,判断此时节点是NULL的话就不需要控制它的指针了。

    //向双向链表中插入节点
    int InsertEleDbLinkList(pNODE pHead, int pos, int data)
    {
    	pNODE pt = NULL, p_new = NULL;
    
    	if (pos > 0 && pos < GetLengthDbLinkList(pHead)+2)
    	{
    		p_new = (pNODE)malloc(sizeof(NODE));
    
    		if (NULL == p_new)
    		{
    			printf("内存分配失败!\n");
    			exit(EXIT_FAILURE);
    		}
    
    		while (1)
    		{
    			pos--;
    			if (0 == pos)
    				break;
    			pHead = pHead->pNext;
    		}
    		
    		pt = pHead->pNext;
    		p_new->data = data;
    		p_new->pNext = pt;
    		if (NULL != pt)
    			pt->pPre = p_add;
    		p_new->pPre = pHead;
    		pHead->pNext = p_new;
    		
    		return 1;
    	}
    	else
    		return 0;
    }

    (4)这部分是从链表中删除节点,当然这里和单向链表差不多,要注意的地方和插入节点时是一样的,上面已经说明了。

    //从链表中删除节点
    int DeleteEleDbLinkList(pNODE pHead, int pos)
    {
    	pNODE pt = NULL;
    
    	if (pos > 0 && pos < GetLengthDbLinkList(pHead) + 1)
    	{
    		while (1)
    		{
    			pos--;
    			if (0 == pos)
    				break;
    			pHead = pHead->pNext;
    		}
    
    		pt = pHead->pNext->pNext;
    		free(pHead->pNext);
    		pHead->pNext = pt;
    		if (NULL != pt)
    			pt->pPre = pHead;
    
    		return 1;
    	}
    	else
    		return 0;
    }

    (5)这部分是用来释放内存的,注意的地方和上面一样。

    //删除整个链表,释放内存
    void FreeMemory(pNODE *ppHead)
    {
    	pNODE pt = NULL;
    
    	while (*ppHead != NULL)
    	{
    		pt = (*ppHead)->pNext;
    		free(*ppHead);
    		if (NULL != pt)
    			pt->pPre = NULL;
    		*ppHead = pt;
    	}
    }

    main.cpp 测试程序源文件——通过简单的交互信息来测试各个函数功能是否正确。

    #include <stdio.h>
    #include <stdlib.h>
    #include "DbLinkList.h"
    
    int main(void)
    {
    	int flag = 0, length = 0;
    	int position = 0, value = 0;
    	pNODE head = NULL;
    
    	head = CreateDbLinkList();
    
    	flag = IsEmptyDbLinkList(head);
    	if (flag)
    		printf("双向链表为空!\n");
    	else
    	{
    		length = GetLengthDbLinkList(head);
    		printf("双向链表的长度为:%d\n", length);
    		TraverseDbLinkList(head);
    	}
    
    	printf("请输入要插入节点的位置和元素值(两个数用空格隔开):");
    	scanf("%d %d", &position, &value);
    	flag = InsertEleDbLinkList(head, position, value);
    	if (flag)
    	{
    		printf("插入节点成功!\n");
    		TraverseDbLinkList(head);
    	}	
    	else
    		printf("插入节点失败!\n");
    
    	flag = IsEmptyDbLinkList(head);
    	if (flag)
    		printf("双向链表为空,不能进行删除操作!\n");
    	else
    	{
    		printf("请输入要删除节点的位置:");
    		scanf("%d", &position);
    		flag = DeleteEleDbLinkList(head, position);
    		if (flag)
    		{
    			printf("删除节点成功!\n");
    			TraverseDbLinkList(head);
    		}	
    		else
    			printf("删除节点失败!\n");
    	}
    
    	FreeMemory(&head);
    	if (NULL == head)
    		printf("已成功删除双向链表,释放内存完成!\n");
    	else
    		printf("删除双向链表失败,释放内存未完成!\n");
    
    	return 0;
    }

    PS:相信对很多人来说链表的相关知识其实不难,很快能把这个程序编出来。但是还是有很多细节的问题要自己编过才知道的,我自己在学习的过程中就遇到过,所以我不让大家再走弯路。

    展开全文
  • 目前我们所学到的链表,无论是动态链表还是静态链表,表中各节点中都只包含一个指针(游标),且都统一指向直接后继节点,通常称这类链表为单向链表(或双向链表(简称双链表)。从名字上理解双向链表,即链表是 ...
  • 主要介绍了c++双向链表操作示例,包括创建双向链、删除双向链表双向链表中查找数据、插入数据等,需要的朋友可以参考下
  • 双向链表1.1 双向链表创建1.2 双向链表插入结点1.3 双向链表删除指定结点1.4 双向链表删除指定元素1.5 双向链表查找元素位置1.6 双向链表更新结点数据1.7 双向链表遍历2. 双向循环链表2.1 双向循环链表创建2.2 双向...
  • 数据结构 双向链表创建和读取 双向链表是为了满足更加方便的查找前驱,而付出空间的代价的一个数据结构。双向链表的节点定义如下: typedef struct node { int x; struct node *prior,*next; }DLNode; 双向...
  • 创建双向链表

    2020-11-27 18:29:18
    创建双向链表 单项链表节点的存储结构只有一个指向直接后继的指针域,所以从链表的某个节点出发只能顺指针查找其他节点。使用双向链表可以避免单项链表这种单项性的缺点。 顾名思义,双向链表的节点有两个指针域...
  • C语言双向链表

    2015-08-13 20:02:00
    双向链表创建,可对 链表元素进行删除、查询、添加、修改
  • -- 【C2】【双向链表】用尾插法创建带头节点的双向链表并删除一个指定位置的结点1891: 【C2】【双向链表】用尾插法创建带头节点的双向链表并删除一个指定位置的结点时间限制:1 Sec内存限制:128 MB提交:769解决:577...
  • 双向链表是为了满足更加方便的查找前驱,而付出空间的代价的一个数据结构。双向链表的节点定义如下: 1 typedef struct node ...双向链表创建如下: 1 //创建双向链表 2 DLNode *create
  • 教你使用双向链表

    2020-04-22 09:54:26
    文章目录双向单链表操作双向链表节点定义双向链表创建双向链表的简单插入双向链表的删除双向链表合并双向链表显示 双向单链表操作 双向链表节点定义 typedef struct List { ElemType data; struct List *prior; ...
  • **双向链表创建、插入、删除**创建一个双向链表的数据结构双向链表结构创建双链表并初始化正向遍历链表反向遍历链表双向链表的尾插双向链表的头插在指定位置插入节点删除指定节点主函数整体工程CMD运行结果 创建一...
  • 那么本文将介绍一下另一种特殊的链表结构,叫做 双向链表。 顾名思义,普通的链表都是从 head 开始往后遍历结构内的元素,那么双向链表就是既可以从头开始遍历,又可以从结构的末尾开始遍历。 上一篇文章的跳转链接...
  • 双向链表

    2019-05-25 18:59:00
    1:创建双向链表 2:遍历双向链表 3:双向链表长度获取 4:双向链表节点的插入 5:双向链表节点的删除 6:双向链表倒序 7:双向链表排序 8:双向链表销毁 9:双向链表判空 */ #include<iostream> ...
  • 循环链表一些操作1,将两个循环链表合并O(1)O(1)O(1)三,双向链表一些操作1,双向链表的元素插入2,双向链表的元素删除四,双向循环链表一些操作1,尾插法插入元素2,直接创建一个含n个元素的循环双向链表3,...
  • 双向链表在保持这一特征之外,最大的区别就是,每一个节点还指向了它的上一个节点,即每个节点的指针域多了一个指向前驱的指针,从而形成了一个反向的链,所以将这种链表称作双向链表. 不难看出,其实双向链表由单链表...
  • 双向链表操作

    2014-10-28 11:22:06
    内容:双向链表创建,遍历,删除,插入。自己看图写代码,只是随写,本人初学者。
  • 创建双向链表(详解)

    万次阅读 多人点赞 2018-11-25 16:18:46
    双向链表操作 在学习了单链表之后,就顺带学习了双链表的操作。 什么是双链表? 双链表顾名思义,就是链表由单向的链变成了双向链。 使用这种数据结构,我们可以不再拘束于单链表的单向创建于遍历等操作,大大减少...
  • 首先讲循环链表,简单来说就是让链表首尾相连,形成一个环,因为一般的链表都是单向的,任意给出的一个节点是不能访问前面的链节,这就导致了单向链表的局限性,循环链表从一定程度上来说就解决了这一问题,通过表头...
  • 双向链表创建、逆序、删除。附件是vs2008编译的工程,自己调试通过的。
  • 双向链表创建与相关基本函数 昨天我们已经讲了单向链表 https://blog.csdn.net/frc8011_zzr/article/details/111657732 在单向链表的基础上我们给每一个结构体加上一个prev指针指向上一个结构体就能实现双向链表...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 82,734
精华内容 33,093
关键字:

双向链表的创建