数据结构算法题整理

1.删除链表中的奇数

#include<stdio.h>
#include<stdlib.h>

typedef struct node
{
	int data;
	struct node *next;
}node, *LinkList;

//删除链表中的奇数
void delete_x(LinkList ls)
{
	LinkList pre,p;
	pre=ls; p=pre->next;
	while(p)
	{
		if(p->data%2==1)
		{
			pre->next=p->next;
			free(p);
		}
		else{
			pre=p;
		}
		p=pre->next;
	}
}

void CreateLinkList(LinkList *L,int n)
{
	int i;
	LinkList p;
	(*L)=(LinkList)malloc(sizeof(node));
	(*L)->next=NULL;
	for(i=n;i>0;--i){
		p=(LinkList)malloc(sizeof(node));
		p->data=i;
		p->next=(*L)->next;
		(*L)->next=p;
	}
}


void Traverse(LinkList LS)
{
	LinkList p;
	p=LS->next;
	while(p)
	{
		printf("%3d",p->data);
		p=p->next;
	}
}

int main()
{
	LinkList LS;
	CreateLinkList(&LS,10);
	delete_x(LS);
	Traverse(LS);
	return 0;
}

2.用递归法实现折半查找算法

#include<stdio.h>
//用递归法实现折半查找算法

int BinSearch(int *r,int low,int high,int key)
{
	int mid;
	if(low>high)
		return 0;
	mid=(low+high)/2;
	if(key<r[mid])
		return BinSearch(r,low,mid-1,key);
	if(key>r[mid])
		return BinSearch(r,mid+1,high,key);
	if(key==r[mid])
		return mid;
}

int main()
{
	int r[10],i,loc;
	for(i=0;i<9;i++) r[i]=i;
	loc=BinSearch(r,0,9,4);
	printf("%d",loc);
	return 0;
}

3.统计二叉树的结点个数和叶子结点个数

#include<stdio.h>
#include<stdlib.h>
typedef struct btreenode
{
	int data;
	struct btreenode *LC,*RC;
}bnode,*BiTree;

//统计叶子结点个数
int num=0,i=0;

void leaves(BiTree T)
{
	if(T)
	{
		if((T->LC==NULL) && (T->RC==NULL))
			num++;
		leaves(T->LC);
		leaves(T->RC);
	}
}

//统计结点个数
int nodes(BiTree T)
{
	if(!T)
		return 0;
	else return nodes(T->LC)+nodes(T->RC)+1;
}

//创建一颗二叉树
void create_binary_tree(BiTree *T)
{
	if(i==10) (*T)=NULL;
	else
	{
		(*T)=(bnode *)malloc(sizeof(bnode));
		(*T)->data=i++;
		create_binary_tree(&(*T)->LC);
		create_binary_tree(&(*T)->RC);
	}
}

//前序遍历
void preOrder(BiTree T)
{
	if(T)
	{
		printf("%3d",T->data);
		preOrder(T->LC);
		preOrder(T->RC);
	}	
}


void main()
{
//	bnode *root=NULL;
	BiTree T;
	create_binary_tree(&T);
//	printf("number of all nodes:%d\n",nodes(root));
	leaves(T);
	preOrder(T);
	printf("number of leaves:%d\n",num);
	printf("number of nodes:%d\n",nodes(T));
}

4.设已有一个由正整数组成的无序的单链表，编写3个函数，实现
下列功能：
（1）找出值最小的结点，打印该数值
（2）若该数值是奇数，则将其与直接后继结点的数值交换，若无
后继则不作操作。
（3）若该数值是偶数，则将其直接后继结点删除，若无后继则不
做操作。

#include<stdio.h>
#include<stdlib.h>

typedef struct node
{
	int data;
	struct node *next;
}node,*LinkList;

```c
node *find_min_node(node *h)
{
	int min;
	node *p,*t;
	if(h==NULL)
		return NULL;
	p=h->next;
	t=NULL;
	min=p->data;
	while(p)
	{
		if(p->data<min)
		{
			t=p;
			min=p->data;
		}
		p=p->next;
	}
	printf("min=%d\n",t->data);
	return t;
}

//将p与p的后继结点数值交换
void switch_next_node(node *p)
{
	node *q;
	int t;
	q=p->next;
	if(q==NULL) return;
	t=p->data;
	p->data=q->data;
	q->data=t;
}

//删除p的后继结点
void del_next_node(node *p)
{
	node *q;
	q=p->next;
	if(q==NULL)return;
	p->next=q->next;
	free(q);
}

//头插法初始化链表
init_node(LinkList *head)
{
	int i;
	node *p;
	(*head)=(node *)malloc(sizeof(node));
	(*head)->data=19;
	p=(node *)malloc(sizeof(node));
	p->data=34;
	p->next=NULL;
	(*head)->next=p;
	for(i=1;i<10;i++)
	{
		p=(node *)malloc(sizeof(node));
		p->data=i;
		p->next=(*head)->next;
		(*head)->next=p;
	}
}

void traverse(node *head)
{
	node *p=head;
	while(p)
	{
		printf("%3d",p->data);
		p=p->next;
	}
	printf("\n");
}

void main()
{
	node *head,*p;
	init_node(&head);
	traverse(head);
	p=find_min_node(head);
	if(p->data%2==1)
		switch_next_node(p);
	else
		del_next_node(p);
	traverse(head);		
}

5.利用顺序存储结构建立单链表

#include<stdio.h>
#include<stdlib.h>

typedef struct node
{
	int data;
	struct node *next;
}node,*LinkList;

//头插法初始化链表
build_node(LinkList *head,int a[],int n)
{
	int i;
	node *p;
	(*head)=(node *)malloc(sizeof(node));
	(*head)->data=a[0];
	p=(node *)malloc(sizeof(node));
	p->data=a[n-1];
	p->next=NULL;
	(*head)->next=p;
	for(i=1;i<n-1;i++)
	{
		p=(node *)malloc(sizeof(node));
		p->data=a[8-i];
		p->next=(*head)->next;
		(*head)->next=p;
	}
}

void traverse_node(node *head)
{
	node *p=head;
	while(p)
	{
		printf("%3d",p->data);
		p=p->next;
	}
	printf("\n");
}

void traverse_array(int a[],int n)
{
	int i;
	for(i=0;i<n;i++)
		printf("%3d",a[i]);
	printf("\n");
}

void main()
{
	node *head,*p;
	int a[9]={1,3,2,5,4,7,6,9,8};
	build_node(&head,a,9);
	traverse_array(a,9);
	traverse_node(head);	
	return 0;
}

6.向单链表的末尾添加一个元素的算法

#include<stdio.h>
#include<stdlib.h>

typedef struct node
{
	int data;
	struct node *next;
}node,*LinkList;


//头插法初始化链表
build_node(LinkList *head,int a[],int n)
{
	int i;
	node *p;
	(*head)=(node *)malloc(sizeof(node));
	(*head)->data=a[0];
	p=(node *)malloc(sizeof(node));
	p->data=a[n-1];
	p->next=NULL;
	(*head)->next=p;
	for(i=1;i<n-1;i++)
	{
		p=(node *)malloc(sizeof(node));
		p->data=a[8-i];
		p->next=(*head)->next;
		(*head)->next=p;
	}
}

void traverse_node(node *head)
{
	node *p=head;
	while(p)
	{
		printf("%3d",p->data);
		p=p->next;
	}
	printf("\n");
}

void traverse_array(int a[],int n)
{
	int i;
	for(i=0;i<n;i++)
		printf("%3d",a[i]);
	printf("\n");
}

//向单链表末尾添加一个元素的算法
void insertRear(LinkList L,int data)
{
	node* newptr,*p;
	newptr=(node *)malloc(sizeof(node));
	if(!newptr)
	{
		printf("Memory allocation failure!\n");
		exit(1);
	}
	newptr->data=data;
	if(L==NULL)
		L=newptr;
	else{
		p=L;
		while(p->next!=NULL)
			p=p->next;
		p->next=newptr;
	}
	newptr->next=NULL;
}

void main()
{
	node *head,*p;
	int a[9]={1,3,2,5,4,7,6,9,8};
	build_node(&head,a,9);
	insertRear(head,777);
	traverse_node(head);	
	return 0;
}

7.将线性表中第i个元素删除的算法

#include<stdio.h>

void traverse_array(int a[],int n)
{
	int i;
	for(i=0;i<n;i++)
		printf("%3d",a[i]);
	printf("\n");
}

//将线性表中第i个元素删除的算法
void delete_i(int a[],int size,int i)
{
	int j;
	for(j=i-1;j<size-1;j++)
		a[j]=a[j+1];
}

void main()
{
	int a[9]={1,3,2,5,4,7,6,9,8};
	traverse_array(a,9);
	delete_i(a,9,2);
	traverse_array(a,9);	
	return 0;
}

8.在带头结点的链表中查找指定元素item的算法

#include<stdio.h>
#include<stdlib.h>

typedef struct node
{
	int data;
	struct node *next;
}node,*LinkList;


//头插法初始化链表
build_node(LinkList *head,int a[],int n)
{
	int i;
	node *p;
	(*head)=(node *)malloc(sizeof(node));
	(*head)->data=a[0];
	p=(node *)malloc(sizeof(node));
	p->data=a[n-1];
	p->next=NULL;
	(*head)->next=p;
	for(i=1;i<n-1;i++)
	{
		p=(node *)malloc(sizeof(node));
		p->data=a[8-i];
		p->next=(*head)->next;
		(*head)->next=p;
	}
}

void traverse_node(node *head)
{
	node *p=head;
	while(p)
	{
		printf("%3d",p->data);
		p=p->next;
	}
	printf("\n");
}

//在带头结点的链表中查找指定元素item的算法
int Find(LinkList HL,int item)
{
	node *p=HL;
	while(p)
	{
		if(p->data==item)
			return 1;
		else p=p->next;
	}
	return 0;
}

void main()
{
	node *head,*p;
	int a[9]={1,3,2,5,4,7,6,9,8};
	build_node(&head,a,9);
	insertRear(head,777);
	traverse_node(head);	
	if(Find(head,5))printf("找到5");
	return 0;
}

9.输出0~n以内的素数

#include<stdio.h>
#include<math.h>

int Prime(int n)
{
	int i=1;
	int x=(int)sqrt(n);
	while(++i<=x)
		if(n%i==0)break;
	if(i>x)return 1;
	else return 0;
}
void printPrime(int n)
{
	int i=0;
	while(++i<=n)
	{
		if(Prime(i))
			printf("%5d",i);
	}
}
void main()
{
	printPrime(999);
	return 0;
}

10.二分查找的非递归算法

#include<stdio.h>
//二分查找的非递归算法
int Binsch(int a[],int n,int key)
{
	int low=0;
	int high=n-1;
	while(low<=high)
	{
		int mid=(high+low)/2;
		if(key==a[mid]) return mid;
		else if(key<a[mid])
			high=mid-1;
		else low=mid+1;
	}
	return -1; //查找失败返回1
}

void main()
{
	int a[5]={4,6,9,77,95};
	printf("查找77的位置为%d\n",Binsch(a,5,77));
	return 0;
}

11.删除单链表的头结点的算法

#include<stdio.h>
#include<stdlib.h>

typedef struct node
{
	int data;
	struct node *next;
}node,*LinkList;


//头插法初始化链表
build_node(LinkList *head,int a[],int n)
{
	int i;
	node *p;
	(*head)=(node *)malloc(sizeof(node));
	(*head)->data=a[0];
	p=(node *)malloc(sizeof(node));
	p->data=a[n-1];
	p->next=NULL;
	(*head)->next=p;
	for(i=1;i<n-1;i++)
	{
		p=(node *)malloc(sizeof(node));
		p->data=a[8-i];
		p->next=(*head)->next;
		(*head)->next=p;
	}
}

void traverse_node(node *head)
{
	node *p=head;
	while(p)
	{
		printf("%3d",p->data);
		p=p->next;
	}
	printf("\n");
}

void traverse_array(int a[],int n)
{
	int i;
	for(i=0;i<n;i++)
		printf("%3d",a[i]);
	printf("\n");
}

int del_head(LinkList *HL)
{
	int temp;
	node *p=(*HL);
	if((*HL)==NULL)
	{
		printf("kongbiao\n");
		exit(1);
	}
    temp=p->data;
	(*HL)=(*HL)->next;
	free(p);
	return temp;	
}

void main()
{
	node *head,*p;
	int a[9]={1,3,2,5,4,7,6,9,8};
	build_node(&head,a,9);
	traverse_node(head);	
	printf("删除的结点数值是%d\n",del_head(&head));
	traverse_node(head);
	return 0;
}

12.二叉搜索树的非递归算法

#include<stdio.h>
#include<stdlib.h>

typedef struct BiTNode
{
	int data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

void initBiTree(BiTree *BT)
{
	(*BT)=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->lchild=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->rchild=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->data=5;
	(*BT)->lchild->data=4;
	(*BT)->rchild->data=6;
	(*BT)->lchild->lchild=NULL;
	(*BT)->lchild->rchild=NULL;
	(*BT)->rchild->lchild=NULL;
	(*BT)->rchild->rchild=NULL;
}

void preOrder(BiTree T)
{
	if(T)
	{
		printf("%3d",T->data);
		preOrder(T->lchild);
		preOrder(T->rchild);
	}
}

//二叉搜索树的非递归算法
int Find(BiTree T,int item)
{
	while(T)
	{
		if(item==T->data)
			return 1;
		else if(item<T->data)
			T=T->lchild;
		else T=T->rchild;
	}
	return -1;
}

int main()
{
	BiTree T;
	initBiTree(&T);
	preOrder(T);
	if(Find(T,6))printf("查找成功\n");
}

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

#include<stdio.h>
#include<stdlib.h>

typedef struct node
{
	int data;
	struct node *next;
}node,*LinkList;


//头插法初始化链表
build_node(LinkList *head,int a[],int n)
{
	int i;
	node *p;
	(*head)=(node *)malloc(sizeof(node));
	(*head)->data=a[0];
	p=(node *)malloc(sizeof(node));
	p->data=a[n-1];
	p->next=NULL;
	(*head)->next=p;
	for(i=1;i<n-1;i++)
	{
		p=(node *)malloc(sizeof(node));
		p->data=a[8-i];
		p->next=(*head)->next;
		(*head)->next=p;
	}
}

void traverse_node(node *head)
{
	node *p=head;
	while(p)
	{
		printf("%3d",p->data);
		p=p->next;
	}
	printf("\n");
}

//统计出单链表HL中结点的值等于给定值X的结点数
int CountX(node *HL,int x)
{
	int count=0;
	node *p=HL;
	while(p)
	{
		if(p->data==x)
			count++;
		p=p->next;
	}
	return count;
}

void main()
{
	node *head;
	int a[9]={1,3,8,5,4,8,6,9,8};
	build_node(&head,a,9);
	traverse_node(head);
	printf("8的个数为%d\n",CountX(head,8));
	return 0;
}

14.设计一个算法能够在O(n)的时间内将线性表划分为两部分，其
中左半部分小于K1，右半部分大于K1

#include<stdio.h>
#include<iostream>
using namespace std;
void part(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;
}


void traverse_array(int a[],int n)
{
	for(int i=0;i<n;i++)
		printf("%3d",a[i]);
	cout<<"\n";
}


void main()
{
	int a[7]={49,30,32,78,79,34,49};
	traverse_array(a,7);
	part(a,0,7);
	traverse_array(a,7);
}

15.有两个集合A、B，要求设计算法生成C，C=A∩B,用连式存储表
示

#include<stdio.h>
#include<stdlib.h>

typedef struct node
{
	int data;
	struct node *next;
}node,*LinkList;


//头插法初始化链表
void build_node(LinkList *head,int a[],int n)
{
	int i;
	node *p;
	(*head)=(node *)malloc(sizeof(node));
	(*head)->data=a[0];
	p=(node *)malloc(sizeof(node));
	p->data=a[n-1];
	p->next=NULL;
	(*head)->next=p;
	for(i=1;i<n-1;i++)
	{
		p=(node *)malloc(sizeof(node));
		p->data=a[8-i];
		p->next=(*head)->next;
		(*head)->next=p;
	}
}

void traverse_node(node *head)
{
	node *p=head;
	while(p)
	{
		printf("%3d",p->data);
		p=p->next;
	}
	printf("\n");
}

void traverse_array(int a[],int n)
{
	int i;
	for(i=0;i<n;i++)
		printf("%3d",a[i]);
	printf("\n");
}

void insertsection(LinkList La,LinkList Lb,LinkList *Lc)
{
	LinkList p,q,t;
	for(p=La,(*Lc)=0;p!=0;p=p->next)
	{
		for(q=Lb;q!=0;q=q->next)if(q->data==p->data)break;
		if(q!=0){t=(node *)malloc(sizeof(node));t->data=p->data;t->next=(*Lc);(*Lc)=t;}
	}
}

void main()
{
	LinkList La,Lb,Lc;
	int a[9]={1,3,2,5,4,7,6,9,8};
	int b[9]={3,6,8,9,33,22,10,99,22};
	build_node(&La,a,9);
	build_node(&Lb,b,9);
	traverse_node(La);	
	traverse_node(Lb);
	insertsection(La,Lb,&Lc);
	traverse_node(Lc);
}

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

#include<stdio.h>
#include<stdlib.h>

typedef struct node
{
	int data;
	struct node *next;
}node,*LinkList;


//头插法初始化链表
void build_node(LinkList *head,int a[],int n)
{
	int i;
	node *p;
	(*head)=(node *)malloc(sizeof(node));
	(*head)->data=a[0];
	p=(node *)malloc(sizeof(node));
	p->data=a[n-1];
	p->next=NULL;
	(*head)->next=p;
	for(i=1;i<n-1;i++)
	{
		p=(node *)malloc(sizeof(node));
		p->data=a[8-i];
		p->next=(*head)->next;
		(*head)->next=p;
	}
}

void traverse_node(node *head)
{
	node *p=head;
	while(p)
	{
		printf("%3d",p->data);
		p=p->next;
	}
	printf("\n");
}

```c
//设计在单链表中删除相同值的多余结点的算法
void delredundant(LinkList *head)
{
	LinkList 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;}
	}
}

void main()
{
	LinkList La;
	int a[9]={1,3,2,3,4,7,6,3,8};
	build_node(&La,a,9);
	traverse_node(La);	
	delredundant(&La);
	traverse_node(La);
}

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

#include<stdio.h>
typedef char datatype;
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");
}

18.一个链表中有字母，数字和其他字符，设计一个算法，用三个
链表将三种字符分离。

#include<stdio.h>
#include<stdlib.h>

typedef struct node
{
	char data;
	struct node *next;
}node,*LinkList;


//头插法初始化链表
void build_node(LinkList *head,char a[],int n)
{
	int i;
	node *p;
	(*head)=(node *)malloc(sizeof(node));
	(*head)->data=a[0];
	p=(node *)malloc(sizeof(node));
	p->data=a[n-1];
	p->next=NULL;
	(*head)->next=p;
	for(i=1;i<n-1;i++)
	{
		p=(node *)malloc(sizeof(node));
		p->data=a[8-i];
		p->next=(*head)->next;
		(*head)->next=p;
	}
}

void traverse_node(node *head)
{
	node *p=head;
	while(p)
	{
		printf("%3c ",p->data);
		p=p->next;
	}
	printf("\n");
}

void split(LinkList head,LinkList *La,LinkList 

*Lb,LinkList *Lc)
{
	LinkList p=head,newp;
	(*La)=0;(*Lb)=0;(*Lc)=0;
	while(p)
	{
		if((p->data>='A' && p->data<='Z') || (p-

>data>='a' && p->data<='z'))
		{ newp=(LinkList)malloc(sizeof(node)); 

newp->data=p->data;newp->next=(*La);(*La)=newp;}
		else if(p->data>='0' && p->data<='9')
		{ newp=(LinkList)malloc(sizeof(node)); 

newp->data=p->data;newp->next=(*Lb);(*Lb)=newp;}
		else
		{ newp=(LinkList)malloc(sizeof(node)); 

newp->data=p->data;newp->next=(*Lc);(*Lc)=newp;}
		p=p->next;
	}
}

void main()
{
	node *head,*La,*Lb,*Lc;
	char data[9]=

{'1','3','2','z','f','E','[','.','s'};
	build_node(&head,data,9);
	split(head,&La,&Lb,&Lc);
	traverse_node(head);
	traverse_node(La);
	traverse_node(Lb);
	traverse_node(Lc);
}

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

#include<stdio.h>
#include<stdlib.h>

typedef struct BiTNode
{
	int data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

void initBiTree(BiTree *BT)
{
	(*BT)=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->lchild=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->rchild=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->data=5;
	(*BT)->lchild->data=4;
	(*BT)->rchild->data=6;
	(*BT)->lchild->lchild=NULL;
	(*BT)->lchild->rchild=NULL;
	(*BT)->rchild->lchild=NULL;
	(*BT)->rchild->rchild=NULL;
}

void preOrder(BiTree T)
{
	if(T)
	{
		printf("%3d",T->data);
		preOrder(T->lchild);
		preOrder(T->rchild);
	}
}

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

void main()
{
	BiTree T;
	initBiTree(&T);
	preOrder(T);
	swapbitree(T);
	preOrder(T);
}

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

#include<stdio.h>
#include<stdlib.h>
#define N 10

typedef struct BiTNode
{
	int key;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

void bstinsert(BiTree *BT,int key)
{
	if((*BT)==0)
	{
		(*BT)=(BiTree)malloc(sizeof(BiTNode));
		(*BT)->key=key;
		(*BT)->lchild=(*BT)->rchild=0;
	}
	else if((*BT)->key>key)
		bstinsert(&(*BT)->lchild,key);
	else bstinsert(&(*BT)->rchild,key);
}

void createbsttree(BiTree *BT)
{
	int i;
	for(i=1;i<N;i++) bstinsert(BT,rand()%100);
}

void preOrder(BiTree T)
{
	if(T)
	{
		printf("%3d",T->key);
		preOrder(T->lchild);
		preOrder(T->rchild);
	}
}

void MidOrder(BiTree T)
{
	if(T)
	{
		
		MidOrder(T->lchild);
		printf("%3d",T->key);
		MidOrder(T->rchild);
	}
}



void main()
{
	BiTree T=0;
	createbsttree(&T);
	preOrder(T);printf("\n");
	MidOrder(T);
}

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

#include<stdio.h>
#include<stdlib.h>
#define N 10

typedef struct BiTNode
{
	int data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;


void initBiTree(BiTree *BT,int a,int b,int c)
{
	(*BT)=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->lchild=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->rchild=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->data=a;
	(*BT)->lchild->data=b;
	(*BT)->rchild->data=c;
	(*BT)->lchild->lchild=NULL;
	(*BT)->lchild->rchild=NULL;
	(*BT)->rchild->lchild=NULL;
	(*BT)->rchild->rchild=NULL;
}

void preOrder(BiTree T)
{
	if(T)
	{
		printf("%3d",T->data);
		preOrder(T->lchild);
		preOrder(T->rchild);
	}
}

int judgebitree(BiTree T1,BiTree T2)
{
	if(T1==0 && T2==0)return 1;
	else if(T1==0 || T2==0 || T1->data!=T2->data) 

return 0;
	else return(judgebitree(T1->lchild,T2->lchild)

*judgebitree(T1->rchild,T2->rchild));
}

void main()
{
	BiTree T1,T2;
	initBiTree(&T1,1,2,3);
	initBiTree(&T2,1,2,3);
	preOrder(T1);
	printf("comparison result:%d\n",judgebitree

(T1,T2));
}

22.设计两个有序单链表的合并排序算法
#include<stdio.h>
#include<stdlib.h>

typedef struct node
{
	int data;
	struct node *next;
}node,*LinkList;


//头插法初始化链表
void build_node(LinkList *head,int a[],int n)
{
	int i;
	node *p;
	(*head)=(node *)malloc(sizeof(node));
	(*head)->data=a[0];
	p=(node *)malloc(sizeof(node));
	p->data=a[n-1];
	p->next=NULL;
	(*head)->next=p;
	for(i=1;i<n-1;i++)
	{
		p=(node *)malloc(sizeof(node));
		p->data=a[8-i];
		p->next=(*head)->next;
		(*head)->next=p;
	}
}

void traverse_node(node *head)
{
	node *p=head;
	while(p)
	{
		printf("%3d",p->data);
		p=p->next;
	}
	printf("\n");
}

void traverse_array(int a[],int n)
{
	int i;
	for(i=0;i<n;i++)
		printf("%3d",a[i]);
	printf("\n");
}

//两个有序单链表的合并排序算法
void MergeLinkList(LinkList ha,LinkList hb,LinkList *hc)
{
	LinkList 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;	
}

void main()
{
	LinkList La,Lb,Lc,*p;
	int a[9]={1,3,2,5,8,41,13,11,63};
	int b[9]={8,3,7,5,8,9,13,0,15};
	build_node(&La,a,9);
	build_node(&Lb,b,9);
	traverse_node(La);
	traverse_node(Lb);
	MergeLinkList(La,Lb,&Lc);
	traverse_node(Lc);
}

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

#include<stdio.h>
#include<stdlib.h>
#define N 10

typedef struct BiTNode
{
	int key;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

void initBiTree(BiTree *BT,int a,int b,int c)
{
	(*BT)=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->lchild=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->rchild=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->key=a;
	(*BT)->lchild->key=b;
	(*BT)->rchild->key=c;
	(*BT)->lchild->lchild=NULL;
	(*BT)->lchild->rchild=NULL;
	(*BT)->rchild->lchild=NULL;
	(*BT)->rchild->rchild=NULL;
}

void bstinsert(BiTree *BT,int key)
{
	if((*BT)==0)
	{
		(*BT)=(BiTree)malloc(sizeof(BiTNode));
		(*BT)->key=key;
		(*BT)->lchild=(*BT)->rchild=0;
	}
	else if((*BT)->key>key)
		bstinsert(&(*BT)->lchild,key);
	else bstinsert(&(*BT)->rchild,key);
}

void createbsttree(BiTree *BT)
{
	int i;
	for(i=1;i<N;i++) bstinsert(BT,rand()%100);
}

void preOrder(BiTree T)
{
	if(T)
	{
		printf("%3d",T->key);
		preOrder(T->lchild);
		preOrder(T->rchild);
	}
}

void MidOrder(BiTree T)
{
	if(T)
	{
		
		MidOrder(T->lchild);
		printf("%3d",T->key);
		MidOrder(T->rchild);
	}
}

int minnmum=-32768,flag=1;
//判断二叉树是否为二叉排序树的算法
void inorder(BiTree Bt)
{
	if(Bt)
	{
		inorder(Bt->lchild);
		if(minnmum>Bt->key)flag=0;
		minnmum=Bt->key;
		inorder(Bt->rchild);
	}
}

void main()
{
	BiTree BST=0,BT=0;
	createbsttree(&BST);
	initBiTree(&BT,1,2,3);
	printf("PreOrder BST:");
	preOrder(BST);printf("\n");
	printf("MidOrder BST:");
	MidOrder(BST);printf("\n");
	inorder(BST);
	if(flag)printf("BST is a Binary Sort Tree!\n");
	else printf("BST is not a Binary Sort Tree!\n");
	printf("MidOrder BT:");
	MidOrder(BT);printf("\n");
	inorder(BT);
	if(flag)printf("BT is a Binary Sort Tree!\n");
	else printf("BT is not a Binary Sort Tree!\n");
}

24.在链式存储结构上设计直接插入排序算法

#include<stdio.h>
#include<stdlib.h>

typedef struct node
{
	int data;
	struct node *next;
}node,*LinkList;

//头插法初始化链表
void build_node(LinkList *head,int a[],int n)
{
	int i;
	node *p;
	(*head)=(node *)malloc(sizeof(node));
	(*head)->data=a[0];
	p=(node *)malloc(sizeof(node));
	p->data=a[n-1];
	p->next=NULL;
	(*head)->next=p;
	for(i=1;i<n-1;i++)
	{
		p=(node *)malloc(sizeof(node));
		p->data=a[8-i];
		p->next=(*head)->next;
		(*head)->next=p;
	}
}

void traverse_node(node *head)
{
	node *p=head;
	while(p)
	{
		printf("%3d",p->data);
		p=p->next;
	}
	printf("\n");
}

void traverse_array(int a[],int n)
{
	int i;
	for(i=0;i<n;i++)
		printf("%3d",a[i]);
	printf("\n");
}

//链式存储结构直接插入排序算法

void straightinsertsort(LinkList *head)
{
	LinkList 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;
		}
	}
}

void main()
{
	node *head,*p;
	int a[9]={1,3,2,5,4,7,6,9,8};
	build_node(&head,a,9);
	traverse_node(head);
	straightinsertsort(&head);
	traverse_node(head);	
}

25.设计在链式存储结构上实现简单选择排序算法

#include<stdio.h>
#include<stdlib.h>

typedef struct node
{
	int data;
	struct node *next;
}node,*LinkList;

//头插法初始化链表
void build_node(LinkList *head,int a[],int n)
{
	int i;
	node *p;
	(*head)=(node *)malloc(sizeof(node));
	(*head)->data=a[0];
	p=(node *)malloc(sizeof(node));
	p->data=a[n-1];
	p->next=NULL;
	(*head)->next=p;
	for(i=1;i<n-1;i++)
	{
		p=(node *)malloc(sizeof(node));
		p->data=a[8-i];
		p->next=(*head)->next;
		(*head)->next=p;
	}
}

void traverse_node(node *head)
{
	node *p=head;
	while(p)
	{
		printf("%3d",p->data);
		p=p->next;
	}
	printf("\n");
}

//在链式存储结构上实现简单选择排序算法
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;}
	}
}

void main()
{
	node *head;
	int a[9]={1,3,2,5,4,7,6,9,8};
	build_node(&head,a,9);
	traverse_node(head);
	simpleselectsort(&head);
	traverse_node(head);	
}

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

#include<stdio.h>
#include<string.h>


void substring(char s[],long 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 

charactters to be copied!\n");
	else {for(i=start-1,j=0;i<start+count-1;i++,j++) 

t[j]=s[i];t[j]='\0';}
}

void main()
{
	char *s="DataStructure";
	char t[8]="";
	substring(s,5,9,t);
	printf("%s\n%s\n",s,t);
}

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

#include<stdio.h>
#include<stdlib.h>
#define N 10

typedef struct BiTNode
{
	int key;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

void bstinsert(BiTree *BT,int key)
{
	if((*BT)==0)
	{
		(*BT)=(BiTree)malloc(sizeof(BiTNode));
		(*BT)->key=key;
		(*BT)->lchild=(*BT)->rchild=0;
	}
	else if((*BT)->key>key)
		bstinsert(&(*BT)->lchild,key);
	else bstinsert(&(*BT)->rchild,key);
}

void createbsttree(BiTree *BT)
{
	int i;
	for(i=1;i<N;i++) bstinsert(BT,rand()%100);
}

void preOrder(BiTree T)
{
	if(T)
	{
		printf("%3d",T->key);
		preOrder(T->lchild);
		preOrder(T->rchild);
	}
}

void MidOrder(BiTree T)
{
	if(T)
	{
		
		MidOrder(T->lchild);
		printf("%3d",T->key);
		MidOrder(T->rchild);
	}
}

int lev=0;
void level(BiTree bt,int x)
{
	if(bt)
	{
		lev++;
		if(bt->key==x)return;
		else if(bt->key>x) level(bt->lchild,x);
		else level(bt->rchild,x);
	}
}

void main()
{
	BiTree T=0;
	createbsttree(&T);
	preOrder(T);printf("\n");
	MidOrder(T);printf("\n");
	level(T,78);
	printf("78 is at level %d \n",lev);
}

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

#include<stdio.h>
#include<stdlib.h>

typedef struct BiTNode
{
	int data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

void initBiTree(BiTree *BT)
{
	(*BT)=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->lchild=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->rchild=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->data=5;
	(*BT)->lchild->data=4;
	(*BT)->rchild->data=6;
	(*BT)->lchild->lchild=NULL;
	(*BT)->lchild->rchild=NULL;
	(*BT)->rchild->lchild=NULL;
	(*BT)->rchild->rchild=NULL;
}

void preOrder(BiTree T)
{
	if(T)
	{
		printf("%3d",T->data);
		preOrder(T->lchild);
		preOrder(T->rchild);
	}
}

void countnode(BiTree bt,int *count)
{
	if(bt){(*count)++;countnode(bt->lchild,&(*count));countnode(bt->rchild,&(*count));}
}

void main()
{
	int count=0;
	BiTree T;
	initBiTree(&T);
	preOrder(T);
	countnode(T,&count);
	printf("\n total node is %d\n",count);
}

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

#include<stdio.h>
#include<stdlib.h>

typedef struct BiTNode
{
	int data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

void initBiTree(BiTree *BT)
{
	(*BT)=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->lchild=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->rchild=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->data=5;
	(*BT)->lchild->data=4;
	(*BT)->rchild->data=6;
	(*BT)->lchild->lchild=NULL;
	(*BT)->lchild->rchild=NULL;
	(*BT)->rchild->lchild=NULL;
	(*BT)->rchild->rchild=NULL;
}

void preOrder(BiTree T)
{
	if(T)
	{
		printf("%3d",T->data);
		preOrder(T->lchild);
		preOrder(T->rchild);
	}
}

void sum(BiTree bt,int *s)
{
	if(bt){(*s)+=bt->data;sum(bt->lchild,&(*s));sum

(bt->rchild,&(*s));}
}

void main()
{
	int count=0;
	BiTree T;
	initBiTree(&T);
	preOrder(T);
	sum(T,&count);
	printf("\n the sum of total node is %d\n",count);
}

30.将所有奇数移到偶数之前的算法

#include<stdio.h>

void move_odd(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--;if(i<j){r[i]=r

[j];i++;}
		while(i<j && r[i]%2==1)i++;if(i<j){r[j]=r

[i];j--;}
	}
	r[i]=x;
}

void traverse_array(int a[],int n)
{
	int i;
	for(i=0;i<n;i++)
		printf("%3d",a[i]);
	printf("\n");
}

void main()
{
	int a[9]={1,2,3,4,5,6,7,8,9};
	traverse_array(a,9);
	move_odd(a,0,8);
	traverse_array(a,9);
}

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

#include<stdio.h>
#include<stdlib.h>

typedef struct node
{
	int data;
	struct node *next;
}node,*LinkList;


//头插法初始化链表
void build_node(LinkList *head,int a[],int n)
{
	int i;
	node *p;
	(*head)=(node *)malloc(sizeof(node));
	(*head)->data=a[0];
	p=(node *)malloc(sizeof(node));
	p->data=a[n-1];
	p->next=NULL;
	(*head)->next=p;
	for(i=1;i<n-1;i++)
	{
		p=(node *)malloc(sizeof(node));
		p->data=a[8-i];
		p->next=(*head)->next;
		(*head)->next=p;
	}
}

void traverse_node(node *head)
{
	node *p=head;
	while(p)
	{
		printf("%3d",p->data);
		p=p->next;
	}
	printf("\n");
}

void traverse_array(int a[],int n)
{
	int i;
	for(i=0;i<n;i++)
		printf("%3d",a[i]);
	printf("\n");
}

int isriselk(LinkList head)
{
	LinkList q,p;
	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);
}

void main()
{
	node *head,*p;
	int a[9]={1,1,2,3,4,6,6,9,11};
	build_node(&head,a,9);
	traverse_node(head);
	if(isriselk(head))printf("rise\n");else printf

("not rise \n");
}

32.将关键字序列调整为堆

#include<stdio.h>

void traverse_array(int a[],int n)
{
	int i;
	for(i=0;i<n;i++)
		printf("%3d",a[i]);
	printf("\n");
}

int isriselk(LinkList head)
{
	LinkList q,p;
	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);
}

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;
}
void main()
{

	int a[9]={1,1,9,3,4,6,6,9,2};
	traverse_array(a,9);
	adjustheap(a,9);
	traverse_array(a,9);
}

33.求树的高度的算法

#include<stdio.h>
#include<stdlib.h>

typedef struct BiTNode
{
	int data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

void initBiTree(BiTree *BT)
{
	(*BT)=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->lchild=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->rchild=(BiTree)malloc(sizeof(BiTNode));
	(*BT)->rchild->rchild=(BiTree)malloc(sizeof

(BiTNode));
	(*BT)->data=5;
	(*BT)->lchild->data=4;
	(*BT)->rchild->data=6;
	(*BT)->lchild->lchild=NULL;
	(*BT)->lchild->rchild=NULL;
	(*BT)->rchild->lchild=NULL;
	(*BT)->rchild->rchild->data=8;
	(*BT)->rchild->rchild->lchild=NULL;
	(*BT)->rchild->rchild->rchild=NULL;
}

void preOrder(BiTree T)
{
	if(T)
	{
		printf("%3d",T->data);
		preOrder(T->lchild);
		preOrder(T->rchild);
	}
}

int BtreeHeight(BiTree T)
{
	if(T==NULL) return -1; //对于空树返回-1
	else
	{
		int h1=BtreeHeight(T->lchild);
		int h2=BtreeHeight(T->rchild);
		if(h1>h2) return h1+1;
		else return h2+1;
	}
}

void main()
{
	BiTree T;
	initBiTree(&T);
	preOrder(T);
	printf("BtreeHeight is %d\n",BtreeHeight(T));
}