线性表的删除算法

A. 关于线性表删除元素的算法

从数组的方面解释的话，比如
int
a[50];
那么a的长度就为50。
数组的第一个元素为a[0]，第一个元素的位置为a,也即a+0，或者&a[0];
第二个元素就是a[1],其位置为a+1,或&a[1];
一次类推，尾元素，即第50个元素为a[49],其位置为a+49,也即&a[49]。
线性表里也是一样的道理（其实普通的数组应该也是一种线性表吧?呵呵）。

B. 线性表执行删除算法时需要移动几个数据元素要移动几次若删除每个元素均等，则平均移动元素的个数是多

线性表：1、2、3、4、5、6、7，
删除元素3后： 1、2、4、5、6、7。

线性表删除时，要删除元素的后面的元素依次前移，移动个数为后面元素的个数；
每个元素向前移一位，移动一次；

设线性表有n个元素，每个元素删除的概率相等，删除第一个元素需要移动n-1个，删除第n个元素需要移动0个，所以平均移动元素个数是((n-1)+(n-2)+..+1+0)/n=(n-1)/2。

C. 《线性表的插入和删除算法实现》以及《栈和队列的插入和删除算法实现》的c语言代码

链表

#include"stdio.h"
#include"malloc.h"
typedef struct node
{
int data;
struct node *next;
}node,*linklist;
int initlist(linklist l)
{
linklist q,p;
int i,n;
q=l;
printf("请输入链表长度:");
scanf("%d",&n);
for(i=0;i<n;i++)
{
p=(linklist )malloc(sizeof(node));
printf("请输入链表数字:");
scanf("%d",&p->data);
q->next=p;
q=p;
}
q->next=NULL;
return 1;
}
int printflink(linklist l)
{
linklist p;

p=l->next;
while(p!=NULL)
{
printf("%d\n",p->data);
p=p->next;
}
return 1;
}
int insertlink(linklist l)
{
linklist p,s;
int j=0,i,n;
p=l;
printf("请输入你要插入的位置:");
scanf("%d",&i);
printf("请输入插入的数字:");
scanf("%d",&n);
while(p->next!=NULL&j<i-1)
{
p=p->next;
j++;
}
if(!(p->next)||j>i-1)
{
printf("error\n");
return 1;
}
s=(linklist)malloc(sizeof(node));
s->data=n;
s->next=p->next;
p->next=s;
return 1;
}
int deletelink(linklist l)
{
linklist p,q;
int j=0,e,i;
p=l;
printf("请输入你要删除的位置:");
scanf("%d",&i);
while(p->next!=NULL&&j<i-1)
{
p=p->next;
j++;
}
if(!(p->next)||j>i-1)
{
printf("error\n");
return 1;
}
q=p->next;
p->next=q->next;
free(q);
return 1;
}
int main()
{
linklist l;

l=(linklist)malloc(sizeof(node));
l->next=NULL;
initlist(l);
printflink(l);
insertlink(l);
printflink(l);
deletelink(l);
printflink(l);
return 1;
}
栈

#include"iostream.h"
#include"stdio.h"
#include"malloc.h"

typedef int elementype;
#define MAXSTACK 100
typedef struct stack
{
elementype *base;
elementype *top;
int stacksize;
}stack;
//建栈
int initstack(stack *p)
{
p->base=(elementype *)malloc(MAXSTACK*sizeof(elementype));
if(!p->base)
{
cout<<"建立栈失败!"<<endl;
return 1;
}
p->top=p->base;
return 1;

}
//元素进栈
int pushstack(stack *p)
{

elementype e;
if(p->top-p->base>=p->stacksize)
{
cout<<"栈已满!"<<endl;
return 1;
}
cout<<"请输入进栈元素:";
cin>>e;

*p->top=e;
p->top++;
return 1;

}

//删除栈顶元素
int deletetop(stack *p)
{
if(p->top==p->base)
{
cout<<"栈为空"<<endl;
return 1;
}
p->top--;
return 1;
}

//显示栈中元素
int displaystack(stack *p)
{
int i=0;
elementype *s;
if(p->top==p->base)
{
cout<<"栈为空!"<<endl;
return 1;
}
s=p->base;
for(i=0;i<p->top-p->base;i++)
{

cout<<*s<<" ";
s++;
}
cout<<endl;
return 1;
}
int main()
{
stack *p;
int a;
initstack(p);
displaystack(p);
pushstack(p);
displaystack(p);
deletetop(p);
displaystack(p);

}
队列
#include"stdio.h"
#include"malloc.h"
typedef struct lnode
{
int data;
struct lnode *next;
}lnode;
typedef struct linkque
{
lnode *front;
lnode *rear;
}linkque;
int queinit(linkque *q)
{
int e;
lnode *p;

q->front=(lnode *)malloc(sizeof(lnode));
q->rear=q->front;
q->front->next=NULL;
while(1)
{
printf("请输入队列数字(输入0结束):");
scanf("%d",&e);
if(e==0) break;
p=(lnode *)malloc(sizeof(lnode));
p->data=e;
p->next=NULL;
q->rear->next=p;
q->rear=p;
}
return 1;
}
int quein(linkque *q)
{
lnode *p;
int e;
printf("请输入你要插入队列的数字:");
scanf("%d",&e);
p=(lnode *)malloc(sizeof(lnode));
p->data=e;
p->next=NULL;
q->rear->next=p;
q->rear=p;
return 1;
}
int quedel(linkque *q)
{
lnode *p;
int e;
p=q->front->next;
e=p->data;
q->front->next=p->next;
free(p);
return e;
}
int printfque(linkque *q)
{
lnode *p;
p=q->front->next;
while(p)
{
printf("%d\t",p->data);
p=p->next;
}
printf("\n");
}
int main()
{
linkque q;
queinit(&q);
printfque(&q);
quein(&q);
printfque(&q);
quedel(&q);
printf("队列出列后为:\n");
printfque(&q);
return 1;
}

D. 关于线性表删除数据元素的算法

从数组的方面解释的话，比如
int a[50];
那么a的长度就为50。
数组的第一个元素为a[0]，第一个元素的位置为a,也即a+0，或者&a[0];
第二个元素就是a[1],其位置为a+1,或&a[1];
一次类推，尾元素，即第50个元素为a[49],其位置为a+49,也即&a[49]。
线性表里也是一样的道理（其实普通的数组应该也是一种线性表吧?呵呵）。

E. 设计算法删除线性表中的多余元素

Node*p=head;
while(p->next!=NULL){
inta=p->data;
intb=p->next.data;
if(a==b){
p->next=p->next->next;
}

p=p->next;

是不是就行了。。

F. 请描述线性表删除操作数据结构的算法实现

直接指向删除元素的下个元素；
比如一个链表中删除一个元素
找到该元素，同时保存元素的前一个节点p
则p->next=p->next->next;

G. 线性表中删除某些元素算法

Status ListDelete_Sq(SqList &L,int i,ElemType &e)
{
if((i<1)||i>L.length)) return ERROR;
p=&(L.elem[i-1]);
e=*p;
q=L.elem+L.length-1;//表尾元素的位置
for(++p;p<=q;++p) *(p-1)=*p;
--L.length;
return OK;
}//ListDelete_Sq

H. 程序定义一个完整的线性表，实现 插入和删除的算法

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 100
typedef struct{
int data[MAXSIZE];
int length;
}SeqList;
//初始化
SeqList InitList(){
SeqList L;
L.length=0;
return L;
}
//插入元素
SeqList Insert(SeqList &L,int x){
if(L.length==MAXSIZE){
printf("表满");
exit(0);
}
L.length++;
L.data[L.length]=x;
return L;
}
//删除第i个元素
SeqList Delete(SeqList &L,int i){
if(i<1||i>L.length){
printf("不存在第%d个元素",i);
exit(0);
}
int j;
for(j=i;j<=L.length-1;j++){
L.data[j]=L.data[j+1];
}
L.length--;
return L;
}
//定位某个元素
int locate(SeqList L,int x){
int i;
i=1;
while(i<=L.length&&L.data[i]!=x){
i++;
}
if(i<=L.length)
return i;
else
return 0;
}

SeqList Bingji(SeqList La,SeqList Lb,SeqList Lc){
int i,j;
for(i=1;i<=La.length;i++){
for(j=1;j<=La.length;j++){
if(La.data[i]==Lb.data[j]){
Lc=Insert(Lc,La.data[i]);
}
}
}
return Lc;
}
//打印数组
void Display(SeqList L){
int i;
for(i=1;i<=L.length;i++){
printf(" %d ",L.data[i]);
}
printf("\n");
}
这个是基于数组的线性表，有插入和删除的操作，如有不懂可追问。

I. 顺序表的删除算法

#include<iostream.h>
#include<stdlib.h>
typedef int DataType; //定义具体问题元素的数据类型
#include"SeqList.h"
void main(void)
{
SeqList myList(128); //定义顺序表对象myList
int n=26; //在myList中顺序插入26个元素
int i;
for(i=0;i<n;i++)
myList.Insert(i+1,i);
myList.Dalete(4); //删除myList中数据元素4
myList.Dalete(9); //删除数据元素9
for(i=0;i<myList.Size();i++) //一次取myList中的元素并显示
cout<<myList.GetData(i)<<" ";
}