试写一算法，在带头结点的单链表L的第k个结点后插入一个结点x。 设计一个在带头结点的单链表中删除第i个结点的算法

bool insert(List L,int k,Listnode x)
{
int i;
List p;
for(i=0,p=L;i<k && p->next;i++,p=p->next);
if(p->next)
{
x->next=p->next;
p->next=x;
return true;
}
else
return false;
}

//linked list with headnode

#include <iostream>
#include <malloc.h>

using namespace std;

typedef int DataType;

typedef struct node
{
DataType data;
struct node *next;
}seqlist;
typedef seqlist node;

void input(seqlist *);
void output(seqlist *);
void insert(seqlist *, node *, DataType);
void deleteNode(seqlist *, DataType);
seqlist *
find(seqlist *, DataType);

int main()
{
seqlist *list1;
seqlist *f;
DataType index, d;
list1 = (seqlist *)malloc(sizeof(seqlist));
list1->next = NULL;
list1->data = 0;
input(list1);
output(list1);
cout << "Please input the Element to insert:\n";
cin >> d;
cout << "Please input before which data exists to insert:\n";
cin >> index;
f = find(list1, index);
insert(list1, f, d);
output(list1);
cout << "Please input the element to delete:\n";
cin >> d;
deleteNode(list1, d);
output(list1);
return 0;
}

void input(seqlist *list)
{
DataType i;
seqlist *p;
cin >> i;
while (i != 0)
{
p = (seqlist *)malloc(sizeof(seqlist));
p->data = i;
p->next = NULL;
list->next = p;
list = p;
cin >> i;
}
}
void output(seqlist *list)
{
list = list->next;
while (list)
{
cout << list->data << '\t';
list = list->next;
}
cout << endl;
}
void insert(seqlist *list, node *p, DataType data) // insert data before p, if p doesn't exist data will be added to the end
{
seqlist *newNode;
newNode = (seqlist *)malloc(sizeof(seqlist));
newNode->data = data;
newNode->next = NULL;
while (list->next != p)
list = list->next;
newNode->next = list->next;
list->next = newNode;
}
void deleteNode(seqlist *list, DataType data)
{
seqlist *p;
if (list->next == NULL)
{
cout << "Empty Linked List" << endl;
return;
}
p = list->next;
while (p && p->data != data)
{
list = p;
p = p->next;
}
if (p)
{
list->next = p->next;
free(p);
}
else
cout << "Item Not Found!\n";
}
seqlist *
find(seqlist *list, DataType data)
{
list = list->next;
while (list)
{
if (list->data == data)
return list;
list = list->next;
}
cout << "Item Not Found!\n";
return NULL;
}

typedef struct S{
struct S *next;
}Ss,*Node;
void Input(Node L,ing k,Ss x)
{
Node p=L->next;
for(int i=1;i<k;i++)
p=p->next;
}
Node q=(Node)malloc(sizeof(Ss));//这是插入的节点，下面对其赋值，这个语句我省略了，因为在定义结构体的时候我只定义了指针
//赋值q=x;
q->next=p->next;
p->next=q;
}

Linklist* p;
p=L;
while(k>1)
{
p=p->next;
k--;
}
Linklist *q=NULL;
q=p;
p->next=x;
x->next=q->next;

试写一算法在带头结点的单链表结构上实现线性表操作Locate(L,x)按值查找;~

Node *Locate(Node L,int x)
{
Node *p;
p = L.next;
while(p != NULL)
{
if (p->data == x)
{
return p; //找到返回结点的地址
}
p = p->next;
}
return NULL; //未找到
}

//删除节点 删除第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);//释放表头


扩展资料：
链接方式存储的线性表简称为链表（Linked List）。链表的具体存储表示为：
① 用一组任意的存储单元来存放线性表的结点（这组存储单元既可以是连续的，也可以是不连续的）
② 链表中结点的逻辑次序和物理次序不一定相同。为了能正确表示结点间的逻辑关系，在存储每个结点值的同时，还必须存储指示其后继结点的地址（或位置）信息（称为指针（pointer）或链(link)）
链式存储是最常用的存储方式之一，它不仅可用来表示线性表，而且可用来表示各种非线性的数据结构。
参考资料来源：百度百科-单链表

设计一个算法,在带头结点的单链表head中删除一个data域值最小的结点...
答：int ListInsert(LinkList L,int i,int e);void DestroyList(LinkList L);void ListTraverse(LinkList L);int main(void){ LinkList L;int i,j,m;int a[]={6,5,4,3,2,1};InitList(&L);for(i=0; i<6; ++i)m = ListInsert(L,i+1,a[i]);printf("链表的内容为：");List...

有一个带头结点的单链表L,设计一个算法使其元素递增有序排列
答：/* 插入排序法 */void sort(Linklist *&L){ LinkList *p=L->next, *q, *r; if(p!=NULL) { /* 把链表分成两条，一条已经排序好了(L)，一条待排序(p)*/ r=p->next; p->next=NULL; p=r; /* 对于所有待排序的元素 */ while(p!=NULL) { ...

写一算法在带头结点的单链表结构上实现线性表操作LOCATE(L,X)
答：ChainNode<T> *first; // 指向第一个节点的指针 } ;// bool Chain<T>::Locate(int k, T& x) const {// 寻找链表中的第k个元素，并将其传送至x / /如果不存在第k个元素，则返回f a l s e，否则返回t r u e if (k < 1) return false;ChainNode<T> *current = first;int ...

编写一个算法,以完成在带头结点单链表l中第i个位置前插入x的操作_百度...
答：int insert(Linklist L,int i,int x){ int k=1;Linklist p=L,s;whlie(knext;k++:} s=(Linklist)malloc(sizeof(LNode));s->data=x;s->next=p->next;p->next=s;return 0;}

一个带头结点的单链表,L为链表的头指针,设计算法删除链表中的偶数结点...
答：/ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 删除偶数结点后 :1 3 5 7 9 11 13 15 Press any key to continue / include<stdio.h> include<malloc.h> typedef struct LNode { int data;struct LNode *next;}*LinkList;LinkList Creat_List(int n) { LinkList head,p,q;h...

有一个线性表存储在一个带头结点的循环单链表L中,写出计算线性表元素...
答：include"stdio.h"include"stdlib.h"typedef int elementype;typedef struct link{ int data;struct link *next;}link,*linklist;int main(){ linklist l,p,q,s;int a,j=0;l=(linklist )malloc(sizeof(linklist));l->next=l;p=l;while(1){ printf("请输入链表数据:");scanf("%d",&...

试写一算法在带头结点的单链表结构上实现线性表操作Length(L)。下面各...
答：int Length(List L){ List p=L->Next; int r=0; while(p) { r++; p=p->next; } return r;}

写出在带头结点的动态单链表结构上求线性表的长度的算法: int LengthL...
答：int LengthList( Node *L ){ Node *p = L->next; //将p初始指向链表中第一个节点的地址 int length = 0;while(p) //当p指向的地址不为空时，继续循环计算长度 { ++length;p = p->next; //链表长度加1后，将p指向其后继节点地址 } return length;} ...

已知带头结点的单链表L,编写算法删除L中国从k开始的n个元素,并将得到的...
答：bool Del_k_n(LinkList &linkList,int k,int n){ LNode *pre=linkList->next,*r,*p=linkList;while (pre!=NULL&&(--k)!=0){//查找开始结点 p=pre;pre=pre->next;} if (pre==NULL) return false;//开始结点为空，删除失败 r=pre;while (r!=NULL&&(--n)!=0){//查找结束...

设计一个在带头结点的单链表中删除第i个结点的算法
答：//删除节点 删除第i个节点int Delete_Positon_LL(LinkList *phead,int i){LinkList p,q;//p为值是x的节点,q是p的前一个节点int j;if((*phead)->next == NULL)//如果链表为空，做下溢处理{printf("单链表为空!\n");return 0;}if(i == 1) //如果是表头,表头后移{ p=(*phead)...