1. 請編寫在帶頭結點的單鏈表L上刪除其值為奇數的所有元素的演算法
#include
#include
#define
LEN
sizeof(struct
Node)
struct
Node
{
int
num
;
struct
Node
*next;
};
int
main()
{
struct
Node
*creat();
struct
Node
*del(struct
Node
*head);
void
print(struct
Node
*);
struct
Node
*head;
head=creat();
print(head);
printf("刪除相同的結點後：\n");
del(head);
print(head);
return
0;
}
//建立鏈表的的函數
struct
Node
*creat()
{
struct
Node
*head;
struct
Node
*p1,*p2;
p1=p2=(struct
Node
*)
malloc(LEN);
head=NULL;
int
n
=
0;
p1->num
=
n;
while
(p1->num
<
19)
{
n=n+1;
if(n==1)head=p1;
else
p2->next=p1;
p2=p1;
p1=(struct
Node
*)malloc(LEN);
p1->num
=
n;
}
p2->next=NULL;
return
(head);
}
//刪除相同結點的函數
struct
Node
*del(struct
Node
*head)
{
struct
Node
*p,*q,*f,*r;
p=head;
while(p!=NULL)
{
r=p;
f=r->next;
while(f!=NULL)
{
if(f->num
%
2
!=
0)
{
q=f;
r->next=f->next;
f=f->next;
free(q);
}
else
{
r=f;
f=f->next;
}
}
p=p->next;
}
return
head;
}
//輸出鏈表的函數
void
print(struct
Node
*head)
{
struct
Node
*p;
p=head;
while
(p!=NULL)
{
printf("%d\n",p->num);
p=p->next;
}
}
2. 帶表頭結點的單鏈表，其結點的元素值以非遞減有序排列，編寫一個演算法刪除該鏈表中多餘的元素值相同的結點
voidsubstract(Node&h)//h是頭結點
{
Node*p=h.next;//p指向第一個元素節點
while(p&&p->next){//p不是最後一個元素節點
if(p->data==p->next->data){//p和下一個節點數據相等，則刪除下一節點
Node*temp=p->next;
p->next=temp->next;
delete[]temp;
}else{//不相等則p指向下一節點
p=p->next;
}
}
}
3. 7.試設計實現刪除單鏈表中值相同的多餘結點的演算法
.....做題啊
解：該例可以這樣考慮，先取開始結點的值，將它與其後的所有結點值一一比較，發現相同的就刪除掉，然後再取第二結點的值，重復上述過程直到最後一個結點。
設單鏈表（其類型為LinkList）的頭指針head指向頭結點，則可按下列步驟執行：
首先，用一個指針p指向單鏈表中第一個表結點，然後用另一個指針q查找鏈表中其餘結點元素，由於是單鏈表，故結束條件為p= =NULL，同時讓指針s指向q所指結點的前趨結點，當查找到結點具有q->data= =p->data時刪除q所指的結點，然後再修改q，直到q為空；然後使p指針後移（即p=p->next），重復進行，直到p為空時為止。演算法描述如下：
del(LinkList *head)
{ //刪除單鏈表中值相同的多餘結點
LinkList *p, *s, *q;
p=head->next;
while(p!=NULL && p->next!=NULL)
{ s=p; //s指向要刪除結點的前趨
q=p->next;
while (q!=NULL)
{ if (q->data= =p->data)} //查找值相同的結點並刪除
{ s->next=q->next;
free(q);
q=s->next;
}
else
{ s=q;
q=q->next;
}
}
p=p->next;
}
}
4. 編寫演算法。函數功能為刪除帶頭結點鏈表L中所有元素大於e的結點，函數返回值為刪除結點的個數
您好，這樣的：
#include<stdio.h>
#include<malloc.h>
#define LEN sizeof(struct Node)
struct Node
{
int num ;
struct Node *next;
};
int main()
{
struct Node *creat();
struct Node *del(struct Node *head);
void print(struct Node *);
struct Node *head;
head=creat();
print(head);
printf("刪除相同的結點後：\n");
del(head);
print(head);
return 0;
}
//建立鏈表的的函數
struct Node *creat()
{
struct Node *head;
struct Node *p1,*p2;
p1=p2=(struct Node *) malloc(LEN);
head=NULL;
int n = 0;
p1->num = n;
while (p1->num < 19)
{
n=n+1;
if(n==1)head=p1;
else p2->next=p1;
p2=p1;
p1=(struct Node *)malloc(LEN);
p1->num = n;
}
p2->next=NULL;
return (head);
}
//刪除相同結點的函數
struct Node *del(struct Node *head)
{
struct Node *p,*q,*f,*r;
p=head;
while(p!=NULL)
{
r=p;
f=r->next;
while(f!=NULL)
{
if(f->num % 2 != 0)
{
q=f;
r->next=f->next;
f=f->next;
free(q);
}
else
{
r=f;
f=f->next;
}
}
p=p->next;
}
return head;
}
//輸出鏈表的函數
void print(struct Node *head)
{
struct Node *p;
p=head;
while (p!=NULL)
{
printf("%d\n",p->num);
p=p->next;
}
}
5. 單鏈表中刪除第一個結點的演算法
頭結點是第一結點，只是一般沒有數據頭結點後面是首元結點，即第一個存放數據的結點做刪除操作時，一般需要返回所刪除結點的數據，所以一般不刪除頭結點如果你執意要刪的話，當然也可以，因為鏈表分為有頭結點的鏈表和無頭結點的鏈表
6. 順序表、單鏈表的刪除演算法
單鏈表的刪除操作是指刪除第i個結點，返回被刪除結點的值。刪除操作也需要從頭引用開始遍歷單鏈表，直到找到第i個位置的結點。如果i為1，則要刪除第一個結點，則需要把該結點的直接後繼結點的地址賦給頭引用。對於其它結點，由於要刪除結點，所以在遍歷過程中需要保存被遍歷到的結點的直接前驅，找到第i個結點後，把該結點的直接後繼作為該結點的直接前驅的直接後繼。刪除操作如圖
單鏈表的刪除操作示意圖
刪除操作的演算法實現如下：
public T Delete(int i)
{
if (IsEmpty()|| i < 0)
{
Console.WriteLine("Link is empty or Position is error!");
return default(T);
}
Node q = new Node();
if (i == 1)
{
q = head;
head = head.Next;
return q.Data;
}
Node p = head;
int j = 1;
while (p.Next != null&& j < i)
{
++j;
q = p;
p = p.Next;
}
if (j == i)
{
q.Next = p.Next;
return p.Data;
}
else
{
Console.WriteLine("The ith node is not exist!");
return default(T);
}
}
演算法的時間復雜度分析：單鏈表上的刪除操作與插入操作一樣，時間主要消耗在結點的遍歷上。如果表為空則不進行遍歷。當表非空時，刪除第i個位置的結點， i等於1遍歷的結點數最少（1個），i等於n遍歷的結點數最多（n個，n為單鏈表的長度），平均遍歷的結點數為n/2。所以，刪除操作的時間復雜度為O（n）。
7. java單線鏈表、雙向鏈表及循環鏈表中插入某節點,和刪除某節點的演算法（可能是頭結點、中間節點、尾節點）
API里有現成的，直接用好了
java.util.List
remove
E remove(int index)移除列表中指定位置的元素（可選操作）。將所有的後續元素向左移動（將其索引減 1）。返回從列表中移除的元素。
參數：
index - 要移除的元素的索引
返回：
以前在指定位置的元素
拋出：
UnsupportedOperationException - 如果列表不支持 remove 操作
IndexOutOfBoundsException - 如果索引超出范圍 (index < 0 || index >= size())
remove
boolean remove(Object o)從此列表中移除第一次出現的指定元素（如果存在）（可選操作）。如果列表不包含元素，則不更改列表。更確切地講，移除滿足 (o==null ? get(i)==null : o.equals(get(i))) 的最低索引 i 的元素（如果存在這樣的元素）。如果此列表已包含指定元素（或者此列表由於調用而發生更改），則返回 true。
指定者：
介面 Collection<E> 中的 remove
參數：
o - 要從該列表中移除的元素，如果存在的話
返回：
如果列表包含指定的元素，則返回 true
拋出：
ClassCastException - 如果指定元素的類型和此列表不兼容（可選）
NullPointerException - 如果指定的元素是 null，並且此列表不允許 null 元素（可選）
UnsupportedOperationException - 如果列表不支持 remove 操作
8. 數據結構演算法編程題，刪除帶頭結點的單鏈表中最大元素或最小元素
//刪除單鏈表中最大元素
Del-max(link a){
int tmp;
element *p;
element *max;
p=a; //指針，用於遍歷鏈表，取數與當前最大結點值比較
max=a; //指針，用於記錄最大元素所在位置（未考慮有多個最大元素）
tmp=p->data; //變數，用於記錄當前最大結點值
while(a->next!=null){
p=p->next;
if(p->data>tmp){ 、//如果當前指針所指結點值大於當前tmp所保留的值，則記錄
max=p; //當前位置（放入到max），記錄當前最大值（放入tmp）
tmp=p->data;
} //end of if
} //end of while
tmp=max->next->data; //一次遍歷後max指針所指結點就是最大元素，刪除之。。。
max->data=tmp;
max->next=max->next->next; //刪除方法能看懂么？好好思考。。。
}//end of Del-max
9. 寫一個演算法，刪除帶頭結點的雙向循環鏈表中最大的數據元素C++
數據類型和成員名按實際情況作適當變動：
void DeleteMax(DLNode *head)
{
if (head->next == head)
return; // 空表直接返回
DLNode *p = head->next, *q = p; // q 當前最大
while (p != head)
{ // 尋找最大值結點
if (p->data > q->data)
q = p;
p = p->next;
}
q->prior->next = q->next;
q->next->prior = q->prior;
delete q;
}
10. 求數據結構程序！！寫出在帶頭結點的單向鏈表l中刪除第i個結點的演算法。
插入和刪除的演算法
Status ListInsert(LinkList &L,int i,ElemType e)
{ // 在不設頭結點的單鏈線性表L中第i個位置之前插入元素e
int j=1; // 計數器初值為1
LinkList s,p=L; // p指向第1個結點
if(i<1) // i值不合法
return ERROR;
s=(LinkList)malloc(sizeof(LNode)); // 生成新結點，以下將其插入L中
s->data=e; // 給s的data域賦值e
if(i==1) // 插在表頭
{ s->next=L; // 新結點指向原第1個結點
L=s; // L指向新結點(改變L)
}
else
{ // 插在表的其餘處
while(p&&j<i-1) // 尋找第i-1個結點
{ j++; // 計數器+1
p=p->next; // p指向下一個結點
}
if(!p) // i大於表長+1
return ERROR; // 插入失敗
s->next=p->next; // 新結點指向原第i個結點
p->next=s; // 原第i-1個結點指向新結點
}
return OK; // 插入成功
}
Status ListDelete(LinkList &L,int i,ElemType &e)
{ // 在不設頭結點的單鏈線性表L中，刪除第i個元素，並由e返回其值
int j=1; // 計數器初值為1
LinkList q,p=L; // p指向第1個結點
if(!L) // 表L空
return ERROR; // 刪除失敗
else if(i==1) // 刪除第1個結點
{ L=p->next; // L由第2個結點開始(改變L)
e=p->data; // 將待刪結點的值賦給e
free(p); // 刪除並釋放第1個結點
}
else
{ while(p->next&&j<i-1) // 尋找第i個結點，並令p指向其前驅
{ j++; // 計數器+1
p=p->next; // p指向下一個結點
}
if(!p->next||j>i-1) // 刪除位置不合理
return ERROR; // 刪除失敗
q=p->next; // q指向待刪除結點
p->next=q->next; // 待刪結點的前驅指向待刪結點的後繼
e=q->data; // 將待刪結點的值賦給e
free(q); // 釋放待刪結點
}
return OK; // 刪除成功
}