删除算法链表

A. 单链表删除操作

// 删除节点，释放内存空间
p->next = p->next->next;
delete p->next;
******************************************
若链表为：
链表节点 | 1 | 2 | 3 |...
对应指针 | p | p->next | p->next->next|...

你想删除节点2（p->next），
但你的做法是：
p->next = p->next->next;（1的下一个由指向2改为指向3）；
链表节点 | 1 | 2 | 3 |...
对应指针 | p | | p->next |...
delete p->next;（删除3）
这就错了，若要删除必须先将被删的节点2保存给临时变量，修改链表后再删除。正确的做法是：
linkList* tmp = NULL;
...
tmp = p->next;
p->next = p->next->next;
delete tmp;

另外，while (p && cnt != location - 1)这种写法虽然正确，但很不规范且危险，容易出现优先级和默认值的疏忽。

关于你补充的问题，不分析你的代码了，直接给你重写一个吧，看懂了就可以自己改了。
void Sort(linkList* L)
{
bool done_flag = FALSE;
linkList* p = L;
linkList* temp = NULL;

if (p->next == NULL)
{
return;
}

/*你的链表结构存在独立首节点，所以p可以直接做两个交换节点的父节点*/

/*若未发现乱序，说明已经排好*/
while(!done_flag)
{
done_flag = TRUE;

/*遍历链表 保证p下至少存在两个节点*/
while(p->next->next != NULL)
{
/*若顺序错误则对换*/
if (p->next->name[0] > p->next->next->name[0])
{
/*存在乱序*/
done_flag = FALSE;

/*链表：p p1 p2 p3*/
/*交换p1 p2*/

/*temp 指向 p1*/
temp = p->next;

/*p 的下一个改为 p2*/
p->next = p->next->next;

/*将 p3挂到p1后面，此时p的下一个是p2，所以p的下一个的下一个是p3，temp此时为p1*/
temp->next = p->next->next;

/*p 的下一个此时为 p2，将p2的下一个指向 temp(p1)*/
p->next->next = temp;
}

/*p后移*/
p = p->next;
}
}
}

bool你那里有问题的话，可以改为int或char。

结题吧。

B. C++数据结构链表删除算法中，del=first;first=first->link;delete del;是什么意思（尤其是第二句）

first是头指针，第一句让del指向首节点；,第二句是让first指向第二个节点，把第一个节点的指针域赋给first，而这个指针域指向第二个节点，故就是让first指向第二个节点；第三句，进行删除操作；这三句这应该在一个循环内，至此，此题已解，呵呵

C. 顺序表、单链表的删除算法

第三个位置的数的下标是2。如果顺序表最开始是12345，length等于5，那删除第三个位置的数后顺序表就变成了12455，而length变成了4，有效数据当然是1245。

D. 试编写一个在循环双向链表中进行删除操作的算法，要求删除的结点是指定结点p的前趋结点（自己创建链表）

要删除p节点的前驱，先定义一个节点q为p的前驱节点。有如下关系：
q->pre->next=p;
p->pre=q->pre;
然后删除q节点就可以了。

# include <iostream.h>
# include <assert.h>

template <class Type>
struct DbNode
{
Type data;
DbNode<Type> *next,*pre;

DbNode(DbNode<Type> *ptr1 = NULL,DbNode<Type> *ptr2 = NULL):next(ptr1),pre(ptr2)
{}
DbNode(Type x,DbNode<Type> *ptr1 = NULL,DbNode<Type> *ptr2 = NULL):data(x),next(ptr1),pre(ptr2)
{}
};

template <class Type>
class DbList
{
public:
DbList()
{
head = new DbNode<Type>;
head->pre = head->next = head;
}

DbList(const DbList<Type> &dl)
{ }

~DbList()
{
Destory();
}
public:
void DeleteNode(DBNode<Type> *p)
{
DBNode<Type> *q=p->pre;

q->pre->next=p;
p->pre=q->pre;
delete q;
}

private:
DbNode<Type> *head;

void Destory()
{
DbNode<Type> *p = head->next;
while(p != head)
{
head->next = p->next;
p->next->pre = head;
delete p;
p = head->next;
}
}
};

E. 线性链表删除元素算法

#include<stdio.h>
#include<malloc.h>
typedef struct node
{
int num; /*指数*/
struct node *next; /*指向下一个结点的指针*/
} *listnode;
void InitList(listnode L) /*初始化单链表*/
{
L=(PolyNode *)malloc(sizeof(PolyNode)); /*建立头结点*/
L->next=NULL;
}
太扣了 一分也不给 但是我就是那种乐于助人的人 告诉不初始化 链表 接下来的 你要是给分我就给你写

F. 单链表的删除算法，为什么这道题选A而不选c呢求告知多谢！！！

C选项最后那句是free(q)，但是我们要删除的是结点A，而不是A的下一个结点
A选项，把p的数据换成了下一个结点的数据，达到删除的目的，而同时下一个结点q就没有用了，那最后要free(q)

G. 求助C语言 单链表的插入、删除算法 的一些问题

第一个问题和第三个问题都是引用的意思，就是在函数中改变该变量的值会影响调用的地方的值，同时这样如果是大的对象，不是复制一个值而是原来的变量，只是一个别名。
第二个问题&&是与的意思，也就是说当p指针不为空并且j < i-1时候执行循环
最后一个三句话意思是删除一个元素，在此处删除的是指针q指向的元素，用q指向要删除的元素，然后第二句话是让当前指针的下一个元素指向q的下一个元素，也就是删除了q，然后把要删除的元素的值也就是data赋给e变量
不知道解释清楚了没有，要是不行再联系我。

H. 用循环单链表实现循环队列,如何写出插入和删除的算法

typedef struct CircleListNode{

Datatype d;

struct CircleList *pre,*nxt;

}*CircleList,CirListNode;

typedef struct

{

CircleList Head;

int num;

}CircleQueue;

void insertFront(CircleList *L,d);

{

if(!L)return NULL;

if(*L==NULL)

{

*L=(CircleList) malloc(sizeof(CirListNode));

*L->nxt= *L->pre=*L ;

*L->d=d;

}

else

{

CircleList p =(CircleList) malloc(sizeof(CirListNode));

p->nxt=*L;

p->pre=*L->pre;

*L->pre->nxt=p;

*L->pre=p;

*L=p;

}

}

I. 链表插入(删除)一个节点的算法

publi void deleteInO1(Node head,Node t){
if (head == null || t == null)
return;
if (t.next != NULL) {
Node tmp = t.next;
t.next = tmp.next;
t.val = tmp.val;
}
else { //待删除节点为尾节点
Node tmp = head;
while(tmp.next != t)
tmp = tmp.next;
tmp.next = NULL;
}
}

J. 设计一个在带头结点的单链表中删除第i个结点的算法

//删除节点 删除第i个节点
int Delete_Positon_LL(LinkList *phead,int i)
{
LinkList p,q;//p为值是x的节点,q是p的前一个节点
int j;

if((*phead)->next == NULL)//如果链表为空，做下溢处理
{
printf("单链表为空! ");

return 0;
}
if(i == 1) //如果是表头,表头后移
{

p=(*phead)->next;
(*phead)->next=(*phead)->next->next;
free(p);//释放表头

(10)删除算法链表扩展阅读：

链接方式存储的线性表简称为链表（Linked List）。链表的具体存储表示为：

① 用一组任意的存储单元来存放线性表的结点（这组存储单元既可以是连续的，也可以是不连续的）

② 链表中结点的逻辑次序和物理次序不一定相同。为了能正确表示结点间的逻辑关系，在存储每个结点值的同时，还必须存储指示其后继结点的地址（或位置）信息（称为指针（pointer）或链(link)）

链式存储是最常用的存储方式之一，它不仅可用来表示线性表，而且可用来表示各种非线性的数据结构。