如何删除单链

① C语言单向链表的创建，输入，插入和删除的实现

/* 线性表-链表的操作: 只提供核心语句 */
#include "stdio.h"
#include "stdlib.h"
#define N 100
typedef int ElemType;/* 链表的存储结构 */
typedef struct LNode{
ElemType data;
struct LNode *next; } LNode,*LinkList;/* 链表的基本操作 *//******* 1.初始化链表 ******/
void InitList(LinkList *L)
{ *L=(LinkList)malloc(sizeof(LNode));
(*L)->next=NULL; }/******* 2.销毁链表 ******/
void DestroyList(LinkList *L)
{ LinkList p;
while(*L!=NULL)
{ p=*L;
*L=(*L)->next;
free(p); }
}
/******* 10.在顺序表第n个位置顷亮兆插入元素e ******/
void ListInsert(LinkList *L, int n, ElemType e)
{ LinkList p,q,new; int i;
q=*L; p=(*L)->next; i=1;
while (p!=NULL && i<n) { q=p; p=p->next; i++; }
new=(LinkList)malloc(sizeof(LNode));
new->data=e;
q->next=new; new->next=p; }/******* 11.删除链表中第n个位置的元素 ******/
void ListDelete(LinkList *L, int n, ElemType *e)
{ LinkList p,q; int i;
q=*L; p=(*L)->next; i=1;
while (p!=NULL && i<n) { q=p; p=p->next; i++; }
*e=p->data;
q->next=p->next; free(p); }/******* 12.遍历链表并输出 ******/
void ListTraverse(LinkList L)
{ LinkList p;
printf("\nList:\t");
p=L->next;
while (p!=NULL)
{ printf("%d\t",p->data);
p=p->next; }
}/******* A(2).后接法建立顺序链表雀租 ******/
void CreateList2(LinkList *L, ElemType a[], int n)
{ LinkList p,new; int i;
p=*L;
for(i=0; i<n; i++)
{ new=(LinkList)malloc(sizeof(LNode));
new->data=a[i];
p->next=new; p=p->next; }
p->next=NULL;
}
/* 主函数 */
main()
{ LinkList La; ElemType a[]={1,3,5,7,9},x;
InitList(&La);//初始化链表
CreateList2(&La,a,5);//建立链表并用键宽数组赋值
ListTraverse(La);//遍历链表
ListInsert(&La, 3, 100);//第三个位置插入100
ListTraverse(La);//遍历链表
ListDelete(&La,5,&x);//删除第五个元素,用x返回
ListTraverse(La);//遍历链表 DestroyList(&La);//销毁链表
} 这是我们刚学的，保证简洁准确

② 建立单向动态链表，并对它进行插入、删除和输入等操作，包括以下任务：

#include<stdio.h>
#define LEN sizeof(struct number)
struct number /*定义编号和数字*/
int name;
int num;
struct number * next;
};

struct number * create() /*建立链表函数*/
{
struct number * head,* new,* tail,* p;
int count=0;
while(1)
{
new=(struct number *)malloc(LEN);
printf("input Name and Number\n");
scanf("%d %d",&new->name,new->num); /*用尺核户输入编号和数字*/
if(new->name==0)
{
free(new);
break;
}
else if(count==0)
{
head=new;
tail=new;
}
else
{
tail->宽困氏next=new;
tail=new;
}
count++;
}
tail->next=NULL;
return(head);
}

struct number * delist(struct number *head,int name) /*删除数字的函数*/
{
struct number * p0,* p1;
p1=head;
if(head==NULL)
{
printf("\nempty list!\n");
}
else
if(p1->name==name) /*找到相同编慎散号*/
head=p1->next;
else
{
while(p1->name!=name&&p1->next!=NULL) /*逐一排查*/
{
p0=p1;
p1=p1->next;
}
if(p1->name==name)
{
p0->next=p1->next;
printf("The node is deleted\n");
}
else
printf("The node can not been foud!\n");
}
return head;
}

struct number * insert(struct number * head,struct number * new)
{ /*插入函数*/
struct number * p0,* p1;
p1= head;
if(head==NULL)
{
head=new;
new->next=NULL;
}
else
if(new->name<p1->name) /*寻找新数字适合的位置插入*/
{
new->next=head;
head=new;
}
else
{
while(new->name>p1->name)
{
p0=p1;
p1=p1->next;
}
new->next=p0->next;
p0->next=new;
}
return(head);
}

void print(struct number * head) /*打印函数*/
{
struct number * p;
p=head;
if(head==NULL) /*其实用不到*/
printf("list is empty\n");
else
while(p!=NULL)
{
printf("%d%d\n",p->name,p->num); /*打印链表内容*/
p=p->next;
}
}

struct number * find(struct number * head,struct number * new)
{ /*查询函数*/
struct number * p0,* p1;
p1= head;
if(head==NULL)
{
head=new;
new->next=NULL;
}
else
if(new->name!=p1->name) /*寻找和输入编号相同的节点,不是则往下读*/
{
new->next=head;
head=new;
}
else
{
while(new->name==p1->name)
{
printf（”find successfully!\n”）;
printf(“%d %d”,p1->name,p1->num);
}

}
return(head);
}

void main() /*主函数*/
{
struct number * head,* p;
int name;
head=create(); /*往下逐一调用函数*/
print(head);
printf("Input the delete number:");
scanf("%d",&name);
head=delist(head,name);
print(head);
printf("Input the inserted name and number:");
p=(struct number *)malloc(LEN);
scanf("&d&d",p->name,p->num);
head=insert(head,p);
print(head);
printf(“Input the found name:”);
scanf(“%d”,&name);
head=find(head,p);
print(head);

}

find函数你可以不用，在主函数中将find函数也一起删掉就行了。

③ 如何降解双链DNA中的单链DNA

单链的核酸外切酶包括大肠杆菌核酸外切酶Ⅰ（exoⅠ）和核酸外切酶Ⅶ（exoⅦ）。核酸外切酶Ⅶ（exoⅦ）能枝迹够从5′-末端或3′-末端呈单链状态的DNA分子上降解DNA，产生出寡核苷酸短片段，而且是唯一不需要Mg2+离子的活性酶，是一种耐受性很强的核酸酶。核酸外切酶Ⅶ（exoⅦ）可以用来测定基因组DNA中一些特殊的间隔序列和编码序列的位置。它只切割末端有单链突出的DNA分子。 双链的核酸外切酶包括大肠杆菌核酸外切酶Ⅲ（exoⅢ）、λ噬菌体核酸外切酶（λexo）以及T7噬菌体基因6核酸外切酶等。大肠杆菌核酸外切酶Ⅲ（exo Ⅲ）具有猛烂并多种催化功能，可历首以降解双链DNA分子中的许多类型的磷酸二酯键。其中主要的催化活性是催化双链DNA按3′→5′的方向从3′-OH末端释放5′-单核苷酸。大肠杆菌核酸外切酶Ⅲ（exoⅢ）通过其3′→5′外切酶活性使双链DNA分子产生出单链区，经过这种修饰的DNA再配合使用Klenow酶，同时加进带放射性同位素的核苷酸，便可以制备特异性的放射性探针。

④ C语言，单向链表 不知道前驱指针，如何删除某一节点。 情况考虑详尽一些！

伪代码:
if node.age ==30
delete(node)

delete是封装好了的代码

删除一个节点的步骤:
如我有一个链表:A B C D 四个元素
我要删除B,则有
p =A.next
A.next = p.next
free(p)

主要是思想对就行，一定要封装

你这个属于那种在线删除
就是先查找，如果符合条件，就删除。信野
删除操作，必须知道有删除的节点的前一个节点的地址才行。
那么你应散中该每次查找的时候不是判断当前节点是否符合要求，而是判断下一个节点。如果符合就按照删除节点的删除来。
删除操作的冲坦山三部曲:
第一步:保存删除节点的地址
第二步:将删除节点的前一个节点的指针域指向删除节点的下一个
第三部:free 需要删除节点

我现在直接在这里写代码了

void del(head,age)
{
p = head;
while(p)
{
if( p->next && p->next->age == age )//删除操作的三步曲
{
q=p->next;
p->next = q ->next;
free(q);
}//end if
p = p->next;
}//end while
}

代码就是这样的。很简单。这段代码并不能编译，你加上类型就好了。我强调的是方法。

⑤ 网站莫名的出现很多单链，在我自己的网站也没有找到，使用站长工具查到了，请问怎么消除这些链接啊

可能是被挂黑链了,你需要修改源程序里面的页面代码,找到这些链接直接删除就行了

⑥ c++ 中单向链表的头结点 删除

1 .要么用引用指针、要么用指向指针的指针， 因为这样才能改变 实参为指针的变量，如分配内存等操作
2.可以删除前端的头指针head ,但你要用另一个指针指向删除haed后的头指针，这样理解上不容易，所以上面这样做比较好，就是让head一直指向头
3，在堆内申请的内存如果不delete ，那么在程序运行完毕前，它就会一直占用这块内存，如果在堆内申请的变量多的话，会占用很多内存，所以对于 不用的堆变量，要极时删除

⑦ 编写不带头结点单链表的插入操作和删除操作算法

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

⑧ 求C语言大神帮忙，一道数据结构题，删除单链表中最大和次最大的数，感激不尽

#include<stdio.h>

#defineelemTypeint
#definestatusint
#defineOVERFLOW-1
#defineERROR0
#defineOK1

/*单链表数据结构*/
typedefstructlNode{
	elemTypedata;
	structlNode*next;
}lNode,*linkList;

/********************************以下为函数声明********************************/
voidinitList(linkList*L);							/*初始化*/
statuslistIsEmpty(linkListL);						/*判断单链表是否为空*/
statuslistInsertNode(linkListL,inti,elemTypee);	/*单链表指定位置插入新元素*/
statuslistDeleteNode(linkListL,inti,elemType*e);	/*删除单链表指定位置元素*/
statuslistOutput(linkListL);							/*输出链笑告表*/
/********************************以上为函数声明********************************/

/*初始化*/
/*操作结果：构造一个空的单链表L*/
voidinitList(linkList*L){
	*L=(linkList)malloc(sizeof(structlNode));/*产生头节点，并使L指向此头节点*/
	if(!*L)/*内存分配失败*/
		exit(OVERFLOW);
	(*L)->next=NULL;/*指针域为空*/
}

/*判断单链表是否为空*/
/*初始条件：单链表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE*/
statuslistIsEmpty(linkListL){
	returnL->next==NULL;
}

/*单链表指定位置插入新元素*/
/*操作结果：在带头结点的单链表L中第i个位置之前插入元素e*/
statuslistInsertNode(linkListL,inti,elemTypee){
	intj=0;
	linkListp=L,s;
	
	while(p&&j<i-1){/*寻找第i-1个结点*/
		p=p->next;
	j++;
	}
	
	if(!p||j>i-1)/*插入位置不合理：i小于1或者大于表长*/
		returnERROR;

	/*生成新结点，并插入L中*/
	s=(linkList)malloc(sizeof(structlNode));
	s->data=e;
	s->next=p->next;
	p->next=s;
	
	returnOK;
}

/*删除单链表指定位置元素*/
/*操作结稿笑果：在带头结点的单链线性表L中，删除第i个元素，并由e返回其值*/
statuslistDeleteNode(linkListL,inti,elemType*e){
	intj=0;
	linkListp=L,q;
	
	while(p->next&&j<i-1){/*寻找第i个结点，并令p指键升含向其前驱结点*/
	p=p->next;
		j++;
	}
	
	if(!p->next||j>i-1)/*删除位置不合理：i小于1或者大于表长*/
		returnERROR;
	
	/*删除并释放结点*/
	q=p->next;
	p->next=q->next;
	*e=q->data;
	free(q);
	
	returnOK;
}

/*输出链表*/
statuslistOutput(linkListL){
	linkListp=L->next;/*p指向第一个结点*/
	while(p!=NULL){
		printf("%d	",p->data);
		p=p->next;
	}
	putchar('
');
	returnOK;
}

/*寻找链表中最大数*/
/*操作结果：L为带头结点的单链表的头指针。最大值的位置赋值给maxIndex。*/
statusfindSpecificElem(linkListL,int*maxIndex){
	inti=1;
	elemTypemaxData;/*记录最大数*/
	
	linkListp=L->next;/*p指向第一个结点*/
	maxData=p->data;
	
	while(p){/*遍历链表寻找最大数*/
		if(p->data>maxData){
			maxData=p->data;
			*maxIndex=i;
		}
		p=p->next;/*p指向下一个结点*/
		i++;
	}
	
	returnOK;	
}

intmain(void){
	linkListL;
	intm1Index,m2Index;/*记录最大、次大数的位置*/
	elemTypem1Data,m2Data;/*记录最大、次大数*/
	
	/*构造一个链表，其中最大数为12，在第6位；次大数为9，在第3位。*/
	initList(&L);
	listInsertNode(L,1,7);
	listInsertNode(L,2,5);
	listInsertNode(L,3,9);
	listInsertNode(L,4,2);
	listInsertNode(L,5,4);
	listInsertNode(L,6,12);
	listInsertNode(L,7,6);
	
	/*输出链表*/
	puts("链表原始内容为：");
	listOutput(L);
	putchar('
');
	
	/*先找到当前链表最大数，删除该元素；再找一遍当前链表最大数，再删除该元素。*/
	/*如此实现删除链表中最大数、次大数*/
	findSpecificElem(L,&m1Index);
	listDeleteNode(L,m1Index,&m1Data);
	
	findSpecificElem(L,&m2Index);
	listDeleteNode(L,m2Index,&m2Data);
	
	printf("最大数：%d
次大数：%d
",m1Data,m2Data);
	putchar('
');
	
	puts("删除最大数、次大数后的链表内容为：");
	listOutput(L);
	
	getch();/*屏幕暂留*/
	return0;
}

运行结果

⑨ 用一个算法将单链中的值重复的节点删除

void del(Linklist list)
{
Linklist p,q,r;
p=list->宽绝link;
r=list;
while(p!=NULL){
q=list;
while(q!=q)
if(q->data==p->data){
r->link=p->link;
free(p);
p=r->好喊link;
q=list;
}
else
q=q->link;
r=p;
p=p->友巧野link;
}
}