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; // 删除成功
}