插入算法

㈠ 跪求分别写一个线性表的插入的完整算法

//Try:
#include<iostream>
#include<stdlib.h>
usingnamespacestd;

#defineOK1
#defineERROR0
#defineTRUE1
#defineFALSE0
#defineINFEASIBLE-1
#defineOVERFLOW-2

typedefintStatus;//Status是函数的类型,其值是函数结果状态码
typedefintElemType;//ElemType为数据元素,暂定为int型

#defineLIST_INIT_SIZE100//线性表存储空间的初始分配量
#defineLIST_INCREMENT10//线性表存储空间的分配增量

typedefstruct//线性表顺序存储结构
{
	ElemType*elem;//存储空间基址
	intlength;//线性表当前长度
	intlistsize;//当前分配的存储容量(以sizeof(ElemType)为单位)
}SqList;

StatusInitList_SL(SqList&L)//初始化顺序线性表
{
//构造一个空的线性表L
	L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
	if(!L.elem)exit(OVERFLOW);//存储分配失败
	L.length=0;//空表长度为0
	L.listsize=LIST_INIT_SIZE;//初始存储容量
	returnOK;
}
Statusvisit(ElemTypee)//访问元素
{
cout<<e<<"";
returnOK;
}

StatusListEmpty_SL(SqListL)//判断线性表是否为空
{
if(L.length==0)returnTRUE;
	elsereturnFALSE;
}

StatusGetElem_SL(SqListL,inti,ElemType&e)//用e返回L中第i个数据元素的值(注意:下标由0开始的)
{
if(L.length==0/*||i<1*/||i>L.length)returnERROR;
e=*(L.elem+i);
returnOK;
}


StatusClearList_SL(SqList&L)//将线性表置为空表
{
	L.length=0;
	returnOK;
}

intLocateElem_SL(SqList&L,ElemTypee)//返回L中第1个与e满足关系的数据元素的位序
{
inti;
	if(L.length==0)return0;
	for(i=0;i<L.length;i++)
	{
		if(e==*(L.elem+i))//找到
			break;
	}
	if(i>=L.length)return0;//没有找到
	return(i+1);
}

StatusListDelete_SL(SqList&L,inti,ElemType&e)
{
//在顺序线性表L中删除第i个元素,并用e返回其值
//i的合法值为1<=i<=ListLength_SL(L)
ElemType*p,*q;
if((i<1)||(i>L.length))returnERROR;//i的值不合法
p=&(L.elem[i-1]);//p为被删除元素的位置
e=*p;//被删除元素的值赋给e
q=L.elem+L.length-1;//表尾元素的位置
for(++p/*++p是指被删除元素的下一个元素开始左移*/;p<=q;++p)//被删除元素之后的元素左移
	*(p-1)=*p;
--L.length;//表长减1
returnOK;
}

StatusListTraverse(SqListL)//遍历线性表元素
{
	inti;
	for(i=0;i<L.length;i++)
		visit(*(L.elem+i));
	cout<<endl;
	returnOK;
}
StatusListInsert_SL(SqList&L,inti,ElemTypee)
{
//在L中第i个位置之前插入新的元素e,
//i的合法值为1<=i<=ListLength_SL(L)+1
	ElemType*newbase,*q,*p;
	if(i<1||i>L.length+1)returnERROR;//i值不合法
	if(L.length>=L.listsize)
	{//当前存储空间已满,增加分配
		newbase=(ElemType*)realloc(L.elem,(L.listsize+LIST_INCREMENT)*sizeof(ElemType));
if(!newbase)exit(OVERFLOW);//存储分配失败
		L.elem=newbase;//新基址
		L.listsize+=LIST_INCREMENT;//增加存储容量
	}
q=&(L.elem[i-1]);//q为插入位置
for(p=&(L.elem[L.length-1]);p>=q;--p)
*(p+1)=*p;
*q=e;//插入e
++L.length;//表长增1
returnOK;
}

intListLength_SL(SqListL)//线性表长度
{
	return(L.length);
}


intmain(void)
{
/***************************
	
	Callthealgorithminhere.


	****************************/

	return1;
}

这个是最简单的线性表,它没有使用到类.都是过程化。

㈡ java数组的插入算法问题

arr[arr.length-1]=num; 43在这句的时候被num替换掉了
java的数组长度被初始化之后就是固定的 如果你想象里面加入一个新值
需要重新定义数组，也就是说如果oldarr.length = 5 你想象中见放第六个数是办不到的
只能重新定义数据 int[] newarr = new int[oldarr+1] 这么来弄

㈢ c语言插入法排序的算法步骤

算法描述
一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：
从第一个元素开始，该元素可以认为已经被排序
取出下一个元素，在已经排序的元素序列中从后向前扫描
如果该元素（已排序）大于新元素，将该元素移到下一位置
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
将新元素插入到该位置后
重复步骤2~5
如果比较操作的代价比交换操作大的话，可以采用二分查找法来减少比较操作的数目。该算法可以认为是插入排序的一个变种，称为二分查找排序。
范例程式码
void insertion_sort(int array[], int first, int last)
{
int i,j;
int temp;
for (i = first+1; i<=last;i++)
{
temp = array[i];
j=i-1;

while((j>=first) && (array[j] > temp))
{
array[j+1] = array[j];
j--;
}
array[j+1] = temp;
}
}

㈣ 顺序表中元素插入算法详细解释

//将顺序表第i-1个元素至最后一个元素全部向后移动一位
for(j=L->last;j>=i-1;j--)
L->data[j+1]=L->data[j]
//将新元素x插入到原第i-1个元素的位置
L->data[i-1]=x;
//更新顺序表长度
L->last++;

㈤ 单链表的元素插入算法

#include <stdlib.h>#include<stdio.h>typedef struct LNode{
int data;
LNode *next;
}*List,LNode;void Creat(List &L,int n){//创建链表
List p;//用于循环创建的节点
L=(List)malloc(sizeof(struct LNode));
L->next=NULL;
for(int i=1;i<=n;i++){
p=(List)malloc(sizeof(struct LNode));
scanf("%d",&p->data);
p->next =L->next;
L->next=p;
}
}//创建成功void Print(List L3){
L3=L3->next;
while(L3){
printf("%d",L3->data);
L3=L3->next;
}
}void Insert(List &L,int i,int e){//在第i个位置之前插入e
List p,s;
p=L;
int j=0; while(p&&j<=i-1){
if(j==i-1){
s=(List)malloc(sizeof(struct LNode));
s->data=e;
s->next=p->next;
p->next=s;
}
j++;
p=p->next;
}
}

int main(){ List L;
int n,i,e;
scanf("%d,%d,%d",&n,&i,&e);
Creat(L,n);
Insert(L,i,e);
Print(L); return 0;
}1

㈥ 算法与数据结构 插入

int inset(palist,p,x)
post-seq pslist;
int p,x;
{
int j;
if(i<0||i>p)
{
printf("i值错误！\n");
return 0;
}
else
{
for(j=p-1;j>=i-1;j--) pslist[j+1]=pslist[j];
pslist[i-1]=x;
p++;
return 1;
}

}

㈦ 如何使用aurora在word中插入算法

Word中使用Aurora插入算法伪代码 1. properties-->packages \usepackage{amsmath} \usepackage{amssymb} \usepackage{amsfonts} \usepackage{mathrsfs} \usepackage{algorithm} \usepackage{algorithmic} \usepackage{multirow} \alglan...

㈧ 二叉排序树的插入算法

首先执行查找算法，找出被插结点的父亲结点。
判断被插结点是其父亲结点的左、右儿子。将被插结点作为叶子结点插入。
若二叉树为空。则首先单独生成根结点。
注意：新插入的结点总是叶子结点。 //在二叉排序树中插入查找关键字keyvoidInsertBST(t，key){if(t==NULL){t=newBiTree;t->lchild=t->rchild=NULL;t->data=key;return;}if(key<t->data)InsertBST(t->lchild,key);elseInsertBST(t->rchild,key);}//n个数据在数组d中，tree为二叉排序树根voidCreateBiTree(tree,d[],n){tree=NULL;for(i=0;i<n;i++)InsertBST(tree,d[i]);}最小值二叉树c例程： #include<stdio.h>#include<malloc.h>structpriorityqueue{intcapacity;intsize;structpriorityqueue*elements;}*tryit;structpriorityqueue*initialize(intmaxelements){structpriorityqueue*h;h=malloc(sizeof(structpriorityqueue));h->elements=malloc(sizeof(int)*(maxelements+1));h->capacity=maxelements;h->size=0;h->elements[0]=-23767;returnh;}voidinsert(intx,structpriorityqueue*h){inti;for(i=++h->size;h->elements[i/2]>x;i/=2)h->elements[i]=h->elements[i/2];h->elements[i]=x;}intdeletemin(structpriorityqueue*h){inti,child;intminelement,lastelement;minelement=h->elements[1];lastelement=h->elements[h->size--];for(i=1;i*2<=h->size;i=child){child=i*2;if(child!=h->size&&h->elements[child+1]<h->elements[child])child++;if(lastelement>h->elements[child])h->elements[i]=h->elements[child];elsebreak;}h->elements[i]=lastelement;returnminelement;}main(){tryit=initialize(10);insert(4,tryit);insert(5,tryit);insert(10,tryit);insert(3,tryit);printf(%d ,deletemin(tryit));printf(%d deletemin(tryit));printf(%d ,deletemin(tryit));printf(%d ,deletemin(tryit));getchar();}

㈨ 如何使用c语言实现插入算法

void InsertSort(int arr[], int len, int key)
{
int i, j;
int temp;
for(i=0; i<len-1; i++)
{
temp = arr[i+1];
for(j=i; j>=0 && arr[j] > temp; j--)
arr[j+1] = arr[j];
arr[j+1] = temp;
}
}

㈩ 顺序表的插入算法的实现

#include<stdio.h>
#include<stdlib.h>
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
typedef int status ;
typedef int ElemType ;

typedef struct{
ElemType *elem;
int length,listsize;
}SqList;

status InitList(SqList &L)//初始化
{
L.elem=(int *)malloc(100*sizeof(int));
if(!L.elem) exit(-2);
L.listsize=100;
L.length=0;
return 1;
}

/*先建立新表*/
status Build(SqList &L)
{
int i,n;
printf("请输入元素个数n和n个元素\n");
scanf("%d",&n);
//if(n>LIST_INIT_SIZE)

for(i=0;i<n;i++)
scanf("%d",L.elem+i);
L.length=n;
return 1;
}
/*输出表中元素和长度*/
void Print(SqList &L)
{
int i;
for(i=0;i<L.length;i++)
printf("%d ",*(L.elem+i));
printf("\n长度为:%d\n\n",L.length);
}
/*删除值为X的元素*/
status ListDelete1(SqList &L,int x)
{
int i;
for(i=0;i<L.length;i++)
if(*(L.elem+i)==x)
break;
if(i==L.length)
return 0;
for(i++;i<L.length;i++)
*(L.elem+i-1)=*(L.elem+i);
L.length--;
return 1;
}

/*逆置函数*/
void Inverse(SqList &L)
{
int i,t;
for(i=0;i<L.length/2;i++)
{
t=*(L.elem+i);
*(L.elem+i)=*(L.elem+L.length-i-1);
*(L.elem+L.length-i-1)=t;
}
printf("表逆置成功!!!\n");
}

/*（升序）*/
void Sort(SqList &L)
{
int i,j,t;
for(i=1;i<L.length;i++)
for(j=0;j<L.length-i;j++)
{
if(*(L.elem+j)>*(L.elem+j+1))
{
t=*(L.elem+j);
*(L.elem+j)=*(L.elem+j+1);
*(L.elem+j+1)=t;
}
}
printf("已升序\n");

}

/*合并两个线性表*/
status Merger(SqList &L,SqList &Lb)
{
int i,j,k;
SqList Lc;
InitList(Lc);
if(Lc.listsize<L.length+Lb.length)
{
Lc.elem=(ElemType *)realloc(Lc.elem,(L.length+Lb.length+LISTINCREMENT)*sizeof(ElemType));
if(!L.elem) exit(-2);
Lc.listsize=L.length+Lb.length+LISTINCREMENT;
}
i=j=k=0;
while(i<L.length && j<Lb.length)
{
if(*(L.elem+i) < *(Lb.elem+j))
{
*(Lc.elem+k)=*(L.elem+i);
k++;i++;
}
else
{
*(Lc.elem+k)=*(Lb.elem+j);
k++;j++;
}
}
while(i<L.length)
{
*(Lc.elem+k)=*(L.elem+i);
k++;i++;
}
while(j<Lb.length)
{
*(Lc.elem+k)=*(Lb.elem+j);
k++;j++;
}
Lc.length=L.length+Lb.length;
L=Lc;
return 1;
}

/*将X插入，使仍然有序*/
status ListInsert(SqList &L,int x)
{
int i,k;
if(L.length>=L.listsize)
{
L.elem=(ElemType *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));
if(!L.elem) exit(-2);
L.listsize+=LISTINCREMENT;
}
for(i=0;i<L.length;i++)
if(x<*(L.elem+i))
break;
k=i;
for(i=L.length;i>k;i--)
*(L.elem+i)=*(L.elem+i-1);
*(L.elem+k)=x;
L.length++;
return 1;
}

/*提示函数*/
void Tips()
{
printf("请选择你的想要的操作：\n");
printf("<1> 输出顺序表及顺序表的长度\n");

printf("<2> 删除值为x的结点\n");

printf("<3> 将顺序表逆置\n");
printf("<4> 将顺序表按升序排序\n");
printf("<5> 将x插入到顺序表的适当位置上\n");
printf("<6> 将两个有序表合并\n");
printf("<0> 退出\n\n");
}

int main()
{

SqList L,Lb;
InitList(L);
Build(L);
int a,x,flag;
//SqList L,Lb;
Tips();
scanf("%d",&a);
while(a)
{
switch(a)
{

case 1:
{ Print(L);
break;}
case 2:
{ printf("请输入要删除的数据X:\n");
scanf("%d",&x);
flag=ListDelete1(L,x);
if(flag)
printf("删除成功!!\n\n");
else
printf("元素不存在,删除失败!!\n\n");
break;}

case 3:
Inverse(L);
break;
case 4:
Sort(L);
break;
case 5:
printf("请输入要插入的数据X:\n");
scanf("%d",&x);
flag=ListInsert(L,x);

if(flag)
printf("插入成功!!\n\n");
else
printf("插入失败!!\n\n");
break;

case 6:
printf("请输入Lb的内容:\n");
InitList(Lb);
Build(Lb);
flag=Merger(L,Lb);
if(flag)
printf("合并成功!!\n\n");
break;
//default;

Tips();
scanf("%d",&a);

}
}
return 0;
}