数据结构算法【考研】

目录：

1.1 统计出单链表HL中结点的值等于给定值X的结点数

2.1 设有一组初始记录关键字序列（K1，K2，… Kn），要求设计一个算法能够在 O(n) 的时间复杂度内将线性表划分成两部分，其中左半部分的每个关键字均小于 Ki ，右半部分的每个关键字均大于等于 Ki

2.2 设有两个集合A和集合B，要求设计生成集合C=A∩B的算法，其中集合A、B和C用链式存储结构表示

3.1 设计在单链表中删除值相同的多余结点的算法

3.2 设计一个求结点 x 在二叉树中的双亲结点算法

4.1 设单链表中有仅三类字符的数据元素(大写字母、数字和其它字符)，要求利用原单链表中结点空间设计出三个单链表的算法，使每个单链表只包含同类字符

4.2 设计在链式存储结构上交换二叉树中所有结点左右子树的算法

4.3 在链式存储结构上建立一颗二叉排序树

5.1 设计判断两个二叉树是否相同的算法

5.2 设计两个有序单链表的合并排序算法

6.1 设计在顺序有序表中实现二分查找的算法

6.2 设计判断二叉树是否为二叉排序树的算法

6.3 在链式存储结构上设计直接插入排序

7.1 设计在链式结构上实现简单选择排序

7.2 设计在顺序存储结构上实现求子串算法

7.3 设计求结点在二叉排序树中层次的算法

8.1 设计一个在链式存储结构上统计二叉树中结点个数的算法

8.2 设计一个算法将无向图的邻接矩阵转为对应邻接表的算法

9.1 设计计算二叉树中所有结点值之和的算法

9.2 设计将所有奇数移到所有偶数之前的算法

9.3 设计判断单链表中元素是否是递增的算法

10.1 设计在链式存储结构上合并排序的算法

10.2 设计在二叉排序树上查找结点 X 的算法

10.3 设关键字序列(k1，k2，…，kn-1)是堆，设计算法将关键字序列(k1，k2，…，kn-1，x)调整为堆

1.1 统计出单链表HL中结点的值等于给定值X的结点数

int CountX(LNode *HL, ElementType X){
	LNode *p;
	int count = 0;
	if(HL == NULL)	return 0;
	p = HL->next;
	while(p != NULL){
		if(p->data == X)
		++count;
		p = p->next;
	}
	return count;
} 

2.1 设有一组初始记录关键字序列（K1，K2，… Kn），要求设计一个算法能够在 O(n) 的时间复杂度内将线性表划分成两部分，其中左半部分的每个关键字均小于 Ki ，右半部分的每个关键字均大于等于 Ki

void quickpass(int r[], int s,int t)
{
	int i=s, j=t, x=r[s];
	while(i<j){	
		while (i<j &&r[j]>x) j=j-1; if (i<j) {r[i]=r[j];i=i+1;}
		while (i<j && r[i]<x) i=i+1;if (i<j) {r[j]=r[i];j=j-1;}
	}
	r[i]=x;
}

2.2 设有两个集合A和集合B，要求设计生成集合C=A∩B的算法，其中集合A、B和C用链式存储结构表示

typedef struct node {int data;struct node *next;}lklist;
void intersection(lklist*ha,lklist *hb,lklist *&hc)
{
	lklist *p,*q,*t;
	for(p=ha,hc=0;p!=0;p=p->next)
	{ 
		for(q=hb;q!=0;q=q->next) 
		{
			if (q->data==p->data) break;
		}
		if(q!=0)
		{
			t=(lklist*)malloc(sizeof(lklist)); 
			t->data=p->data;t->next=hc; hc=t;
		}
	}
}

3.1 设计在单链表中删除值相同的多余结点的算法

typedef int datatype;
typedef struct node
{
    datatype data;
    struct node *front, *next;
}lklist;
void delredundant(lklist *&head)
{
	lklist *p,*q,*s;
	for(p=head; p!=0; p=p->next)
	{
		for(q=p->next, s=q; q!=0;)
		{
			if(q->data==p->data)
			{
				s->next=q->next; free(q); q=s->next;
			}else{
				s=q; q=q->next;
			}
		}
	}
}	

3.2 设计一个求结点 x 在二叉树中的双亲结点算法

typedef struct node {datatype data; struct node *lchild,*rchild;} bitree;
bitree *q[20]; int r=0,f=0,flag=0;
void preorder(bitree *bt, char x)
{
	if (bt!=0 && flag==0)
		if (bt->data==x) { flag=1; return;}
		else {
			r=(r+1)% 20; q[r]=bt; 
			preorder(bt->lchild,x); 
			preorder(bt->rchild,x); 
		}
}
void parent(bitree *bt,char x)
{
	int i;
	preorder(bt,x);
	for(i=f+1; i<=r; i++) 
	{
		if (q[i]->lchild->data==x || q[i]->rchild->data) break;
	}
	if (flag==0) printf("not found x\n");
	else if (i<=r) printf("%c",bt->data); 
	else printf("not parent");
}

4.1 设单链表中有仅三类字符的数据元素(大写字母、数字和其它字符)，要求利用原单链表中结点空间设计出三个单链表的算法，使每个单链表只包含同类字符

typedef char datatype;
typedef struct node {datatype data;struct node *next;}lklist;
void split(lklist *head,lklist*&ha,lklist *&hb,lklist *&hc)
{
	lklist *p; ha=0,hb=0,hc=0;
	for(p=head;p!=0;p=head)
	{
		 head=p->next; p->next=0;
		 if (p->data>='A' && p->data<='Z') {p->next=ha;ha=p;}
		 else if (p->data>='0' && p->data<='9')
		 {p->next=hb; hb=p;} else {p->next=hc; hc=p;}
  	}
}

4.2 设计在链式存储结构上交换二叉树中所有结点左右子树的算法

typedef struct node{ int data;struct node *lchild,*rchild;}Bitree;
void swapbitree(Bitree *bt)
{
	Bitree *p;
	if(bt==0)
	{
		return;
	}
	swapbitree(bt->lchild);
	swapbitree(bt->rchild);
	p=bt->lchild;
	bt->lchild=bt->rchild;
	bt->rchild=p;
}

4.3 在链式存储结构上建立一颗二叉排序树

#define n10
typedefstruct node{int key; struct node *lchild,*rchild;}bitree;
voidbstinsert(bitree *&bt,int key)
{
	if (bt==0)
	{
		bt=(bitree*)malloc(sizeof(bitree)); 
		bt->key=key;bt->lchild=bt->rchild=0;
	}
	else if (bt->key>key) 
		bstinsert(bt->lchild,key);
	else bstinsert(bt->rchild,key);
}
voidcreatebsttree(bitree *&bt)
{
	int i;
	for(i=1;i<=n;i++)bstinsert(bt,random(100));
}

5.1 设计判断两个二叉树是否相同的算法

typedef struct node(datatype data; struct node *lchild, *rchild;)bitree;
int judgebitree(bitree *bt1,bitree *bt2)//判断两个二叉树是否相同。
{
  	if (bt1==0 && bt2==0)//两棵树对应位置都为空返回1
  		return 1;
  	else if (bt1==0 || bt2==0 ||bt1->data!=bt2->data) 
  	//两棵树的当前节点只有一个为空或者两棵树的当前节点的值不同。
	  	return 0;
  	else 
	  	return judgebitree(bt1->lchild,bt2->lchild)*judgebitree(bt1->rchild,bt2->rchild);
}

5.2 设计两个有序单链表的合并排序算法

Typedef struct Lnode{
	Datatype data;
	Struct Lnode *next;
}Lnode,*linklist;
Void Merge_List(Linklist &la,linklist &b){
	LNode *pa=la->next,*pb=lb->next,*r;   //r指针防止断链
	La->next=null；                    
		While(pa&&pb){
		If(pa->data >= pb->data){
			r=pa->next;                   
			Pa->next=la->next;
			La->next=pa;
			Pa=r;                  //pa重新指向未排序位置
		}
		If(pa->data <= pb->data){
			r=pb->next;                  
			Pb->next=la->next;
			La->next=pb;
			Pb=r;                  
		}
	}
	If(pa)  pb=pa;           
	While(pb){               
		r=pb->next;
		Pb->next=la->next;
		La->next=pb;
		Pb=r;
	}
	Free(lb);                //释放掉lb的空闲空间
}

6.1 设计在顺序有序表中实现二分查找的算法

struct record{int key; int others;};
int bisearch(struct record r[], int k)
{
	int low=0, mid, high=n-1;
	while(low<=high)
	{
		mid=(low+high)/2;
		if(r[mid].key==k)
		{
			return (mid+1);
		}
		else if(r[mid].key>k)
		{
			high=mid-1;
		}else{
			low=mid+1;
		}
	}
	return 0;
}

6.2 设计判断二叉树是否为二叉排序树的算法

//递归方式
KeyType predt=-32767;
int JudgeBST(BisTree bt)
{
	int b1, b2;
	if(bt==NULL)
	{
		return 1;
	}else{
		b1=JudgeBST(bt->lchild); //递归
		if(b1==0 || predt>=bt->data)
			return 0;
		predt=bt->data;
		b2=JudgeBST(bt->rchild);
		return b2;	
	}
}
//非递归方式
int InOrderTraverse(BiTree T)
{
	BiTree p;
	p=T;
	while(p||!StackEmpty(S))
	{
		if(p)
		{
			Push(S,p);
			if(p->data>p->lchild->data)
				p=p->lchild;
			else return 0;
		}
		else
		{
			Pop(S,p);
			cout<<p->data<<" ";
			if(p->data<p->rchild->data)
				p=p->rchild;
			else return 0;
		}
	}
	return 1；
}

6.3 在链式存储结构上设计直接插入排序

void straightinsertsort(lklist *&head)
{
	lklist *s,*p,*q;
	int t;
	if(head==0 || head->next==0) return ;
	else for(q=head, p=head->next; p!=0; p=q->next)
	{
		for(s=head; s!=q->next; s=s->next)
		{
			if(s->data > p->data) break;
			if(s==q->next) q=p;
			else{
				q->next=p->next;
				p->next=s->next;
				s->next=p;
				t=p->data;
				p->data=s->data;
				s->data=t;
			}
		}	
	}
}

7.1 设计在链式结构上实现简单选择排序

typedef struct LNode{int data;struct LNode *next}*Linklist;
void  simpleselectSort(Linklist *&head)
{
	Linklist *p,*q,*s;
	int min,t;
	if(head==0 || head->next==0)
	{
		return;
	}
	for(q=head;q!=0;q=q->next)
	{
		min=q->data;
		s=q;
		for(p=q->next;p!=0;p=p->next)
		{
			if(min>p->data)
			{
				min=p->data;
				s=p;
			}
		}
		if(s!=q)
		{
			t=s->data;
			s->data=q->data;
			q->data=t;
		}
	}
}

7.2 设计在顺序存储结构上实现求子串算法

void subString(char s[],int start,long count,char t[])
{
	long i,j,length=strlen(s);
	if(start<1 || start>length)
	{
		printf("The copy position is wrong!\n");
	}else if(start+count-1>length)
	{
		printf("Too characters to be copied!\n");
	}else
	{
		for(i=start-1,j=0;i<start+count-1;i++,j++)
		{
			t[j]=s[i];
		}
		t[j]='\0';
	}
}

7.3 设计求结点在二叉排序树中层次的算法

int lev=0;
typedef struct node
{
	int key;
	struct node *lchild,*rchild;
}bitree;
void level(bitree *bt, int x)
{
	if(bt!=0)
	{
		lev++;
		if(bt->key==x)
		{
			return;
		}
		else if(bt->key>x)
		{
			level(bt->lchild, x);
		}
	}
	else{
		level(bt->rchild, x);
	}
}

8.1 设计一个在链式存储结构上统计二叉树中结点个数的算法

voidcountnode(bitree *bt,int &count)
{
	if(bt!=0)
	{
		count++;
		countnode(bt->lchild,count); 
		countnode(bt->rchild,count);
	}
}

8.2 设计一个算法将无向图的邻接矩阵转为对应邻接表的算法

typedef struct {intvertex[m]; int edge[m][m];}gadjmatrix;
typedef structnode1{int info;int adjvertex; struct node1 *nextarc;}glinklistnode;
typedef structnode2{int vertexinfo;glinklistnode *firstarc;}glinkheadnode;

voidadjmatrixtoadjlist(gadjmatrix g1[ ],glinkheadnode g2[ ])
{
	int i,j;glinklistnode *p;
	for(i=0;i<=n-1;i++)g2[i].firstarc=0;
	for(i=0;i<=n-1;i++)for(j=0;j<=n-1;j++)
	if(g1.edge[i][j]==1)
	{
		p=(glinklistnode*)malloc(sizeof(glinklistnode)); p->adjvertex=j;
		p->nextarc=g[i].firstarc; g[i].firstarc=p;
		p=(glinklistnode*)malloc(sizeof(glinklistnode)); p->adjvertex=i;
		p->nextarc=g[j].firstarc; g[j].firstarc=p;
	}
}

9.1 设计计算二叉树中所有结点值之和的算法

voidsum(bitree *bt,int &s)
{
   if(bt!=0)
   {
		s=s+bt->data; 
		sum(bt->lchild,s);
		sum(bt->rchild,s);
	}   
}

9.2 设计将所有奇数移到所有偶数之前的算法

voidquickpass(int r[], int s, int t)
{
	int i=s,j=t,x=r[s];
	while(i<j)
	{
		while (i<j && r[j]%2==0)
			j=j-1;  
			if (i<j) {r[i]=r[j];i=i+1;}
		while (i<j && r[i]%2==1)
			i=i+1; 
			if (i<j) {r[j]=r[i];j=j-1;}
	}
	r[i]=x;
}

9.3 设计判断单链表中元素是否是递增的算法

intisriselk(lklist *head)
{
	if(head==0||head->next==0)return(1);
	else
		for(q=head,p=head->next;p!=0; q=p,p=p->next)
			if(q->data>p->data) return(0);
	return(1);
}

10.1 设计在链式存储结构上合并排序的算法

voidmergelklist(lklist *ha,lklist *hb,lklist *&hc)
{
	lklist *s=hc=0;
	while(ha!=0 && hb!=0)
		if(ha->data<hb->data)
		{
			if(s==0)hc=s=ha; 
			else {s->next=ha; s=ha;};
			ha=ha->next;
		}
		else {
			if(s==0) hc=s=hb; 
			else {s->next=hb; s=hb;};
			hb=hb->next;
		}
		if(ha==0) s->next=hb; 
		else s->next=ha;
}

10.2 设计在二叉排序树上查找结点X的算法

bitree*bstsearch1(bitree *t, int key)
{
	bitree *p=t;
	while(p!=0) 
		if (p->key==key)return(p);
		else if (p->key>key) p=p->lchild; 
		else p=p->rchild;
	return(0);
}

10.3 设关键字序列(k1，k2，…，kn-1)是堆，设计算法将关键字序列(k1，k2，…，kn-1，x)调整为堆

void adjustheap(int r[ ],int n)
{
	int j=n,i=j/2,temp=r[j-1];
	while (i>=1) 
		if(temp>=r[i-1])break; 
		else{
			r[j-1]=r[i-1]; j=i; i=i/2;
		}
	r[j-1]=temp;
}