数据结构

SanEr
143 阅读4分钟

排序

//直接插入排序
void insertSort(List R,int n)
{
	int i,j;
	for(i=2;i<=n;i++)
	{
		R[0]=R[i];  //岗哨获取第二个值
		j=i-1;  //j等于前一个值
		if(R[0].key<R[j].key)  //岗哨与其前面的值比较
		{
			R[j+1] = R[j]; //将岗哨插入合适位置 
			j--;  //
		}
		R[j+1]=R[0];  //循环到最后将岗哨放在合适位置
	}
}

//冒泡排序
void bubbleSort(List R, int n)
{
	int i,j,temp,endsort;
	for(i=1;i<=n-1;i++)
	{
		endsort=0;
		for(j=1;j<=n-i;j++)
		{
			if(R[j].key>R[j+1].key)
			{
				temp = R[j];
				R[j] = R[j+1];
				R[j+1] = temp;
				endsort = 1;
			}
		}
		if(endsort==0) break;
	}
}
//快速排序
void quickSort(List R,int low,int high)
{
	int i,j,x;
	i=low;
	j=high;
	x=R[i];
	while(i<j&&x.key<=R[j].key) --j;
	if(i<j)
	{
		R[i] = R[j];
		++i;
	}
	while(i<j&&x.key>=R[i].key) ++i;
	if(i<j)
	{
		R[j] = R[i];
		--j;
	}
	R[i]=x;
	if(low<i-1)
	{
		quickSort(R,low,i-1);
	}
	if(high>j+1)
	{
		quickSort(R,j+1,high);
	}
}
//直接选择排序
void selectSort(List R,int n)
{
	int i,j,min;
	for(i=1;i<=n-1;i++){
		min = i;
		for(j=1;j<=n;j++)
		{
			if(R[j].key<R[min].key)
			{
				min=j;
			}
			if(min!=i)
			{
				temp = R[i];
				R[i] = R[min];
				R[min] = temp;
			}
		}
	}
}
//二路归并
void mergeSort(List R,List a,int m,int h,int n);
{
	int j = m+1;
	int k = h;
	while(h<=m&&j<=n)
	{
		if(a[h].key<=a[j].key)
		{
			R[k]=a[h];
			h++;
		}
		else{
			R[k]=a[j];
			j++;
		}
		k++;
	}
	while(h<=m)
	{
		R[k]=R[h];
		h++;
		k++;
	}
	while(j<=n)
	{
		R[k]=R[j];
		j++;
		k++;
	}
}
//二分查找
int searchBin(sqtable T,int n,int key)
{
	int low = 1;
	int high = T.n;
	while(low<=high)
	{
		mid = (high+low)/2
		if(T.elem[mid].key == key){
			return mid;
		}else if(T.elem[mid].key<key){
			high=mid-1;
		}else{
			low=mid+1;
		}
	}
	return 0;
}
//散列查找
int searchHash(keyType key,openHash HL)
{
	d=H(key);
	i=d;
	while(HL[i].key != NULLkey && HL[i].key!=key)
	{
		i=(i+1)%m;
	}
	if(HL[i].key == key) return i;
	else return 0;
}

二叉链表

//二叉链表定义
typedef struct btnode
{
	datatype data;
	struct btnode *lchild,*rchild;
}*BinTree;
BInTree bt;

//先序遍历
void preorder(BinTree bt)
{
	if(bt!=NULL)
	{
		visit(bt);
		preorder(bt->lchild);
		preorder(bt->rchild);
	}
}

//中序遍历
void inorder(BinTree bt)
{
	if(bt!=NULL)
	{
		inorder(bt->lchild);
		visit(bt);
		inorder(bt->rchild);
	}
}

//后序遍历
void lastorder(BInTree bt)
{
	if(bt!=NULL)
	{
		lastorder(bt->lchild);
		lastorder(bt->rchild);
		visit(bt);
	}
}

//叶结点的个数
int leafnum(BinTree bt)
{
	if(bt==NULL)
		return 0;
	else if(bt->lchild==NULL && bt->rchild == NULL)
		return 1;
	else 
		return (leafnum(bt->lchild)+leafnum(bt->rchild)); 	
}

//度为1的结点
int onenum(BinTree bt)
{
	if(bt==NULL)
		return 0;
	else if((bt->lchild!=NULL && bt->rchild == NULL) || (bt->lchild==NULL && bt->rchild != NULL))
		return (onenum(bt->lchild)+onenum(bt->rchild)+1);
	else 
		return (onenum(bt->lchild)+onenum(bt->rchild));
}

//度为2的结点
int twonum(BinTree bt)
{
	if(bt==NULL)
		return 0;
	else if(bt->lchild!=NULL && bt->rchild != NULL)
		return (twonum(bt->lchild)+twonum(bt->rchild)+1);
	else (bt->lchild == NULL || bt->rchild == NULL)
		return (twonum(bt->lchild)+twonum(bt->rchild));
}

//非终端结点
int notleafnum(BinTree bt)
{
	if(bt==NULL)
		return 0;
	else if(bt->lchild==NULL && bt->rchild == NULL)
		return 0;
	else 
		return (notleafnum(bt->lchild)+notleafnum(bt->rchild)+1);
}

//所有结点
int allnum(BinTree bt)
{
	if(bt==NULL)
		return 0;
	else 
		return (allnum(bt->lchild)+allnum(bt->rchild)+1);
}

//数据域为8的个数
int data8num(BinTree bt)
{
	if(bt==NULL)
		return 0;
	else if(bt->data==8)
		return (data8num(bt->lchild)+data8num(bt->rchild)+1);
	else 
		return (data8num(bt->lchild)+data8num(bt->rchild));
}

//二叉树高度
int height(BinTree bt)
{
	int l,h;
	if(bt==NULL)
		return 0;
	else 
	{
		l=height(bt->lchild);
		r=height(bt->rchild);
		return 1+(l>r?l:r)
	}
}

线性表的顺序存储

//顺性表的定义
const maxsize = 10；
typedef struct
{
	dataType data[maxsize];
	int length;
} sqlist;
sqlist L;

//顺序表的插入
void insert(sqlist L,datatype x,int i)
{
	if(L.length == maxsize) error("表满");
	if(i<1 || i>L.length) error("位置错");
	for(j=L.length;j>=i;j--)
		L.data[j] = L.data[j-1];
	L.data[i-1] = x;
	L.length++;
}

//顺序表的删除
void delete(sqlist L,int i)
{
	if(i<1 || i>L.length) error("位置错");
	for(j=i;j<L.length;j++)
		L.data[j-1]=L.data[j];
	L.length--;
}

//顺序表的定位
int loacate(sqlist L,datatype x)
{
	int i=0;
	while(L.data[i]!=x&&i<L.length)
		i++;
	if(i<L.length) return i+1;
	else return 0;
}

//顺序表改为单链表
void *CreateLink(dataType a[],int n)
{
	linkList head;
	Node *p;
	head = malloc(sizeof(Node));
	head->next = NULL;
	for(i=n-1;i>=0;i--)
	{
		p=malloc(sizeof(Node));
		p->data=a[i];
		p->next = head->next;
		head->next=p;
	}
	return head;
}

//顺序表逆置
void revert(int a[],int n)
{
	int i,temp;
	for(i=0;i<n/2-1;i++)
	{
		temp = a[i];
		a[i] = a[n-i-1];
		a[n-i-1] = temp;
	}
}

线性表的链式存储

//单链表的定义
typedef struct node{
	dataType x;
	struct node *next
}Node,*linkList;

//单链表的初始化
Linklist initalLink()
{
	Linklist head;
	head = malloc(sizeof(Node));
	head->next = NULL;
	return head;
}

//单链表的长度
int length(Linklist head)
{
	Node *p;
	p=head; int j=0;
	while(p->next!=NULL)
	{
		p=p->next;
		j++;
	}
	return j;
}

//插入
void insert(Linklist head,int i,datatype x)
{
	Node *p,*q;
	if(i==1) p=head;
	else p=getLinklist(head,i-1);
	if(p==NULL) error("找不到插入位置")
	else {
		q=malloc(sizeof(Node));
		q->next = p->next;
		q->data = x;
		p->next = q;
	}
}

//删除
void delete(Linklist head,int i)
{
	Node *p,*q;
	if(i==1) p=head;
	else p=getLinklist(head,i-1);
	if(p!=NULL && p->next!=NULL) 
	{
		q=p->next;
		p->next = q->next;
		free(p);
	}else{
		error("找不到删除位置")
	}
}

//读表中的元素
Node *getLinklist(Linklist head,int i)
{
	Node *p;
	p=head->next;int j=1;
	while(j<i&&p!=NULL)
	{
		p=p->next;
		j++;
	}
	if(j==i) return p;
	else return NULL;
}

//定位
int locateLinklist(Linklist head,dataType x)
{
	Node *p;
	p=head->next;int j=1;
	while(p!=NULL&&p->data!=x)
	{
		p=p->next;
		j++;
	}
	if(p!=NULL) return j;
	else return 0;
}

//将值为x的值插入单链表中，使得L仍然有序
void insert(Linklist L,datatype x)
{
	Node *p,*q;
	Linklist s;
	p=L;
	q=L->next;
	while(q!=NULL&&q->data<x)
	{
		p=q;
		q=q->next;
	}
	s=malloc(sizeof(Node));
	s->data=x;
	s->next=q->next;
	q->next=s;
}

//将值为x的值插入单循环链表表中，使得L仍然有序
void insert(Linklist L,datatype x)
{
	Node *p,*q;
	p=L;
	q=p->next;
	Linklist s;
	while(q!=L&&q->data<x)
	{
		p=q;
		q=q->next;
	}
	s=malloc(sizeof(Node));
	s->data=x;
	s->next=q->next;
	q->next=s;
}

图

//图的存储结构定义
#define MaxVertex num;
typedef int EdgeType;
typedef char VertexType;
typedef struct graph{
	int n,e;
	EdgeType edge[MaxVertex][MaxVertex];
	VertexType vertex[MaxVertex];
}
//向图中插入一条边
void Addgraphedge(Graph *G,VertexType x,VertexType y)
{
	int i=-1;int j=-1;
	for(int k=0;k<G->n;k++)
	{
		if(G->vertex[k]==x) i=k;
		if(G->vertex[k]==y) j=k;
	}
	if(i==-1||j==-1) error("找不到插入位置");
	else{
		G->edge[i][j]=1;
		G->edge[j][i]=1;
		G->e++;
	}
}
//矩阵的转置
void main()
{
	int i,j,temp;
	for(i=0;i<=n;i++)
	{
		for(j=0;j<=n;j++)
		{
			temp=A[i][j];
			A[i][j] = A[j][i];
			A[j][i] = temp;
		}
	}
}

链式栈

初始化
void stkLink()
{
	LS=malloc(sizeof(Node));
	LS->next=NULL;
}

判栈空
int emptystk(LKstk *LS)
{
	if(LS->next==NULL) return 1;
	else return 0;
}

进栈
void pushstk(LKstk *LS)
{
	Node *temp;
	temp=malloc(sizeof(Node));
	temp->next=LS->next;
	LS->next=temp;
	temp->data=x;
}

出栈
void delete(LKstk *LS)
{
	if(LS->next!=NULL)
	{
		Node *temp;
		temp=LS->next;
		LS->next=temp->next;
		free(temp);
	}
}

取栈顶
int getTop(LKstk *LS)
{
	if(LS->next!=NULL){
		return LS->next->data;
	}
	return NULLdata;
}

链式队列

队列初始化
void inital(LKQue *LQ)
{
	lkQueue *temp;
	temp=malloc(sizeof(node));
	LQ->front=temp;
	LQ->rear=temp;
	(LQ->front)->next=NULL;
}

判队列空
int emptyLKQue(LKQue *LQ)
{
	if(LQ->rear==LQ->front)
		return 1;
	else return 0;
}

入队列
void enter(LKQue *LQ,DataType x)
{
	LkQueue *temp;
	temp=malloc(sizeof(Node));
	temp->data=x;
	temp->next=NULL;
	(LQ->rear)->next=temp;  //先将结点插入尾结点的后面
	LQ->rear=temp; //再将尾结点指向它
}

出队列
void pop(LKQue *LQ)
{
	if(LQ->front != LQ->rear)
	{
		temp = LQ->front->next;
		LQ->front->next=temp->next;
		if(temp->next==NULL)
			LQ->rear=LQ->front;
		free(temp);
	}
}
avatar
文章
阅读
粉丝