双向链插入算法

❶ 双向链表 写出在双向循环链表中插入一个节点的算法

void insert_node(Node current_node, Node new_node){

new_node->next = current_node->next;

current_node->next->prev = new_node;

current_node->next = new_node;

new_node->prev = current_node;

}

给你看一下这个过程的图解(画得有点乱)

❷ 谁知道..用C语言描述双向链表的插入的算法

实际上，算法类似于单链表的插入
描述如下
例如p前<->p<->p后，现在要求改为p前<->p<->s<->p后
那么
s->next=p->next; //s的后继
*(p->next)->pred=s; //p后的前驱
p->next=s; //p的后继
s->pred=p; //s的前驱
插入完成

❸ 双向链表p点后插入节点的算法

双向链表节点:\r\ntypedef struct LinkNode\r\n{\r\n struct LinkNode * pre;\r\n\r\n struct LinkNode *next;\r\n\r\n int data;\r\n\r\n}node;\r\nsrand()\r\nrand()\r\n产生随机数插入到链表\r\n然后你可以网络一下直接插入排序算法，修改指针指向完成排序\r\n\r\n单链表:\r\ntypedef struct LinkNode\r\n{\r\n struct LinkNode *next;\r\n\r\n int data;\r\n\r\n}\r\n方法同上，\r\n自己动手做一下，有助于提高。其实动起手来很简单的，不要想的太复杂

❹ 关于双向链表插入算法的问题,高手请>>>

这个是计算机考试公共基础的内容吧！在线性单链表中，每一个节点只有一个指针域，由这个指针只能找到后件结点，但不能找到前件结点。因此在单链表中只能顺指针向链尾方向进行扫描，这对于某些问题的处理会带来不便，因为在这种方式下，由某一个节点出发。只能找到他的后件，而为了找到他的前件必须从头开始找！未了弥补单链表这个缺点，我们采用双向链表，它的每个节点设有两个指针，左指针和右指针，左指针指向前件，右指针指向后件。循环链表相比前面的单链表有两个特点：增加了一个表头指针：链表最后一个节点的指针域不是空，而是指向表头结点，这就形成循环了！再循环链表中，只要指出表中任意一个结点的位置，就可以从它出发访问表中其他所有的结点，耳线性链表做不到这一点。
以上介绍了他们的特点，插入和删除运算就是利用栈来进行，而首先就是查找指定元素，以上三个查找上的不同决定了插入和删除的效率。此外循环链表和单链表的插入删除基本一样，都是一个指针，就是查找指定元素时方式不一！！！

希望可以帮到你！！！

❺ 请问什么是双向插入法

逐点插入法进行构网，分析该算法中制约运行速度的因素，在三角网拓扑关系、三角形的查找、LOP算法（Local Optimization Procere）等方面进行了优化处理，使之有了较高的执行效率。
1 数据结构
在采用逐点插入进行Delaunay三角剖分的过程中，存在大量的查询操作，利用数据结构提供三角形之间的拓扑信息，能够有效地提高算法效率。边结构应包含点与三角形的信息，三角形结构应包含点与边的信息，再考虑到构网过程中动态的数据更新，算法中采用了双向链表结构，以方便于剖分过程中新旧边（三角形）的添加、删除工作。
2 算法原理
逐点插入法是Lawson在1977年提出的，该算法思路简单，易于编程实现。基本原理为：对于已有的三角网络，向其中插入一点，该点与包含它的三角形三个顶点相连，形成三个新的三角形，然后逐个对它们进行空外接圆检测，通过交换对角线的方法来保证所形成的三角网为Delaunay三角网。
3 算法基本步骤

a: 点在三角形内，b:点在三角形边上。
在按a进行剖分时，添加了三条新边及三个新三角形NT，删除了旧三角形T。同样，在b的情况中，记录点所在的边E，根据拓扑关系，找出该边的左右相邻三角形T1，T2，添加四条新边和四个新三角形NT，删除T1，T2以及边E。
构网的关键是对新剖分出的三角形用LOP算法进行优化，其基本过程为：新三角形与周围的三角形构成共用同一条对角线的四边形，逐个对四边形中的两个三角形进行空外接圆检测，如果满足空外接圆准则，则略过。如果不满足，则用另一对角线替换现有对角线，在交换对角线后，又会产生相应的新四边形，继续进行空外接圆检测。这种方法可连续进行,直到全部满足空外接准则为止。这个过程是随着数据点P的逐次插入，与三角剖分同时进行的，可以通过递归调用优化程序来实现。

❻ 双向链表 插入操作

我感觉在进行指针操作时，最重要的是要注意指针的保存。在对双向链表进行插入操作时，顺序可能并不唯一，但是你要自己分析清楚每个节点的前驱和后继指针分别指向谁。画个图可能能更好的去理解~~

比如在节点p后面插入节点t：

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

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

这两种顺序都是OK的~

可以画图理解一下，也可以参考一下我参考资料中的链接

❼ 双向链表中连续两个节点p,q之间 插入一个s

p->next = s;
s->next = q;
s->front = p;
q->front = s;
如果不明白,再HI我吧

❽ 算法实现：在带头结点的双向链表中插入和删除一个结点，请写出伪代码

先来说说整体思想，我们可以发现序号为奇数的元素的前后相对位置未变，只是偶数位置有变化。这样的话，我们可以将偶数按序号逆序（由大到小）插入到链表尾部。考虑到时间复杂度问题，在搜索偶数的过程中，可以先找到最大的偶数序号+1的位置（是个奇数，奇数相对位置不动），记下它的位置为L，L向前指的那个位置是偶数位置。这样再找下一个时，直接用L-2，直至k-2等于3为止即可找到所有序号为偶数的位置。

怎么化整为零呢？先来看看下面这个过程：
null
1 2 （1是从head的后面插入链表，2是从tail的前面插入链表）
1 3 2 （3是从1的后面插入链表）
1 3 4 2（4是从2的前面插入链表）
1 3 5 4 2（5是从3的后面插入链表）
......
1 3 5 ... n ... 6 4 2
由此，我们可以设置2个指针p，q，分别指向刚刚序号为奇数的元素插入的位置和刚刚序号为奇数的元素插入的位置，下一个序号为奇数的元素插入到p后，为偶数的插入到q前，并随着插入的过程实时变化p，q，最后再将q和q指向的元素之间的2个指针接上就OK了。

程序交给你来写吧，应该不太难。

❾ 双向链表的顺序插入算法

#include <stdio.h>
#include <stdlib.h>
typedef struct tagDbNode
{
int num;
struct tagDbNode * pre;
struct tagDbNode * next;
} DbNode, * pdbNode;
//创建结点
pdbNode CreateNode(int num)
{
pdbNode pnode = (pdbNode)malloc(sizeof(DbNode));
pnode->num = num;
pnode->pre = pnode->next = pnode; //创建新结点时，让其前驱和后继指针都指向自身
return pnode;
}
//创建链表
pdbNode CreateList(int head) //参数给出表头结点数据 （表头结点不作为存放有意义数据的结点）
{
pdbNode pnode = (pdbNode)malloc(sizeof(DbNode));
pnode->num = head;
pnode->pre = pnode->next = pnode;
return pnode;
}
//获取链表的长度
int GetLength(pdbNode *node) // 参数为链表的表头结点
{
int i=1;
pdbNode x=*node;
pdbNode y=x->next;
while(y!=x)
{
y=y->next;
i++;
}
return(i);
}
//插入新结点,顺序插入
pdbNode InsertNode(pdbNode *node,int num) // 参数1是链表的表头结点，参数2是要插入的结点（结点数据为num）
{
pdbNode x=*node;
pdbNode y=x;
x=x->next;
if(y->num<num)
{
pdbNode a=(pdbNode)malloc(sizeof(tagDbNode));
a->num=num;
a->next=y;
a->pre=y->pre;
y->pre->next=a;
y->pre=a;
(*node)=a;//
return a;
}
while(x!=y)
{
if(x->num<num)
{
pdbNode a=(pdbNode)malloc(sizeof(tagDbNode));
a->num=num;
a->next=x;
a->pre=x->pre;
x->pre->next=a;
x->pre=a;
return y;
}
else
{
x=x->next;
}
}
pdbNode a=(pdbNode)malloc(sizeof(tagDbNode));
a->num=num;
a->next=y;
a->pre=y->pre;
y->pre->next=a;
y->pre=a;
return y;
}
//打印整个链表
void PrintList(pdbNode node) // 参数为链表的表头结点
{
pdbNode pnode;
if (NULL == node) return;
pnode= node->next;
printf("%d ", node->num);
while (pnode != node)
{
printf("%d ", pnode->num);
pnode = pnode ->next;
}

printf("\n");
}
//测试程序
#include <stdio.h>
#include <stdlib.h>
//#include "dblist.h"
#define FALSE 0
#define TRUE 1
void main()
{
int nChoose;
int num;
bool bFlag = FALSE;
pdbNode pnode;
pdbNode list = CreateList(0);
pdbNode *head=&list;//是指向指针的指针，因为头结点会变，而这种变化要传回来，只能用指向指针的指针
while(FALSE == bFlag)
{
printf("主目录\n");
printf("1. 插入一个节点\n");
printf("2. 删除一个节点\n");
printf("3. 查找节点\n");
printf("4. 打印链表\n");
printf("5. 删除链表\n");
printf("0. 退出\n\n");
scanf("%d", &nChoose);
switch(nChoose)
{
case 1:
printf("请输入要插入的数据:");
scanf("%d", &num);
list = InsertNode(head, num);
PrintList(*head);
break;
case 2:
printf("请输入要删除的数据:");
scanf("%d", &num);
//DeleteNode(*head, num);
break;
case 3:
printf("请输入要查找的数据:");
scanf("%d", &num);
//pnode = FindNode(list, num);
if (NULL != pnode)
{printf("查找成功!\n");
}
else
{ printf("没有这个数据!\n");
}
break;
case 4:
PrintList(list);
break;
case 5:
//DeleteList(list);
break;
case 6:
printf("这各表的长度为： %d", GetLength(head));
break;
case 0:
//DeleteList(list);
bFlag = TRUE;
}
}
}

我的这个答案，在函数调用的时候，利用的是指向指针的指针，因为开始没有注意到你用的函数有头结点的返回值，所以和你原来给的变动较大，不过还是希望我写的你可以理解，因为我的注释较少（太懒了），所以，将就着看吧

❿ 在双向链表中实现插入和删除，用c编程实现

语法错误已经全部改了，插入算法还有逻辑错误，现在没时间修改了
#include<stdio.h>
#include<stdlib.h>
typedef struct DULNODE{
int data;
struct DULNODE *priou;
struct DULNODE *next;
}DULNODE,*Dulinklist;
Dulinklist creat(Dulinklist L)//创建
{
int node;
Dulinklist p;
L=(Dulinklist)malloc(sizeof(DULNODE));
L->next=NULL;
L->priou=NULL;
printf("\nplease input the node(end with 0)");
scanf("%d",&node);
while(node!=0)
{
p=(Dulinklist)malloc(sizeof(DULNODE));
p->data=node;
p->next=L->next;
L->next=p;
p->priou=L;
printf("\nplease input the node(end with 0):");
scanf("%d",&node);
}
return L;
}
Dulinklist insert(Dulinklist L,int i,int x)//插入函数
{
int j;
Dulinklist p,s;
p=L;j=0;
while(p!=NULL&&j<i-1)
{
p=p->next;
++j;
}
if(!(s=(Dulinklist)malloc(sizeof(DULNODE))))
printf("\nerror\n");
s->data=x;
p->next=s->next;
s->next=p->next;
s->next->priou=s->priou;
p->next=s;
return L;
}
Dulinklist Delete(Dulinklist L,int i)
{
int j,x;
Dulinklist p;
p=L,j=0;
while(p->next!=NULL&&j<i)
{
p=p->next;
++j;
}
x=p->data;
p->priou->next=p->next;
p->next->priou=p->priou;
printf("the delete value is %d",x);
free(p);
return L;
}
void display(Dulinklist L)//输出
{
Dulinklist p;
p=L->next;
while(p!=NULL)
{
printf("%d",p->data);
p=p->next;
printf("\n");
}
}
int main()//主函数
{
int i,x;
Dulinklist L;
L=creat(L);
display(L);
printf("\n please input the position you want to insert:");
scanf("%d",&i);
printf("\ninput the node you want to insert:");
scanf("%d",&x);
L=insert(L,i,x);
display(L);
printf("\nplease inout the node position you want to delete:");
scanf("%d",&i);
L=Delete(L,i);
display(L);
}