数据结构必会算法

2.2顺序表插入
//顺序表存储结构
#define MAXSIZE 100
typedef struct{
	Type elem[MAXSIZE];
	int last ;
}List;
#define OK 1
#define ERROR 0
 //在顺序表L中第i个数据元素之前插入一个元素e。
//i的合法取值范围1<=i<=last+2
int InsList(List *L,int i,Type e)
{
    int k;
    //判断插入位置是否合法 
    //边界点 1 (1之前为位置0) last+1 (last+1 之前为位置last)
    if(i<1||i>last+2){
    	printf("插入位置i不合法")；
		return ERROR; 
    }
    //判断是否能够插入 
    //最后一个元素已经是 MAXSIAZE-1
    if(L->last>=MAXSIAZE-1){
    	printf("表已满，无法插入")；
		return ERROR; 
    }
    //为插入元素移动位置 i-1把i-1的元素移走 
    for(k=L->last;k>=i-1;k--){
    	L->elem[k+1]=L->elem[k];
    }
    L->elem[i-1]=e;//第i个数据元素之前插入一个元素e 
    L->last++;//修改尾指针 
   return OK:
}
2.3顺序表删除
#define OK 1
#define ERROR 0
 //在顺序表L中删除第i个数据元素,并用指针参数e返回其值。
//i的合法取值范围1<=i<=last+1 
int InsList(List *L,int i,Type e)
{
    int k;
    //判断删除位置是否合法 
    //边界点 1 (1之前为位置0) last+1 (last+1 之前为位置last)
    if(i<1||i>last+1){
    	printf("删除位置i不合法")；
		return ERROR; 
    }
    *e =L->elem[i-1];//将删除元素放入指针e带出 
    //为插入元素移动位置 i-1把i-1的元素移走 
    for(k=i;i<=L->last;k--){
    	L->elem[k-1]=L->elem[k];
    }//last最后一个元素的下标 
    L->last--;//修改尾指针 
   return OK:
}
//单链表的存储结构
//Node结点类型定义 
typedef struct Node{
	Type data;
	struct Node* next; 
}Node,*List; //*List结构指针类型 
//初始化单链表
InitList(List *L)
{
	*L=(List)malloc(sizeof(Node));//建立头节点List头指针类型 
	(*L)->next=NULL;
	 
}
//2.6头插法建立单链表 
void CreatFromHead(List L){
	char c;
	Node *s;
	int flag=1;
	while(flag){
		c=getchar();//获得字符串
		if(c!=$){
		s=(Node*)malloc (sizeof(Node));//申请新结点
		s->data=c;
		s->next=L->next;
		L->next=s; 
		}
		else flag=0;
	}
}
//2.7尾插法建立单链表 
void CreatFromTail(List L){
	Node *s,*r;r=L;//初始化 
	char c;
	int flag=1;
	while(flag){
		c=getchar();
		if(c!=$){
			s=(Node*)malloc(siazeof(Node));
			s->data=c;
			r->next=s;//尾插 
			r=s;//修改尾指针 
		}
		else {
			flag=0;
			r->next=NULL;
		} 
	}
}
//2.11单链表的插入
int Insert(List L,int i,Type e){
	Node *pre,*s;
	pre=L;
	int k=0;
	if(i<0){
			printf("输入位置不合法")；
		return EROOR; 
	}
	while(pre!=NULL&&k<i-1){
		pre=pre->next;
		k=k+1;
	}
	if(Pre==NULL){
		printf("输入位置不合法")；
		return EROOR; 
	}
	s->data=e;
	s->next=pre->next;
	pre->next=s;
	return OK:
}
//2.12单链表删除
int DelList(List L,int i,Type *e){
	Node *pre,*s;//s指向待删元素的指针
	pre=L;
	int k=0; 
	while(Pre->next!=NULL&&k<i-1){
		pre=pre->next;
		k=k+1;
	}
	if(Pre->next==NULL||i<1){
		printf("删除位置不合法")；
		return ERROR; 
	}
	s=pre->next;
	pre->next=s->next;
	*e=s->data;
	free(s);
	return OK:
}
//顺序栈存储结构
#define Stack_Size 50
typedef struct{
	type elem[Stack_Size];
	int top;//栈顶元素的下标 
}Stack; 
//顺序栈初始化
void InitStack(Stack *S){
	S->top=-1;
} 
//顺序进栈
int Push(Stack *S,Type x)
{
	//判满 
	if(S->top==Stack_Size-1) return(FLASE);
	S->tp++;
	S->elem[S->top]=x;
	return (TRUE);
} 
//顺序栈出栈
int pop(Stack *S,Type *x){
	//栈顶元素弹出， x带出
	//判空 
	if(S->top==-1) return(FLASE);
	*x=S->elem[S->top];
	S->top--;
	return (TURE); 
}
//链栈存储结构
typedef struct node{
	Type data;
	struct node *next;
}Node,*List; 
//链栈进栈 
void InitList(List L){
	top=L;
	top->next==NULL;
}
int push(List *L,Type x){
	//申请新的空间
	List *t;
	t=(List *)malloc(sizeof(Node));
	if(t==NULL)return(FLASE);//申请空间失败
	t->data=x;
	t->next=top->next;
	top->next=t;
	return(TURE); 
}
//链栈出栈 
int pop(List L,Type *x){
	List t;
	t=top->next;
	//判空 
	if(t==NULL)return(FLASE);
	 top->next=t;//要删除的点 
	 *x=t->data;//指针x带出
	 free(t);//释放指针
	 return (TRUE); 
}
查找
//折半查找法  二分查找
//顺序结构数据定义
#define SIZE 20
typedef struct{
	Type key;
	Type Other_data;
}RecordType; 
typedef struct{
	RecordType r[SIZE];
	int length;
}List;
int binsrch(List l,Type k){
	//在有序表l中查找关键字为k的元素，若找到则返回k所在的位置
	 low=1;
	 high=l.length;
	 while(low<=high){
	 	mid=(low+high)/2;
	 	if(k==l.r[mid].key)  return mid;
	 	else if(k<l.r[mid].key) high=mid-1;//前半区查找 
	 	else  low=mid+1;//后半区查找 
	 }
	 retur(0);	 
}
排序
//向量结构定义
typedef int KeyType;
typedef struct{
	KeyType key;
	Other_Type data;
}RecordType;
//直接插入排序
void IntSort(RecordType r[],int length)
{
	for(i=2;i<=length;i++){
		r[0]=r[i];//将待插入位置记录存放在r[0] 
		j=i-1;//j为i的前一个位置
		while(r[0].key<r[j].key){
			//j为插入位置 
			r[j+1]=r[j];//先把j位置的数移到下一个位置  腾位置 
			r[j]=r[0]; //再把要插入的数插入到位置j 		
		} 	
	}
}
//折半插入排序
void Sort(RecordType r[],int length){
	for(i=2;i<=length;++i){
		x=r[i];
		low=1;
		high=i-1;
		//确定插入位置 
		while(low<=high){
			mid=(low+high)/2;
			if(x.key<r[mid].key)high=mid-1;
			else low=mid+1
		}
		for(j=i-1;j>=low;--j)
			r[j+1]=r[j];//移位 
			r[low]=x;//插入记录 
		
	}
}
//冒泡排序 
void IntSort(RecordType r[],int length)
{
	int t;
	for(int i=0;i<n;i++){
		for(int j=0;j<n-i;j++){
			if(r[j].key>r[j+1].key){
				t=r[j];
				r[j]=r[j+1];
				r[j+1]=t;
			}
		}//每趟排序都把最大的数放在最后n-i 
	} 
}
//选择排序 
void selectSort(RecordType r[],int n){
	k=i;
	for(int j=i+1;j<n;j++){
		if(r[k].key<r[j].key)k=j;//k纪录最小数的下标 
		//k!=i 说明i不是最小数就与j交换 
		if(k!=i){
			t=r[i];
			r[i]=r[j];
			r[j]=t;
		}
	}
}