線性表的刪除演算法

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)<<" ";
}