❶ 雙向鏈表 寫出在雙向循環鏈表中插入一個節點的演算法
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);
}
