数据结构整理

最新推荐文章于 2024-05-16 01:48:09 发布

HHHᕙ(`▿´)ᕗ

最新推荐文章于 2024-05-16 01:48:09 发布

阅读量230

点赞数

文章标签：数据结构

本文链接：https://blog.csdn.net/QinHebtu/article/details/111224450

版权

数据结构整理

线性表的顺序存储结构

typedef struct {
	int *elem;
	int length;
	int listsize;
}SqList;
bool InitList(SqList &L);
bool ListEmpty(SqList &L);
bool ListInsert(SqList &L,int i,int e);
int ListLength(SqList &L);
bool ListDelete(SqList &L,int i,int &e);
bool GetElem(SqList &L,int i,int &t);
void PrintList(SqList &L);

#include<stdio.h>
#include"SqList.h"
#include<stdlib.h>
#define LIST_INIT_SIZE 20
#define LISTINCREMENT 10
/*
操作目的：初始化顺序表
初始条件：无
操作结果：构造一个空的线性表
函数参数：SqList &L  待初始化的线性表
返回值：bool 操作是否成功
*/
bool InitList (SqList &L)
{
	L.elem=(int *)malloc(LIST_INIT_SIZE*sizeof(int));
	if(!L.elem)
		return false;
	L.length=0;
	L.listsize=LIST_INIT_SIZE;
	return true;
}
/*
操作目的：判断顺序表是否为空 
初始条件：线性表已存在 
操作结果：若L为空表，则返回true,否则返回false 
函数参数：SqList &L  待判断的线性表
返回值：bool 是否为空 
*/
bool ListEmpty(SqList &L)
{
	if(L.length==0)
		return true;
	else
		return false;
}
 /*
操作目的：在顺序表的指定位置插入结点，插入位置i表示在第i个元素之前插入 
初始条件：线性表L已存在，l<=i<=ListLength(L)+1 
操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加一 
函数参数：SqList &L  线性表L
          int i       插入位置
		  int e       待插入的数据元素 
返回值：bool 操作是否成功 
*/
bool ListInsert(SqList &L,int i,int e)
{
	int *p,*q,*newbase;
	if(i<1||i>L.length+1)
		return false;
	if(L.length>L.listsize)
	{
		newbase=(int *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(int));
		if(!newbase)
			exit(0);
		L.elem=newbase;
		L.listsize+=LISTINCREMENT;
	}
	q=&(L.elem[i-1]);
	for(p=&(L.elem[L.length-1]);p>=q;p--)
		*(p+1)=*p;
	*q=e;
	L.length++;
	return true;
}
 /*
操作目的：求线性表的长度
初始条件：线性表L已存在
操作结果：返回线性表的长度 
函数参数：SqList &L  线性表L
返回值：int 线性表的长度 
*/
int ListLength(SqList &L)
{
	return L.length;
}
/*
操作目的：在顺序线性表L中删除第i个元素，并用e返回其值 
初始条件：线性表L已存在
操作结果：若成功删除，则返回true,否则返回false ，e返回其值 
函数参数：SqList &L  线性表L
          int i       删除元素的位置 
		  int e       存放被删除的元素 
返回值：bool 操作是否成功 
*/
bool ListDelete(SqList &L,int i,int &e)
{
	int *p,*q;
	if(i<1||i>L.length)
		return false;
	p=&(L.elem[i-1]);
	e=*p;
	q=L.elem+L.length-1;
	for(++p;p<=q;++p)
	*(p-1)=*p;
	L.length--;
	return true; 
}
/*
操作目的：取出顺序线性表L中第i个元素，并用e返回其值 
初始条件：线性表L已存在，1<=i<=Listlength(L) 
操作结果：若成功查找，则返回true,否则返回false ，e返回其值 
函数参数：SqList &L  线性表L
          int i       要取出元素的位置 
		  int e       存放取出的元素 
返回值：bool 操作是否成功 
*/
bool GetElem(SqList &L, int i, int &t)
{
	int *p;
	if(i<1||i>ListLength(L))
		return false;
	p=&(L.elem[i-1]);
	t=*p;
	return true;
}
/*
操作目的：输出线性表中的所有元素 
初始条件：线性表L已存在
操作结果：输出线性表中的所有元素 
函数参数：SqList &L  线性表L
返回值：无
*/
void PrintList(SqList &L)
{
	int *p,*q;
	q=L.elem+L.length-1;
	for(p=&(L.elem[0]);p<=q;p++)
	{
		printf("%d ",*p);
	}
	printf("\n");
}

#include<stdio.h>
#include"SqList.h"
int main()
{
	SqList l;
	if(InitList(l))
		printf("初始化成功!\n");
	if(ListEmpty)
		printf("动态顺序表为空！\n");
	else
		printf("动态顺序表不为空！\n");
	int n;
	for(int i=1;i<=5;i++)
	{
		printf("请输入第%d个元素\n",i);
		scanf("%d",&n);
		if(ListInsert(l,i,n))
			printf("第%d个元素插入成功！\n",i);
	}
	printf("线性表的长度为%d\n",ListLength(l));
	int e;
	if(ListDelete(l,3,e))
		printf("第三个元素删除成功！\n");
	else
		printf("第三个元素删除失败！\n");
	printf("线性表的长度为%d\n",ListLength(l));
	int t;
	if(GetElem(l,4,t))
		printf("第4个元素为%d\n",t);
	else
		printf("取元素失败！\n");
	printf("线性表中所有元素为:\n");
	PrintList(l);
	return 0;
 }

线性表的链式存储结构

typedef int ElemType;
typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;
bool InitList(LinkList &L);
void CreatList(LinkList &L,int n);
bool ListEmpty(LinkList L);
bool ListInsert(LinkList &L, int i, ElemType e);
void Print(LinkList L);
bool ListDelete(LinkList &L, int i, ElemType &e);
int  ListLength(LinkList L);
bool GetElem(LinkList L, int i, ElemType &e);
bool PriorElem(LinkList L, ElemType cur_e, ElemType &pre_e);
bool NextElem(LinkList L, ElemType cur_e, ElemType &nxt_e);
void ClearList(LinkList &L);

#include<stdlib.h>
#include"LinkList.h"
#include<stdio.h>
bool InitList(LinkList &L)//初始化链表
{
    L=(LNode *)malloc(sizeof(LNode));
    if(L==NULL)
        return false;
    else
    {
        L->next=NULL;
        return true;
    }
}
bool ListEmpty(LinkList L)//判空
{
    if(L->next==NULL)
        return true;
    else
        return false;
}
void CreatList(LinkList &L,int n)//创建链表
{
    L=(LinkList)malloc(sizeof(LNode));
    L->next=NULL;
    LinkList p;
    for(int i=n;i>0;i--)
    {
        p=(LinkList)malloc(sizeof(LNode));
        scanf("%d",&p->data);
        p->next=L->next;
        L->next=p;
    }
}

void Print(LinkList L)//输出
{
    LinkList p;
    p=L;
    p=p->next;
    while(p)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
}
bool ListInsert(LinkList &L, int i, ElemType e)
{
    LinkList p=L;
    int j=0;
    while(p&&j<i-1)
    {
        p=p->next;
        j++;
    }
    if(!p||j>i-1)
        return false;
    LinkList s;
    s=(LinkList)malloc(sizeof(LNode));
    s->data=e;
    s->next=p->next;
    p->next=s;
    return true;
}
bool ListDelete(LinkList &L, int i, ElemType &e)//删除第i个元素
{
    LinkList p=L,q;
    int j=0;
    while(p->next&&j<i-1)
    {
        p=p->next;
        j++;
    }
    if(!(p->next)||j>i-1)
        return false;
    q=p->next;
    p->next=q->next;
    e=q->data;
    free(q);
    return true;
}
int  ListLength(LinkList L)//链表长度
{
    int length=0;
    LinkList p=L;
	p=p->next;
    while(p)
    {
        length++;
        p=p->next;
    }
    return length;
}
bool GetElem(LinkList L, int i, ElemType &e)//取元素
{
    LinkList p=L;
    int j=0;
    while(p->next&&j<i-1)
    {
        p=p->next;
        j++;
    }
    if(!(p->next)||j>i-1)
        return false;
    p=p->next;
    e=p->data;
    return true;
}
bool PriorElem(LinkList L, ElemType cur_e, ElemType &pre_e)//找前驱
{
    LinkList p,pre;
    p=L;
    pre=p;
    p=p->next;
	if(p->data==cur_e)
		return false;
    while(p&&p->data!=cur_e)
    {
        pre=p;
        p=p->next;
    }
    if(p==NULL)
    {
        return false;
    }
    else
    {
        pre_e=pre->data;
    }
    return true;
}
bool NextElem(LinkList L, ElemType cur_e, ElemType &nxt_e)
{
    LinkList p;
    p=L;
    p=p->next;
    while(p&&p->data!=cur_e)
    {
		
        p=p->next;
		
    }
	if(p->next==NULL&&p->data==cur_e)//当它是最后一个元素的时候，没有后继元素了
			return false;
    if(p==NULL)//不然就是没有这个元素
    {
        return false;
    }
    else
    {
        nxt_e=p->next->data;
    }
    return true;
}
void ClearList(LinkList &L)//清空链表
{
	LinkList p=L,q;
	p=p->next;
	while(p)
	{
		q=p;
		p=p->next;
		free(q);
	}
	L->next=NULL;
}

#include<stdio.h>
#include"LinkList.h"
#include<stdlib.h>
int main()
{
    LinkList L;
    if(InitList(L))
        printf("初始化成功！\n");
    else
        printf("初始化失败！\n");
        
    if(ListEmpty(L))
        printf("链表为空！\n");
    else
        printf("链表不为空！\n");
        
    int n;
	printf("请输入元素个数\n");
    scanf("%d",&n);
	printf("请逆序输入%d个元素\n",n);
    CreatList(L,n);
    
    printf("当前链表存入元素为:\n");
    Print(L);
    
    int i;
    ElemType e;
  /*  printf("请输入插入位置:\n");
    scanf("%d",&i);
    printf("请输入插入元素:\n");
    scanf("%d",&e);
    if(ListInsert(L,i,e))
    {
        printf("插入成功！\n");
        printf("插入后的链表为：\n");
        Print(L);
    }
    else
        printf("插入失败！\n");
    
    printf("请输入删除元素的位置:\n");
    scanf("%d",&i);
    if(ListDelete(L,i,e))
    {
        printf("删除元素%d成功!\n",e);
        printf("当前链表元素为：\n");
        Print(L);
    }
    else
    {
        printf("元素不存在！\n");
    }
    
    
    printf("当前链表长度为：%d\n",ListLength(L));
    
    
    printf("请输入取出元素的位置：\n");
    scanf("%d",&i);
    if(GetElem(L,i,e))
    {
        printf("成功取出第%d个元素%d\n",i,e);
    }
    else
    {
        printf("元素不存在！\n");
    }
    */
    
    int cur_e,pre_e;
    printf("请输入当前元素:\n");
    scanf("%d",&cur_e);
    
    if(PriorElem(L,cur_e,pre_e))
    {
        printf("%d前的元素为%d\n",cur_e,pre_e);
    }
    else
    {
        printf("不存在%d这个元素，或此元素前无元素\n",cur_e);
    }
    
    int nxt_e;
    printf("请输入当前元素:\n");
    scanf("%d",&cur_e);
    if(NextElem(L,cur_e,nxt_e))
    {
        printf("%d后的元素为%d\n",cur_e,nxt_e);
    }
    else
    {
        printf("不存在%d这个元素,或此元素无后继元素\n",cur_e);
    }
    
	ClearList(L);
	 printf("当前链表长度为：%d\n",ListLength(L));
	Print(L);
    return 0;
}

栈的顺序存储结构

#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef char SElemType;
typedef struct{
	SElemType *base;
	SElemType *top;
	int stacksize;
}SqStack;
bool InitStack(SqStack &S);//初始化空栈
bool Push(SqStack &S,SElemType e);//入栈
//bool GetTop(SqStack S, SElemType &e);//取栈顶元素
bool Pop(SqStack &S,SElemType &e);//弹出

bool StackEmpty(SqStack S);//判空
int StackLength(SqStack S);//栈的长度
bool ClearStack(SqStack &S);//清空
bool DestoryStack(SqStack &S);//销毁
bool visit(SElemType e);//输出元素
void StackTraverse(SqStack &S);//遍历栈
void conversion(int n,int d);//数制转换
bool judge(char ss[]);//括号匹配

int EvaluateExpression();//表达式求值
char GetTop(SqStack S);//用于表达式求值的取栈顶元素
bool In(char c);//判断是否为运算符
int ops(char c);//转换运算符
char Precede(char a,char b);//比较a,b两个运算符
char Operate(char a,char theta,char b);//进行操作

#include"Stack.h"
#include<stdlib.h>
#include<stdio.h>
#include<string.h>
typedef char SElemtype;
int EvaluateExpression()
{
    SqStack optr;//运算符栈
    SqStack opnd;//运算数栈
    InitStack(optr);//初始化运算符栈 
    Push(optr,'#');//运算符栈压入#号 
    InitStack(opnd);//初始化运算数栈 
    char c,a,b,theta,x; 
    c=getchar();//开始读入 
    while(c!='#'||GetTop(optr)!='#')//没有读到#号或者栈顶元素不是#的时候 
    {
        if(!In(c))//如果不是运算符就入运算数的栈
        {
            Push(opnd,c);
            c=getchar();//继续读入下一个字符 
        }
        else
            switch (Precede(GetTop(optr),c))//是运算符，就比较一下这个运算符和当前栈顶的运算符的优先级 
            {
            case '<'://读入字符优先级高 
                Push(optr,c);//入栈，继续读入 
                c=getchar();
                break;
            case '='://优先级一样 
                Pop(optr,x);
                c=getchar();
                break;
            case '>'://读入字符优先级低 
                Pop(optr,theta);
                Pop(opnd,b);
                Pop(opnd,a);
                Push(opnd,Operate(a,theta,b));//运算后的数入栈 
                break;
            }
    }
    return GetTop(opnd)-'0';
}


char GetTop(SqStack S)
{
    if(S.top!=S.base)
        return *(S.top-1);
}

bool In(char c)//判断是否为操作符
{
    if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='#')
        return true;
    else
        return false;
}



int ops(char c)//把操作符转换为数字
{
    if(c=='+')
        return 0;
    if(c=='-')
        return 1;
    if(c=='*')
        return 2;
    if(c=='/')
        return 3;
    if(c=='(')
        return 4;
    if(c==')')
        return 5;
    if(c=='#')
        return 6;
}
char Precede(char a,char b)//比较运算符的优先级
{
    char cmp[8][8]={">><<<>>",">><<<>>",">>>><>>",">>>><>>","<<<<<= ",">>>> >>","<<<<< ="};
    int i=ops(a);
    int j=ops(b);
    return cmp[i][j];
}


char Operate(char a,char theta,char b)//各种操作 
{
	
    a-='0';
    b-='0';
    switch (theta)
    {
    case '+':
        return a+b+'0';
    case '-':
        return a-b+'0';
    case '*':
        return a*b+'0';
    case '/':
        return a/b+'0';
    }
}




bool InitStack(SqStack &S)//初始化
{
	S.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
	if(!S.base)
		return false;
	S.top=S.base;
	S.stacksize = STACK_INIT_SIZE;
	return true;
}


int StackLength(SqStack S)//栈的长度
{
    return S.top-S.base;
}




/*



void conversion(int N,int d)
{
    SqStack S;
    InitStack(S);
    while(N)
    {
        Push(S,N%d);
        N=N/d;
    }
    int e;
    while(!StackEmpty(S))
    {
        Pop(S,e);
        printf("%d",e);
    }
}


*/







bool Push(SqStack &S,SElemType e)//入栈
{
	if(S.top-S.base>=S.stacksize)
	{
		S.base=(SElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));
		if(!S.base)
			return false;
		S.top=S.base+S.stacksize;
		S.stacksize+=STACKINCREMENT;
	}
	*S.top=e;
	S.top++;
	return true;
}

bool Pop(SqStack &S,SElemType &e)//出栈
{
	if(S.top==S.base)
        return false;
    S.top--;
    e=*S.top;
    return true;
}

bool StackEmpty(SqStack S)//判空
{
    if(S.top==S.base)
        return true;
    else
        return false;
}


bool ClearStack(SqStack &S)//清空栈
{
    while(!StackEmpty(S))
    {
        S.top--;
    }
    return true;
}

bool DestoryStack(SqStack &S)//销毁栈
{
    while(!StackEmpty(S))
    {
        S.top--;
    }
    S.stacksize=0;
    S.top=S.base=NULL;
    return true;
}


bool visit(SElemType e)//输出元素
{
    printf("%d ",e);
    return true;
}

void StackTraverse(SqStack &S)
{
    if(StackEmpty(S))
    {
        printf("栈为空！\n");
        return;
    }
    while(!StackEmpty(S))
    {
        visit(*(--S.top));
    }
    printf("\n");
}

#include<stdio.h>
#include"Stack.h"

int main()
{
    printf("请输入一个表达式，并以#结束\n");
    printf("表达式的结果为:%d\n",EvaluateExpression());
    return 0;
}














/*
int main()
{
    int n,d;
    printf("请输入一个十进制数和转换的数制：\n");
    scanf("%d%d",&n,&d);
	printf("十进制数%d转换为%d进制数为",n,d);
	conversion(n,d);
	printf("\n");
    return 0;
}






























int main()
{
	SqStack S;
	int e;
	if(InitStack(S))
		printf("初始化成功!\n");
	else
		printf("初始化失败！\n");





     int n;
    printf("请输入元素的个数：");
    scanf("%d",&n);
    printf("请输入%d个元素\n",n);
    while(n--)
    {
        scanf("%d",&e);
        if(Push(S,e))
			printf("%d成功入栈！\n",e);
		else
			printf("入栈失败！\n");
    }

    printf("当前栈的长度为%d\n",StackLength(S));



	if(GetTop(S,e))
		printf("栈顶元素为%d\n",e);
	else
		printf("栈为空！\n");








    if(Pop(S,e))
    {
        printf("栈顶元素%d成功删除！\n",e);
    }
    else
        printf("栈顶无元素！\n");










    if(StackEmpty(S))
    {
        printf("栈为空！\n");
    }
    else
        printf("栈不为空！\n");
	
	printf("栈中当前元素为：\n");
	StackTraverse(S);




	if(ClearStack(S))
		printf("栈清除成功！\n");
	printf("当前栈的长度为%d\n",StackLength(S));

	
	
	if(DestoryStack(S))
		printf("栈销毁成功！\n");


	return 0;

}
*/

队列的基本操作

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef int QElemType; 
typedef struct QNode{
	QElemType data;
	struct QNode *next;
}QNode ,*QueuePtr;//定义队列节点
typedef struct{
	QueuePtr front;//队头指针
	QueuePtr rear;//队尾指针 
}LinkQueue;
bool InitQueue(LinkQueue &Q)//构造空队列
{
	Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));//分配内存空间 
	if(!Q.front)//分配失败 
		return false;
	Q.front->next=NULL;//下一个结点为空 
	return true; 
 } 
 bool DestoryQueue(LinkQueue &Q)//销毁队列 
 {
 	while(Q.front)
 	{
 		Q.rear=Q.front->next;//队尾指针指向队头指针的下一个 
 		free(Q.front);//删除队头指针 
 		Q.front=Q.rear;//队头指针指向下一个 
	 }
	 return true; 
 }
 
 bool ClearQueue(LinkQueue &Q)//清空队列 
 {
 	QueuePtr p,q;//两个指针来存队头和下一个 
	p=Q.front->next;
	Q.front->next=NULL; //处理队头 
	while(p) 
	{
		q=p->next;
		free(p);
		p=q;
	}
	Q.rear=Q.front;//处理队尾 
	return true; 
 }
 
 bool QueueEmpty(LinkQueue Q)//判空 
 {
 	if(Q.front->next==NULL) 
 		return true;
 	else
 		return false;
 	
 }
 
 int QueueLength(LinkQueue Q)//求队列长度 
 {
 	int cnt=0;
 	QueuePtr p=Q.front->next;
 	while(p)
	 {
	 	cnt++;
	 	p=p->next;
	  } 
	  return cnt;
 }
 
 bool GetHead(LinkQueue Q,QElemType &e)//取队头元素
 {
 	if(Q.front==Q.rear)
 		return false;
 	e=Q.front->next->data;
	 return true; 
 } 
 
 
 bool EnQueue(LinkQueue &Q,QElemType e)//插入，在队尾插入e 
 {
 	QueuePtr p;
 	p=(QueuePtr)malloc(sizeof(QNode));//分配内存
	if(!p)//失败
	 	return false;
	 p->data=e;//赋值元素
	 p->next=NULL;//指向下一个
	 Q.rear->next=p;//接入队尾
	 Q.rear=p;//尾指针指向队尾 
	 return true;
 }
 
 bool DeQueue(LinkQueue &Q,QElemType &e)//如果队列不空，就删除队头元素，用e返回其值 
 {
 	QueuePtr p;
 	if(Q.front==Q.rear)//队为空 
 		return false;
 	p=Q.front->next;//队头元素
	e=p->data; 
 	Q.front->next=p->next;//删除节点和队头连接 
 	if(Q.rear==p)
 		Q.rear=Q.front;
 	free(p);
 	return true;
  } 
  
void visit(QElemType e)
{
	printf("%d ", e);
	//printf("%c ",e);
}

bool QueueTraverse(LinkQueue Q) 
{
	
	if(QueueEmpty(Q))
	{
		printf("队列为空!\n");
		return false;
	 } 
	QueuePtr p;
	p=Q.front->next;
	while(p)
	{
		visit(p->data);
		p=p->next;
	}
	printf("\n");
	return true;
}
int main()
{
	LinkQueue Q;
	if(InitQueue(Q))//初始化队列
		printf("初始化成功！\n");
	else
		printf("初始化失败！\n");
		
	if(QueueEmpty(Q))
		printf("当前队列为空！\n");
	else
		printf("当前队列不为空！\n");
	
	printf("请输入入队数据的个数：\n");
	int len;
	scanf("%d",&len); 
	int a[100];
	QElemType e;
	printf("请输入这些数据：\n");
	for(int i=0;i<len;i++)
	{
		scanf("%d",&a[i]);
		EnQueue(Q,a[i]);//入队操作 
	 } 
	 
	 printf("此时队列长度为：%d\n",QueueLength(Q));
	 
	 if(GetHead(Q,e))
	 	printf("队头元素为：%d\n",e);
	else
		printf("队列为空！\n");
		
	if(DeQueue(Q,e))
		printf("队头元素%d删除成功！\n",e);
	else
		printf("队列为空！\n");
	
	printf("当前队列：\n");
	QueueTraverse(Q);
	 
	ClearQueue(Q);
	 
	DestoryQueue(Q);
	return 0;
}

循环队列的基本操作

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAXQSIZE 100
typedef int QElemType; 
typedef struct{
	QElemType *base;//初始化的动态分配内存空间 
	int front;//头指针，若队列不为空，指向队列头元素 
	int rear;//尾指针，若队列不空，指向队尾元素的下一个位置 
}SqQueue;//循环队列的顺序存储结构 
bool InitQueue(SqQueue &Q)//初始化 
{
	Q.base=(QElemType *)malloc(MAXQSIZE * sizeof(QElemType));//分配内存空间
	if(!Q.base)//分配失败
		return false;
	Q.front=Q.rear=0;//初始头尾指针都指向0 
	return true;
}
int QueueLength(SqQueue Q)//求长度 
{
	return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;
}
bool EnQueue(SqQueue &Q,QElemType e)//在队尾插入 
{
	if((Q.rear+1)%MAXQSIZE==Q.front)//循环队列满了 
		return false;
	Q.base[Q.rear]=e;
	Q.rear=(Q.rear+1)%MAXQSIZE;//指向下一个
	return true; 
}
bool DeQueue(SqQueue &Q,QElemType &e)//在队头删除 
{
	if(Q.front==Q.rear)
		return false;
	e=Q.base[Q.front];//存一下要删除的数
	Q.front = (Q.front+1)%MAXQSIZE;
	return true; 
}
 bool QueueEmpty(SqQueue Q)//判空 
 {
 	if(Q.rear==Q.front) 
 		return true;
 	else
 		return false;
 }
 
  bool GetHead(SqQueue Q,QElemType &e)//取队头元素
 {
 	if(Q.front==Q.rear)
 		return false;
 	e=Q.base[Q.front];
	 return true; 
 } 
 
 bool ClearQueue(SqQueue &Q)//清空队列 
 {
 	Q.front=Q.rear=0; 
 	return true;
 }
 
 bool DestoryQueue(SqQueue &Q) //销毁队列 
 {
 	free(Q.base);
 	Q.front=0;
 	Q.rear=0;
 	return true;
 }
 
 void visit(QElemType e)
 {
 	printf("%d ",e);
 }
 bool QueueTraverse(SqQueue Q)
 {
 	if(QueueEmpty(Q))
 	{
 		printf("队列为空！\n");
 		return false;
	 }
 	int i=Q.front;
 	while(i!=Q.rear)
 	{
 		visit(Q.base[i]);
 		i=(i+1)%MAXQSIZE;
	 }
	 printf("\n");
	 return true;
 }
 
 int main()
{
	SqQueue Q;
	if(InitQueue(Q))//初始化队列
		printf("初始化成功！\n");
	else
		printf("初始化失败！\n");
		
	if(QueueEmpty(Q))
		printf("当前队列为空！\n");
	else
		printf("当前队列不为空！\n");
	
	printf("请输入入队数据的个数：\n");
	int len;
	scanf("%d",&len); 
	int a[100];
	QElemType e;
	printf("请输入这些数据：\n");
	for(int i=0;i<len;i++)
	{
		scanf("%d",&a[i]);
		
	 } 
	 for(int i=0;i<len;i++)
	 {
	 	if(EnQueue(Q,a[i]))
	 		printf("元素%d成功入队！\n",a[i]);
		else
			printf("入队失败！\n"); 
	 }
	 printf("当前队列：\n");
	 QueueTraverse(Q);
	 printf("此时队列长度为：%d\n",QueueLength(Q));
	 
	 if(GetHead(Q,e))
	 	printf("队头元素为：%d\n",e);
	else
		printf("队列为空！\n");
		
	if(DeQueue(Q,e))
		printf("队头元素%d删除成功！\n",e);
	else
		printf("队列为空！\n");
	
	printf("当前队列：\n");
	QueueTraverse(Q);
	 
	ClearQueue(Q);
	 
	DestoryQueue(Q);
	return 0;
}

串

串的基本操作

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct{
	char *ch;//若是非空串，则按串长分配存储区，否则ch为NULL 
	int length;//串的长度 
}HString;
bool StrInit(HString &T)
{
	T.ch=NULL;
	T.length=0;
	return true;
}
bool StrAssign(HString &T,char *chars)//生成一个其值等于串常量chars的串T 
{
	if(T.ch)  //释放T原有空间 
		free(T.ch);
	char *c;//一个指针 
	int i; 
	for(i=0,c=chars;*c;i++,c++);//求chars的长度,i的值即为串的长度 
	if(!i)//如果串为空串 
	{
		T.ch=NULL;//新串也为空串 
		T.length=0;
	}
	else
	{
		if(!(T.ch=(char *)malloc(i*sizeof(char))))//分配内存空间 
			return false;
		for(int j=0;j<=i-1;j++)
		{
			T.ch[j]=chars[j];//赋值 
		}
		T.length=i;//长度 
	}
	return true;
}

bool StrInsert(HString &S,int pos,HString T)//在串的第pos个字符前插入串T 
{
	if(pos<1||pos>S.length+1)//输入位置不合法 1<=pos<=Strlength(S)+1 
		return false;
	if(T.length)//串T非空 ，重新分配空间 
	{
		if(!(S.ch=(char *)realloc(S.ch,(S.length+T.length)*sizeof(char))))
			return false;
		for(int i=S.length-1;i>=pos-1;i--)//S串后面的元素后移，从S串最后一个元素后移的，直到第pos个元素的位置pos-1 
			S.ch[i+T.length]=S.ch[i]; 
		for(int i=pos-1,j=0;j<T.length;i++,j++)//把串T插入到S串中 
		{
			S.ch[i]=T.ch[j];//i>=pos-1,i<=pos+T.length-2    0<=j<=T.length-1
		}
		S.length+=T.length;//更改串的长度 
	}
	return true;
}

bool SubString (HString &Sub,HString S,int pos,int len)//用sub返回串第pos个字符起始长度为len的子串 
{
	if(pos<1||pos>S.length||len<0||len>S.length-pos+1)//1<=pos<=Strlenth(S)且0<=len<=Strlength(S)-pos+1 
		return false;
	if(Sub.ch)//释放旧空间 
		free(Sub.ch);
	if(!len)//空子串 
	{
		Sub.ch=NULL;//直接为空 
		Sub.length=0;
	}
	else
	{
		Sub.ch=(char *)malloc(len*sizeof(char));//为子串分配空间 
		for(int i=0,p=pos-1;i<len;i++,p++)//复制过去 
		{
			Sub.ch[i]=S.ch[p];
		}
		Sub.length=len;//长度 
	}
	return true;
}
bool StrDelete(HString &S,int pos,int len)//从串S中删除长度为Len的子串 
{
	if(pos<1||pos+len>S.length||len<0)
		return false;
	for(int i=pos-1;i<S.length-len;i++)
	{
		S.ch[i]=S.ch[i+len];
	}
	S.length-=len;
	return true;
}
bool Concat(HString &T,HString S1,HString S2)//用T返回由S1和S2联接成的新串 
{
	if(T.ch)//释放旧空间 
		free(T.ch);
	if(!(T.ch=(char *)malloc((S1.length+S2.length)*sizeof(char))))//重新分配空间 
		return false;
	for(int i=0;i<S1.length;i++)//串1复制过去 
	{
		T.ch[i]=S1.ch[i];
	}
	T.length=S1.length+S2.length;//新串的长度 
	for(int i=S1.length,j=0;i<T.length;i++,j++)//串2复制过去 
	{
		T.ch[i]=S2.ch[j];
	}
	return true;
}
int StrCompare(HString S,HString T)//两个字符串比较 
{
	for(int i=0;i<S.length&&i<T.length;i++)
	{
		if(S.ch[i]!=T.ch[i])//两个字符串不相等 
			return S.ch[i]-T.ch[i]; 
	}
	return S.length-T.length;//只有两个字符串相等的时候，才会是0,不然还是不相等 
}
void Print(HString S)
{
	for(int i=0;i<S.length;i++)
		printf("%c",S.ch[i]);
	printf("\n");
}
int Index(HString S,HString T,int pos)//定位函数，返回子串T在主串S中第pos个字符之后的位置，不存在返回0 
{
	int i=pos-1;
 	int j=0;
    while(i<S.length&&j<T.length)
 	{
 	 	if(S.ch[i]==T.ch[j])
 	 	{
 	 		i++;
 	 		j++;//继续比较后面的字符 
	     }
  		else//不相等，子串从头开始 
 		{
  			i=i-j+1;//主串相比之前加一
 		 	j=0;
 		 }
    }
  	if(j==T.length) 
  		return i-T.length+1; 
  	else
  		return 0;
}
int main()
{
	HString S1;
	StrInit(S1);
	char  a[9]="abcdefgh";
	StrAssign(S1,a);//赋值 
	printf("当前串为:");
	Print(S1);
	HString A;
	StrInit(A);
	SubString(A,S1,2,3);//从串第2个位置取长度为3的子串并输出
	printf("串的第二个位置长度为3的子串为："); 
	Print(A);
	
	HString B;
	StrInit(B);
	char b[4]="cde";
	StrAssign(B,b);
	int pos=Index(S1,B,1);
	printf("子串%s的位置是%d\n",b,pos);
	
	char c[3]="ef";
	printf("删除子串%s后，字符串为：",c); 
	StrDelete(S1,5,2);
	Print(S1);
	
	HString S2,S3;
	StrInit(S2);
	StrInit(S3);
	char d[4]="123";
	char e[4]="456";
	StrAssign(S2,d);
	printf("串2为：");
	Print(S2);

	StrAssign(S3,e);
	printf("串3为：");
	Print(S3);
	
	int ans=StrCompare(S2,S3);
	if(ans>0)
		printf("串2大于串3\n");
	else if(ans<0)
		printf("串2小于串3\n");
	else
		printf("串2等于串3\n");
	HString T;
	StrInit(T);
	Concat(T,S2,S3);
	printf("将串2和串3连接为："); 
	Print(T);
	return 0;
}

串的朴素匹配算法

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int Index(char s[],char t[],int pos)//返回子串T在主串S中第pos个字符之后的位置，不存在返回0 
{
	int i=pos-1;
 	int j=0;
    while(s[i]!='\0'&&t[j]!='\0')
 	{
 	 	if(s[i]==t[j])
 	 	{
 	 		i++;
 	 		j++;//继续比较后面的字符 
	     }
  		else//不相等，子串从头开始 
 		{
  			i=i-j+1;//主串相比之前加一
 		 	j=0;
 		 }
    }
  	if(t[j]=='\0') 
  		return i-j+1; //包含子串，输出位置 
  	else
  		return 0;//不包含子串 
}
int main()
{
	char s[100],t[100];
	printf("请输入主串：");
	gets(s);
	printf("请输入子串："); 
	gets(t);
	int pos;
	printf("请输入匹配的起始位置：");
	scanf("%d",&pos); 
	int a=Index(s,t,pos);
	if(a==0)
		printf("主串%s不包含子串%s",s,t);
	else
		printf("主串%s包含子串%s",s,t);
	return 0;
 }

KMP

#include<stdio.h>
#include<string.h>
#define MAXSTRLEN 255
typedef  char SString[MAXSTRLEN+1];
int next[MAXSTRLEN+1];
int Index_KMP(SString S,SString T,int pos)
{
	int i=pos,j=1;
	while(i<=S[0]&&j<=T[0])
	{
		if(j==0||S[i]==T[j])
		{
			i++;
			j++;
		}
		else
			j=next[j];
	}
	if(j>T[0])
		return i-T[0];
	else 
		return 0;
}
void get_next(SString T,int next[])
{
	int j=1,k=0;
	next[1]=0;
	while(j<T[0])
	{
		if(k==0||T[j]==T[k])
		{
			j++;
			k++;
			next[j]=k;
		}
		else
			k=next[k];
	}
}
int main()
{
	SString S,T;
	printf("请输入主串：\n");
	gets(S+1);
	*S=strlen(S+1);
	printf("请输入子串：\n");
	gets(T+1);
	*T=strlen(T+1);
	printf("请输入开始匹配的位置:\n");
	int pos;
	scanf("%d",&pos); 
	pos=Index_KMP(S,T,pos);
	printf("子串的位置：%d\n",pos);
	return 0;
}

数组和稀疏矩阵

数组

#include<stdio.h>
#include<stdlib.h>
#include<stdarg.h>
#define MAX_ARRAY_DIM 8//设数组最大维度为8
typedef int ElemType;
typedef struct {
	ElemType *base;//数组元素基址，由InitArray分配 
	int dim;//数组维度 
	int *bounds;//数组维界基址，由InitArray分配 
	int *constants;//数组映像函数常量基址，由InitArray分配 
}Array;

bool InitArray(Array &A,int dim,...)//省略号为int型的各维界长度
{
	int elemtotal,i; 
	if(dim<1||dim>MAX_ARRAY_DIM)
		return false;
	A.dim=dim;
	A.bounds=(int *)malloc(dim*sizeof(int));//分配内存 
	if(!A.bounds)
		exit(0);
	//若各位长度合法，则存入A.bounds,并求出A的元素总数elemtotal 
	elemtotal = 1;
	va_list ap;
	va_start(ap,dim);//ap为va.list类型，是存放变长参数信息的数组
	for(i=0;i<dim;i++)
	{
		A.bounds[i]=va_arg(ap,int);
		if(A.bounds[i]<0)
			return false;
		elemtotal *=A.bounds[i];
	 } 
	 va_end(ap);
	 A.base=(ElemType *)malloc(elemtotal*sizeof(ElemType));
	 if(!A.base)
	 	exit(0);
	A.constants=(int *)malloc(dim * sizeof(int));
	if(!A.constants)
		exit(0);
	
	A.constants[dim-1]=1;
	for(i=dim-2;i>=0;i--)
		A.constants[i]=A.bounds[i+1]*A.constants[i+1];
	return true;
 } 
 bool Locate(Array A,va_list ap,int &off)
 {
 	//若ap指示的各下标值合法，则求出该元素在A中相对地址off 
 	off=0;
 	for(int i=0;i<A.dim;i++)
 	{
 		int ind=va_arg(ap,int);
 		if(ind<0||ind>=A.bounds[i])
 			return false;
 		off+=A.constants[i]*ind;
	 }
	 return true;
 }
 bool Assign(Array &A,ElemType e, ...)
 {
    //A是n维数组，e为元素变量，随后是n个下标值
    //若各维下标不超界，则把e赋给所指定的A的元素，并返回OK
 	int result;
 	va_list ap;
 	va_start(ap,e);
 	int off;
 	if((result=Locate(A,ap,off))<=0)
 		return result;
 	*(A.base+off)=e;
 	return true;
 }
bool Value(Array A,ElemType &e, ...)
{    //A是n维数组，e为元素变量，随后是n个下标值
    //若各维下标不超界，则e赋值为所指定的A的下标值，并返回OK
	va_list ap;
	bool result;
	va_start(ap,e);
	int off;
	if((result = Locate(A,ap,off))<=0)
		return result;
	e=*(A.base+off);
	return true;
 } 
int main()
{
	Array A;
	InitArray(A,3,2,3,4);
	for(int i=0;i<2;i++)
	{
		for(int j=0;j<3;j++)
		{
			for(int k=0;k<4;k++)
			{
				Assign(A,i+j+k,i,j,k);
				int value; 
				Value(A,value,i,j,k);
				printf("a[%d][%d][%d]=%d\n",i,j,k,value);
			}
		}
	}
	return 0;
}

稀疏矩阵

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 12500
typedef int ElemType;
typedef struct
{
	int i,j;//非零元行下标和列下标 
	ElemType e;//数据 
 }Triple;
 
 typedef struct
 {
 	Triple data[MAXSIZE+1];//非零元三元组表，data[0]未使用 
 	int mu,nu,tu;//行数，列数，非零元个数 
  }TSMatrix;//三元组
  //初始化
  bool InitTSMatrix(TSMatrix &M)
  {
  	int m,n,t;
  	printf("请输入矩阵的行数，列数和非零元的个数：\n");
  	scanf("%d%d%d",&m,&n,&t);
  	printf("请输入非零元素所在的行、列值、以及此非零元素\n"); 
  	if(t>MAXSIZE||m<0||n<0)
  		return false;
	for(int k=1;k<=t;k++)//从第一个开始的 
	{
		scanf("%d%d%d",&M.data[k].i,&M.data[k].j,&M.data[k].e);
	}
	M.mu=m;
	M.nu=n;
	M.tu=t;
	return true;
   } 
   //快速转置
bool FastTransposeSMartix(TSMatrix M,TSMatrix &T) //T存放转置后的矩阵
{
	T.mu=M.nu;//行列互换 
	T.nu=M.mu;
	T.tu=M.tu;//非零元数量 
	int num[M.nu+1],cpot[M.nu+1];
	if(T.tu)
	{
		int col;
		for(col=1;col<=M.nu;col++)
			num[col]=0;//num数组记录M每一列非零元出现的次数 
		for(int t=1;t<=M.tu;t++)
			num[M.data[t].j]++;//记录M中每一列的元素个数 
		cpot[1]=1;//第一行元素起始下标为1 
		for(col=2;col<=M.nu;col++)//cpot数组记录T中每一行起始元素下标
			cpot[col]=cpot[col-1]+num[col-1];
		for(int p=1;p<=M.tu;p++)//逐个移入矩阵T中 
		{
			col=M.data[p].j;
			int q=cpot[col];
			T.data[q].i=M.data[p].j;
			T.data[q].j=M.data[p].i;
			T.data[q].e=M.data[p].e;
			cpot[col]++;
		}	
	}
	return true;
 } 
 int main()
 {
 	TSMatrix M,T;
 	InitTSMatrix(M);
 	FastTransposeSMartix(M,T);
 	printf("转置后的矩阵为：\n");
 	printf("%5d%5d%5d\n",T.mu,T.nu,T.tu);
 	for(int k=1;k<=T.tu;k++)
 	{
 		printf("%5d%5d%5d\n",T.data[k].i,T.data[k].j,T.data[k].e);
	 }
  }

树

二叉树

#include<stdio.h>
#include<stdlib.h>
typedef char TElemType;
typedef struct BiTNode
{
	TElemType data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
bool InitBiTree(BiTree &T)//初始化二叉树 
{
	T=NULL; 
	return true;
}
bool BiTreeEmpty(BiTree T) //树判空
{
	if(T==NULL)
		return true;
	return false;
 } 
int TreeSize(BiTree T)//二叉树总结点数 
{
	if(T==NULL)
		return 0;
	if(T->lchild==NULL&&T->rchild==NULL)
		return 1;
	return 1+TreeSize(T->lchild)+TreeSize(T->rchild);
}
void PrintTreeLeaf(BiTree T)//输出所有叶子结点 
{
	if(T)
	{
		if(T->lchild==NULL&&T->rchild==NULL)
		{
			printf("%c",T->data);
		}
		PrintTreeLeaf(T->lchild);
		PrintTreeLeaf(T->rchild);
	}
}
int TreeDepth(BiTree T)//求树的深度 
{
	if(T==NULL)
	{
		return 0;
	}
	if(T->lchild==NULL&&T->rchild==NULL)
	{
		return 1;
	}
	int dl=TreeDepth(T->lchild);//左子树的高度 
	int dr=TreeDepth(T->rchild);//右子树的高度 
	return 1+(dl>dr? dl:dr); 
}
bool CreateBiTree(BiTree &T)
{
	char ch;
	scanf(" %c",&ch);
	if(ch=='@')
		T=NULL;
	else
	{
		if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))
			exit(0);
		T->data=ch;//生成根节点
		CreateBiTree(T->lchild);//构造左子树 
		CreateBiTree(T->rchild);//构造右子树 
	}
	return true;
}
bool Visit(TElemType e)
{
	printf("%c",e);
	return true;
 } 
bool PreOrderTraverse(BiTree T)//先序遍历递归算法 
{
	if(T)
	{
		if(Visit(T->data))
		{
			if(PreOrderTraverse(T->lchild))
			{
				if(PreOrderTraverse(T->rchild))
					return true;
			}
		}
		return false;
	}
	else
		return true;
 } 

 bool InOrderTraverse(BiTree T)//中序遍历递归算法
 {
 	if(T)
 	{
 		if(InOrderTraverse(T->lchild))
 		{
 			if(Visit(T->data))
 			{
 				if(InOrderTraverse(T->rchild))
					return true;
			 }
			 return false;
		 }
		 return false;
	 }
	 else 
	 	return true;
 } 
 bool PostOrderTraverse(BiTree T) //后序遍历递归算法
 {
 	if(T)
 	{
 		if(PostOrderTraverse(T->lchild))
 		{
 			if(PostOrderTraverse(T->rchild))
 			{
 				if(Visit(T->data))
 					return true;
 				else
 					return false;
			 }
		 }
	 }
	 else
	 	return true;
 }
int main()
{
	BiTree T;
	InitBiTree(T);//初始化
	if(BiTreeEmpty(T))
		printf("树为空！\n");
	else
		printf("树不为空！\n");
	printf("先序创建二叉树：\n");
	CreateBiTree(T);
	printf("二叉树的深度为：%d\n",TreeDepth(T));
	printf("二叉树总结点个数为：%d\n",TreeSize(T));
	printf("二叉树叶子结点为：\n");
	PrintTreeLeaf(T);
	printf("\n");
	printf("二叉树的先序遍历序列为:\n");
	PreOrderTraverse(T);
	printf("\n");
	
	printf("二叉树的中序遍历序列为:\n");
	InOrderTraverse(T);
	printf("\n");
	printf("二叉树的后序遍历序列为:\n");
	PostOrderTraverse(T); 
	printf("\n");
}

哈夫曼树

#include<stdio.h>
#include<stdlib.h> 
#include<string.h> 
typedef struct
{
    unsigned int weight;
    unsigned int parent,lchild,rchild;
}HTNode,*HuffmanTree;//动态分配数组存储哈夫曼树 
typedef char * * HuffmanCode;//动态分配数组存储哈夫曼编码表 
void Select(HuffmanTree HT,int n,int &s1,int&s2)  //选择函数，选出两个权值最小的结点 
{ 
    int min=99999998,max=99999999; 
    s1=s2=0; 
    for(int i=1; i<=n;i++) 
    { 
        if(HT[i].parent==0) 
        { 
           if(HT[i].weight<min) //找到小的，就更新 
           { 
               min=HT[i].weight;
			   s1=i;               
		    } 
       } 
    } 
    int t=HT[s1].weight; //存一下 
    HT[s1].weight=max; //换成一个最大数 
    min=99999998; //继续找最小值 ，第二小的 
    for(int i=1; i<=n; i++) 
    { 
        if(HT[i].parent==0) 
        { 
            if(HT[i].weight<min) //更新 
            { 
                min=HT[i].weight; 
                s2=i; 
            } 
        } 
    } 
    HT[s1].weight=t; 
} 
void HuffmanCoding(HuffmanTree &HT,HuffmanCode &HC,int*w,int n)
{
	//w存n个字符的权值，构造哈夫曼树HT，并求n个字符的哈夫曼编码HC 
    if(n<=1)
		return;
    int m=2*n-1;
    HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));//0号单元未用 
    int i;
    for(i=1;i<=n;i++)//初始化 
    {
       HT[i].weight=w[i];
       HT[i].parent=HT[i].rchild=HT[i].lchild=0;
    }
    for(;i<=m;i++)
    {
       HT[i].weight=HT[i].parent=HT[i].rchild=HT[i].lchild=0;
    }
    int s1=0,s2=0;
    for(i=n+1;i<=m;i++)//构造哈夫曼树 
    {//在HT[1...i-1]选择parent为0且weight最小的两个结点，序号为s1,s2 
       Select(HT,i-1,s1,s2);
       HT[s1].parent=i;
	   HT[s2].parent=i;
       HT[i].lchild=s1;
	   HT[i].rchild=s2;
       HT[i].weight=HT[s1].weight+HT[s2].weight;//权值 
    }
    HC=(HuffmanCode)malloc((n+1)*sizeof(char*));//分配n个字符编码的头指针向量 
    char *cd;
    cd=(char *)malloc(n*sizeof(char));//分配求编码的工作空间 
    cd[n-1]='\0';//编码结束符 
    
    //从叶子到根逆序求每个字符的哈夫曼编码 
    int start;
    for(i=1;i<=n;++i)//逐个字符求哈夫曼编码 
    {
       start=n-1;//编码结束符位置 
       int c=0;
	   int f=0;
       for(c=i,f=HT[i].parent;f!=0;c=f,f=HT[f].parent)//从叶子到根逆向求编码 
       {
           if(HT[f].lchild==c)
               cd[--start]='0';
           else
              cd[--start]='1';
       }
       HC[i]=(char*)malloc((n-start)*sizeof(char));
       strcpy(HC[i],&cd[start]);//从cd复制编码（串）到HC 
    }
    free(cd);
}
int main()
{
    HuffmanTree HT;
    HuffmanCode HC;
    char c[100];
    int n,i;
    printf("请输入结点数目:\n");
    scanf("%d",&n);
    int a[100];
    int *w;
    w=a;
    printf("输入%d个结点的权值: \n",n);
    for(i=1;i<=n;i++)
    {
       printf("输入第%d结点的名称以及权值:",i);
       scanf(" %c %d",&c[i],&a[i]);
    }
    w=a;
    HuffmanCoding(HT,HC,w,n);
    printf("哈夫曼编码的输出:\n");
    for(i=1;i<=n;i++)
    {
       printf("%c:%s",c[i],HC[i]);
       printf("\n");
    }
    return 0;
}

图的基本操作和prim算法最小生成树

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define INFINITY INT_MAX //最大值 
#define MAX_VERTEX_NUM 20//最大顶点数
#define VRType int
#define IofoType int
#define VertexType int

#define Boolean bool
#define Max   100 
#define Status int
Boolean visited[Max];//访问标志数组 

typedef int ElemType;
typedef enum {DG,DN,UDG,UDN} GraphKind;//有向图，有向网，无向图，无向网 
typedef struct ArcCell 
{
	VRType adj;//VRtype是顶点关系类型，对无权图用1或0表示相邻否，对带权图，为权值类型 
	IofoType *info; //该弧相关信息的指针 
}ArcCell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
typedef struct
{
	VertexType vexs[MAX_VERTEX_NUM];//顶点向量 
	AdjMatrix arcs;//邻接矩阵 
	int  vexnum,arcnum;//图当前顶点数和弧数 
	GraphKind kind;//图的种类标志 
}MGraph;
void (*VisitFunc)(MGraph G,int v);//函数变量
void InitMGraph(MGraph &G)//初始化 
{
	for(int i=0;i<MAX_VERTEX_NUM;i++)//初始化 
	{
		for(int j=0;j<MAX_VERTEX_NUM;j++)
		{
			if(G.kind==0||G.kind==2)//对于图来说 ,初始化为0 
			{
				G.arcs[i][j].adj=0; 
			}
			else
			{
				G.arcs[i][j].adj=INFINITY;//对于网来说，初始化为正无穷 
			}
		}
	}
}
int LocateVex(MGraph G,int v)//遍历邻接矩阵查找顶点v 
{
	for(int i=0;i<G.vexnum;i++)
	{
		if(G.vexs[i]==v)
			return i;
	}
	return -1;
}

bool CreateGraph(MGraph &G)
{
	printf("请输入图的类型标识（0:有向图 1:有向网 2:无向图 3:无向网）：");
	scanf("%d", &G.kind);
	InitMGraph(G);
	printf("请输入图G的顶点数和弧数：");
	scanf("%d%d", &G.vexnum, &G.arcnum);
	if (G.vexnum == 0 || G.arcnum == 0) 
		return false;
	printf("请输入各个顶点的信息（将按照输入顺序建立顶点向量）：\n");
	for (int i=0; i<G.vexnum; ++i)
	   scanf("%d", &(G.vexs[i]));
    printf("构造邻接矩阵\n");
    
	for (int k=0; k<G.arcnum; ++k)
	{
		ElemType v1, v2;
		int w;
		printf("请输入第%d条弧的信息（弧尾顶点、弧头顶点、权值（若为无权图，则输入1））：\n",k+1);
		scanf("%d%d%d", &v1, &v2, &w);		
        printf("v1=%d v2=%d w=%d\n",v1,v2,w);
		int i = LocateVex(G, v1);
		int j = LocateVex(G, v2);
		G.arcs[i][j].adj = w;
		if (G.kind == 2 || G.kind == 3)
			G.arcs[j][i].adj = w;
	}
	return true;
}
void Print(MGraph G)
{
	for(int i=0;i<G.vexnum;i++)
	{
		for(int j=0;j<G.vexnum;j++)
		{
			if(G.kind==1||G.kind==3)
			{
				if(G.arcs[i][j].adj==INT_MAX)
					printf("∞ ");
				else 
					printf("%2d ",G.arcs[i][j].adj); 
			}
			else printf("%2d ",G.arcs[i][j].adj);
		}
		printf("\n");
	}
}
Status FirstAdjVex(MGraph G,int v)
{
	for(int i=0;i<G.vexnum;i++)
	{
		if(G.arcs[v][i].adj!=0&&G.arcs[v][i].adj!=INFINITY)
		{
			return i;
		}
	}
	return -1;
}
Status NextAdjVex(MGraph G,int v,int w)
{
	for(int i=w+1;i<G.vexnum;i++)
	{
		if(G.arcs[v][i].adj!=0&&G.arcs[v][i].adj!=INFINITY)
			return i;
	}
	return -1;
}
void Visit(MGraph G,int v)
{
	printf("%d ",G.vexs[v]);
}
void DFS(MGraph G,int v)//从第v个顶点出发递归深度优先遍历图G 
{
	visited[v]=true;
	VisitFunc(G,v);//访问第v个顶点 
	for(int w=FirstAdjVex(G,v);w>=0;w=NextAdjVex(G,v,w))//w是v的第一个邻接顶点 
	{
		if(!visited[w])
			DFS(G,w);//对v的尚未访问的邻接顶点w递归调用DFS 
	}
}
void DFSTraverse(MGraph G)//对图G作深度优先遍历 
{
	VisitFunc = Visit;//用全局变量VisitFunc,DFS不必设函数指针参数 
	for(int v=0;v<G.vexnum;v++)
		visited[v]=false;//访问数组初始化 
	for(int v=0;v<G.vexnum;v++)
	{
		if(!visited[v])
			DFS(G,v);//对尚未访问的顶点调用DFS 
	}
}

typedef int QElemType; 
typedef struct QNode{
	QElemType data;
	struct QNode *next;
}QNode ,*QueuePtr;//定义队列节点
typedef struct{
	QueuePtr front;//队头指针
	QueuePtr rear;//队尾指针 
}LinkQueue;

bool InitQueue(LinkQueue &Q)//构造空队列
{
	Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));//分配内存空间 
	if(!Q.front)//分配失败 
		return false;
	Q.front->next=NULL;//下一个结点为空 
	return true; 
 } 

 bool QueueEmpty(LinkQueue Q)//判空 
 {
 	if(Q.front->next==NULL) 
 		return true;
 	else
 		return false;
 	
 }
 bool EnQueue(LinkQueue &Q,QElemType e)//插入，在队尾插入e 
 {
 	QueuePtr p;
 	p=(QueuePtr)malloc(sizeof(QNode));//分配内存
	if(!p)//失败
	 	return false;
	 p->data=e;//赋值元素
	 p->next=NULL;//指向下一个
	 Q.rear->next=p;//接入队尾
	 Q.rear=p;//尾指针指向队尾 
	 return true;
 }
 
 bool DeQueue(LinkQueue &Q,QElemType &e)//如果队列不空，就删除队头元素，用e返回其值 
 {
 	QueuePtr p;
 	if(Q.front==Q.rear)//队为空 
 		return false;
 	p=Q.front->next;//队头元素
	e=p->data; 
 	Q.front->next=p->next;//删除节点和队头连接 
 	if(Q.rear==p)
 		Q.rear=Q.front;
 	free(p);
 	return true;
  } 
void BFSTraverse(MGraph G)//广度优先遍历 
{
	for(int v=0;v<G.vexnum;v++)//初始化 
	{
		visited[v]=false;
	}
	LinkQueue Q; 
	InitQueue(Q);//初始化一个队列 
	for(int v=0;v<G.vexnum;v++)//每一个顶点 
	{
		if(!visited[v])//没有被访问过 
		{
			visited[v]=true;//访问它 
			Visit(G,v);
			EnQueue(Q,v);//这个顶点入队 
			while(!QueueEmpty(Q))
			{
				int u;
				DeQueue(Q,u);//出队 
				for(int w=FirstAdjVex(G,u);w>=0;w=NextAdjVex(G,u,w))
				{
					if(!visited[w])
					{
						visited[w]=true;
						Visit(G,w);
						EnQueue(Q,w);//和他相邻的顶点入队 
					}
				}
			}
		}
	}
}
typedef struct
{
	VertexType adjvex;
	VRType lowcost;
}cd;
cd closedge[MAX_VERTEX_NUM];

int minimum(cd closedge[],MGraph G)
{
	int mini, j;
	for (j = 0; j < G.vexnum; j++)
	{

		if (closedge[j].lowcost != 0)
			break;
	}
	mini = j;
	for (j=j+1; j < G.vexnum; j++)
	{
		if ((closedge[j].lowcost < closedge[mini].lowcost)&&closedge[j].lowcost!=0)
		{
			mini = j;
		}
	}
	return mini;
}
void MiniSpanTree_PRIM(MGraph G,VertexType u)//最小生成树的Prim算法 
{
	int k=LocateVex(G,u); 
	for(int j=0;j<G.vexnum;j++)//辅助数组初始化
		if(j!=k)
		{
			closedge[j].adjvex=u;
			closedge[j].lowcost=G.arcs[k][j].adj;
		}
	closedge[k].lowcost=0;//初始化 
	for(int i=1;i<G.vexnum;i++)
	{
		k=minimum(closedge,G);//求出T的下一个结点，第K个结点 
		printf("%d->%d  ",closedge[k].adjvex,G.vexs[k]);//输出生成树的边 
		closedge[k].lowcost=0;//第K个顶点并入U集 
		for(int j=0;j<G.vexnum;j++)
			if(G.arcs[k][j].adj<closedge[j].lowcost)//新顶点并入U后重新选择最小边 
			{
				closedge[j].adjvex=G.vexs[k];
				closedge[j].lowcost=G.arcs[k][j].adj;
			}
	}
}
int main()
{
	MGraph G;
	CreateGraph(G);
	printf("邻接矩阵为：\n"); 
	Print(G);
	printf("深度优先遍历序列为：\n");
	DFSTraverse(G); 
	printf("\n");
	printf("广度优先遍历序列为：\n");
	BFSTraverse(G); 
	printf("\n");
	printf("prim算法最小生成树：\n");
	printf("请输入最小生成树顶点："); 
	int u;
	scanf("%d",&u);
	MiniSpanTree_PRIM(G,u);
	return 0;
}

查找

顺序表的查找

#include<stdio.h>
typedef int ElemType;
typedef int KeyType;
typedef struct{
	ElemType elem[100];
	int length;
}SSTable;
int Search_Seq(SSTable ST,KeyType key)//在顺序表中查找关键字等于key的数据元素，找到函数值为元素在表中的位置，没找到为0 
{
	ST.elem[0]=key;//哨兵，表中第0个位置存一下关键字
	int i;
	for(i=ST.length;ST.elem[i]!=key;i--);
	return i; 
}
int Search_Bin(SSTable ST,KeyType key)
{
	int low=1,high=ST.length;
	while(low<=high)
	{
		int mid=(low+high)/2;
		if(ST.elem[mid]==key)
			return mid;
		else if(ST.elem[mid]>key)
			high=mid-1;
		else low=mid+1;
	}
	return 0;
}
int main()
{
	KeyType key;
	int t; 
	SSTable ST1;
	
	printf("顺序表的查找：\n");
	printf("请输入数据个数：");
	scanf("%d",&ST1.length);
	printf("请输入%d个数据\n",ST1.length);
	for(int i=1;i<=ST1.length;i++)
		scanf("%d",&ST1.elem[i]);
	printf("请输入要查找的元素：\n");
	scanf("%d",&key);
	t=Search_Seq(ST1,key);
	if(t)
		printf("%d在顺序表的第%d个位置\n",key,t);
	else
		printf("表中不存在此元素\n"); 
	
	SSTable ST2;
	printf("有序表的折半查找\n");
	printf("请输入数据个数：");
	scanf("%d",&ST2.length);
	printf("请有序输入%d个数据\n",ST2.length);
	for(int i=1;i<=ST2.length;i++)
		scanf("%d",&ST2.elem[i]);
	printf("请输入要查找的元素：\n");
	scanf("%d",&key);
	t=Search_Seq(ST2,key);
	if(t)
		printf("%d在有序表的第%d个位置\n",key,t);
	else
		printf("表中不存在此元素\n"); 
	return 0; 
}

二叉排序树

#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef int KeyType;
typedef struct BiTNode//树节点 
{
	int data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
bool SearchBST(BiTree T,KeyType key,BiTree f,BiTree &p)//递归查找关键字等于key的数据元素 
{
	if(!T)
	{
		p=f;//f是T的双亲 
		return false;
	}
	else if(key==T->data)
	{
		p=T;//找到了就指向该节点 
		return true;
	}
	else if(key<T->data)
		return SearchBST(T->lchild,key,T,p);
	else return SearchBST(T->rchild,key,T,p);
 } 
bool InsertBST(BiTree &T,ElemType e)
{//当二叉排序树T中不存在关键字等于e.key的数据元素时，插入e 
	BiTree p; 
	if(!SearchBST(T,e,NULL,p))
	{
		BiTree s;
		s=(BiTree)malloc(sizeof (BiTNode));
		s->data=e;
		s->lchild=s->rchild=NULL;
		if(!p)
			T=s;
		else if(e<p->data)
			p->lchild=s;
		else
			p->rchild=s;
		return true;
	}
	else return false;
}
bool Visit(int e)
{
	printf("%d ",e);
	return true;
 } 
bool InOrderTraverse(BiTree T)//中序遍历递归算法
 {
 	if(T)
 	{
 		if(InOrderTraverse(T->lchild))
 		{
 			if(Visit(T->data))
 			{
 				if(InOrderTraverse(T->rchild))
					return true;
			 }
			 return false;
		 }
		 return false;
	 }
	 else 
	 	return true;
 } 
int main()
{
	BiTree T;
	int a;
	for(int i=0;i<6;i++)
	{
		scanf("%d",&a);
		InsertBST(T,a);//建立二叉排序树 
	}
	printf("二叉排序树中序遍历结果为：\n"); 
	InOrderTraverse(T);
	return 0;
}

二叉排序树的判定

#include<stdio.h>
#include<stdlib.h>
#define true 1
#define false 0
typedef int datatype;
typedef struct node
{
	datatype data;
	struct node *lchild,*rchild;
 }BiTNode, *BiTree;
 int Min=-1;
 //判断给定二叉树是否为二叉排序树
//左子树比根结点小，右子树比根结点大为二叉排序树
bool CreateBiTree(BiTree &T)
{
	datatype e;
	scanf("%d",&e);
	if(e==0)
		T=NULL;
	else
	{
		if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))
			exit(0);
		T->data=e;//生成根节点
		CreateBiTree(T->lchild);//构造左子树 
		CreateBiTree(T->rchild);//构造右子树 
	}
	return true;
}
void JudgeBST(BiTree T,int &flag)
{
	if(T->lchild&&flag)
		JudgeBST(T->rchild,flag);//遍历左子树 
	if(T->data<Min)
			flag=0;
	Min=T->data;
	if(T->rchild&&flag)
		JudgeBST(T->lchild,flag);//遍历右子树 
 } 
 int main()
 {
 	BiTree T;
 	printf("先序建立一颗二叉树：\n");
 	CreateBiTree(T);
 	int flag=1;
 	JudgeBST(T,flag);
 	if(flag)
 		printf("此二叉树为二叉排序树。\n");
	else printf("此二叉树不是二叉排序树。\n"); 
 }

散列表插入和删除

bool Insert(int k)//在散列表中插入关键字K 
{
	int ant=hash(k);//哈希函数 
	LinkList p=HT[ant]; //初始化散列表
	while(p->next)//遍历散列表 
	{
		if(p->next->data==k)
			return false;//如果已经在里面了，就不再插入了 
		p=p->next;
	 } //找到插入位置，即末尾 
	 LinkList s;
	 s=(LNode*)malloc(sizeof(LNode));//新建一个结点 
	 s->data=k;
	 s->next=p->next;//接入结点 
	 p->next=s;
	 return true; 
}

bool Delete(int k)
{
	int ant=hash(k);
	LinkList p=HT[ant]; //初始化散列表
	while(p->next)
	{
		if(p->next->data==k)
		{
			LinkList s=p->next;
			p->next=s->next;
			free(s);
			return true;
		}
		p=p->next;//遍历下一个结点 
	}
	return false; 
}

排序

#include<stdio.h>
#define MAXSIZE 20
typedef int KeyType;
typedef int InfoType;
typedef struct{
	KeyType key;//关键字 
	InfoType otherinfo;//其他数据项 
}RedType;
typedef struct{
	RedType r[MAXSIZE+1];//r[0]闲置或者为哨兵 
	int length;
}SqList; 
void InsertSort(SqList &L)//直接插入排序 
{
	int i,j;
	for(i=2;i<=L.length;i++)//遍历 
	{
		if(L.r[i].key<L.r[i-1].key)//后面的数小，就插在前面 
		{
			L.r[0]=L.r[i];//更新哨兵 
			L.r[i]=L.r[i-1];
			for( j=i-2;L.r[0].key<L.r[j].key;j--)
				L.r[j+1]=L.r[j];//后移 
			L.r[j+1]=L.r[0]; //插入这个数 
		}
	}
}
void ShellInsert(SqList &L,int dk)//希尔调整 
{
	int i,j;
	for(i=dk+1;i<=L.length;i++)
	{
		if(L.r[i].key<L.r[i-dk].key)
		{
			L.r[0]=L.r[i];
			for(j=i-dk;j>0&&L.r[0].key<L.r[j].key;j-=dk)
				L.r[j+dk]=L.r[j];//后移 
			L.r[j+dk]=L.r[0];//插入 
		}
	}
 } 
void ShellSort(SqList &L,int dlta[],int t)//希尔排序 
{
	for(int k=0;k<t;k++)
		ShellInsert(L,dlta[k]);//一趟增量为dlta[k]的插入排序 ,增量存在dlta数组中 
}

//快速排序
int Partition(SqList& L,int low,int high)
{
	L.r[0]=L.r[low];//第一个记录作枢轴 
	int pivotkey=L.r[low].key;
	while(low<high)
	{
		while(low<high&&L.r[high].key>=pivotkey) 
			high--;
		L.r[low]=L.r[high];
		while(low<high&&L.r[low].key<=pivotkey) 
			low++;
		L.r[high]=L.r[low];
	}
	L.r[low]=L.r[0];
	return low;
}
 
void QSort(SqList &L,int low,int high)
{
	if(low<high)
	{
		int pivoloc=Partition(L,low,high);
		QSort(L,low,pivoloc-1);
		QSort(L,pivoloc+1,high);
	}
}
 
void QuickSort(SqList &L)//快速排序 
{
	QSort(L,1,L.length);
}

int SelectMinkey(SqList &L,int i)
{
	int min=L.r[i].key ,j;
	int minp=i;
	for( j=i+1;j<=L.length;j++)
	{
		if(L.r[j].key<min)
		{
			min=L.r[j].key;
			minp=j;
		}
			
	}
	return minp;
}
void SelectSort(SqList &L)//简单选择排序 
{
	int i,j; 
	for(i=1;i<L.length;i++)
	{
		j=SelectMinkey(L,i);
		if(j!=i)
		{
			RedType t;
			t=L.r[j];
			L.r[j]=L.r[i];
			L.r[i]=t;
		}
	}
}

typedef SqList HeapType;
//调整堆
void HeapAdjust(HeapType &H,int s,int m)
{
	RedType rc=H.r[s];                           //将r[s]值储存起来
	for(int j=2*s;j<=m;j*=2)
	{
		if(j<m&&H.r[j].key<H.r[j+1].key)  
			j++;
		if(rc.key>=H.r[j].key) 
			break;
		H.r[s]=H.r[j];
		s=j;               
	}
	H.r[s]=rc;                       //循环结束将r[s]值插入
}

void HeapSort(HeapType &H)//堆排序
{
	int i;
	for(i=H.length/2;i>0;i--)
	{
		HeapAdjust(H,i,H.length);
	}                //初建堆
	for(i=H.length;i>1;i--)
	{                            //不断交换并调整堆
		RedType t=H.r[1];
		H.r[1]=H.r[i];
		H.r[i]=t;
		HeapAdjust(H,1,i-1);
	}
	
}
void Input(SqList &L)//输入 
{
	printf("请输入数据个数：");
	scanf("%d",&L.length);
	printf("请输入这些数据：\n");
	for(int i=1;i<=L.length;i++)
	{
		scanf("%d",&L.r[i].key);
	}
 } 
void Print(SqList L)//输出 
{
	for(int i=1;i<=L.length;i++)
		printf("%d ",L.r[i].key);
	printf("\n");
}
int main()
{
	SqList L;
	/*
	printf("直接插入排序：\n");
	Input(L);
	InsertSort(L);
	Print(L);
	
	printf("希尔排序：\n");
	Input(L);
	int dlta[3]={5,3,1};//增量数组 
	ShellSort(L,dlta,3);
	Print(L);
	
	printf("快速排序：\n");
	Input(L);
	QuickSort(L); 
	Print(L);
	*/ 
	printf("简单选择排序：\n");
	Input(L);
	SelectSort(L); 
	Print(L);
	/*
	printf("堆排序：\n");
	Input(L);
	HeapSort(L); 
	Print(L);
	*/
	
}