数据结构严蔚敏全部代码（正在更新中）（详细到书中每一个ADT及算法段以及入门演示代码 COVER BY：数据结构算法实现及解析 (修改版可直接运行文件）（更新于2020.11.10））

最新推荐文章于 2023-04-10 21:02:41 发布

正在认真学习的阿俊

最新推荐文章于 2023-04-10 21:02:41 发布

阅读量1.3k

点赞数 9

分类专栏：编程练习文章标签：数据结构 c语言

本文链接：https://blog.csdn.net/qq_38977714/article/details/108893590

版权

该博客详细介绍了数据结构的各个章节，包括三元组实现、线性表的顺序表和链表、栈、队列、KMP算法、二叉树等，并提供了相应的C++代码实现，便于学习和实践。

摘要由CSDN通过智能技术生成

第一章　绪论

三元组的实现

c1.h　万能头文件

#include<string.h>
#include<ctype.h>
#include<malloc.h>
#include<limits.h>
#include<stdio.h>
#include<stdlib.h>
#include<io.h>
#include<math.h>
#include<process.h>
#include<iostream>
using namespace std;

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1

typedef int Status;//函数返回类型
typedef int Boolean;//布尔类型
typedef int ElemType;

c1-1.h

typedef ELemType *Tripelet;

bo1-1.cpp

#include "c1.h"
#include "c1-1.h"

Status InitTriplet(Triplet &T,ElemType v1,ElemType v2,ElemType v3)
{
   
    if(!(T=(ElemType *)malloc(3*sizeof(ElemType))))
        exit(OVERFLOW);
    T[0]=v1,T[1]=v2,T[2]=v3;
    return OK;
}
Status DestroyTriplet(Triplet &T)
{
   
    free(T);
    T=NULL;
    return OK;
}
Status Get(Triplet T,ElemType &e,int i)
{
   
    if(i<1||i>2)
        return ERROR;
    e=T[i-1];
    return OK;
}
Status Put(Triplet &T,ElemType e,int i)
{
   
    if(i<1||i>2)
        return ERROR;
    T[i-1]=e;
    return OK;
}
Status IsAscending(Triplet T)
{
   
    return T[0]<T[1]&&T[1]<T[2];
}
Status IsDecending(Triplet T)
{
   
    return T[0]>T[1]&&T[1]>T[2];
}
Status Max(Triplet T,ElemType &e)
{
   
    e=T[0]>T[1]?T[0]>T[2]?T[0]:T[2]:T[1]>T[2]?T[1]:T[2];
    return OK;
}
Status Min(Triplet T,ElemType &e)
{
   
    e=T[0]<T[1]?T[0]<T[2]?T[0]:T[2]:T[1]<T[2]?T[1]:T[2];
    return OK;
}

main1-1.cpp(可对照上面的函数文件自行修改)

#include"c1.h"
#include"c1-1.h"
#include"bo1-1.cpp"

int main()
{
   
    Triplet T;
    ElemType m;
    Status i;
    i=InitTriplet(T,5,7,9);
    printf("调用初始化函数后，i=%d(1:成功) T的3个值为",i);
    cout<<T[0]<<' '<<T[1]<<' '<<T[2]<<endl;
    int j=2;
    i=Get(T,j,m);
    if(i==OK)
    {
   
        cout<<"T的第二个值为"<<m<<endl;
    }
    i=Put(T,2,6);
    if(i==OK)
        cout<<"将T的第2个值改为6后，T的3个值为 "<<T[0]<<' '<<T[1]<<' '<<T[2]<<endl;
    i=IsAscending(T);
    printf("调用升序函数后，是否成功？ %d\n",i);
    i=IsDecending(T);
    printf("是否为降序？%d\n",i);
    j=Max(T,m);
    printf("最大值为：%d\n",m);
    j=Min(T,m);
    printf("最小值为：%d\n",m);
    i=DestroyTriplet(T);
    if(i)
        printf("成功销毁");
    else
    {
   
        printf("未能成功销毁");
    }
    return 0;
}

区分引用类型和非引用类型（注：必须保存为c++后缀即：.cpp）

algo1-3.cpp

#include<stdio.h>
void fa(int a)
{
   
	a++;
	printf("在函数fa中：a=%d\n",a);
}
void fb(int &a)
{
   
	a++;
	printf("在函数fb中：a=%d\n",a);
}
int main()
{
   
	int n=1;
	printf("在主程序中，调用函数fa之前：n=%d\n",n);
	fa(n);
	printf("在主程序中，调用函数fa之后，fb之前：n=%d\n",n);
	fb(n);
	printf("在主程序中，调用函数fb之后：n=%d\n",n);
	return 0;
}

exit的作用

algo1-4.cpp

#include"c1.h"

int a(int i)
{
   
    if(i==1)
    {
   
        printf("退出程序的运行\n");
        exit(0);//里面的值0代表正常退出运行，值为1则代表异常退出运行
    }
    return i;
}

int main()
{
   
    int i;
    printf("请输入i: ");
    scanf("%d",&i);
    printf("a(i)=%d\n",a(i));
    return 0;
}

记录程序运行时间

一般的方法是使用time.h头文件中的clock()函数

#include<stdio.h>
#include<time.h>
int main()
{
   
    clock_t begin,end;
    begin = clock();
    for(int i=0;i<1000000000;++i);//可替换为待检测的程序
    end = clock();
    printf("%lf",(double)(end-begin)/CLOCKS_PER_SEC);
    return 0;
}

另一种方法是调用sys/timb.h头文件

#include<stdio.h>
#include<sys/timeb.h>
int main()
{
   
    timeb t1,t2;
    long t;
   
    ftime(&t1);
    for(int i=1;i<1000000000;++i);
    ftime(&t2);
    t=(t2.time-t1.time)*1000+(t2.millitm-t1.millitm);
    printf("用时%ld毫秒\n",t);
    return 0;
}

增加两种时间表达方式 ( 转载 )

#include<iostream>
#include<Windows.h>
 
using namespace std;
int main()
{
   
	long begin=GetTickCount();
	for(int i=0;i<1000000000;i++);
	long end=GetTickCount();
 
	cout<<begin-start<<endl;
	return 0;
 }

#include<stdio.h>
#include <windows.h>
int main() {
   
	double run_time;
	_LARGE_INTEGER time_start;	//开始时间
	_LARGE_INTEGER time_over;	//结束时间
	double dqFreq;		//计时器频率
	LARGE_INTEGER f;	//计时器频率
	QueryPerformanceFrequency(&f);
	dqFreq=(double)f.QuadPart;
	QueryPerformanceCounter(&time_start);	//计时开始
	for(int i = 1; i <= 100000000; i++);	//要计时的程序
	QueryPerformanceCounter(&time_over);	//计时结束
	run_time=1000000*(time_over.QuadPart-time_start.QuadPart)/dqFreq;
	//乘以1000000把单位由秒化为微秒，精度为1000 000/（cpu主频）微秒
	printf("\nrun_time：%fus\n",run_time);
	return 0;
}

第二章　线性表

顺序表

c2-1.h 线性表动态分配顺序结构

#define LIST_INIT_SIZE 100
#define LIST_INCREMENT 2

#ifndef _TEST_H_ 
#define _TEST_H_ 
struct SqList{
   
    ElemType *elem;
    int length;
    int listsize;
};
#endif

bo2-1.cpp 顺序表的操作

#include "c2-1.h"
#include "c1.h"

void InitList(SqList &L){
   
    L.elem=(ElemType *)malloc(sizeof(ElemType)*LIST_INIT_SIZE);
    if(!L.elem)
        exit(OVERFLOW);
    L.listsize=LIST_INIT_SIZE;
    L.length=0;
}

void DestroyList(SqList &L){
   
    free(L.elem);
    L.elem=NULL;
    L.length=0;
    L.listsize=0;
}

void ClearList(SqList &L){
   
    L.length=0;
}

Status ListEmpty(SqList L)
{
   
    return L.length==0;
}

Status ListLength(SqList L,int &len)
{
   
    return L.length;
}

Boolean ListInsert(SqList &L,int i,int e)
{
   
    ElemType *newbase,*q,*p;
    if(i<1&&i>L.length+1)
        exit(OVERFLOW);
    if(L.length>=L.listsize)
    {
   
        if(!(newbase=(ElemType*)realloc(L.elem,(sizeof(ElemType))*(L.listsize+LIST_INCREMENT))))
            exit(OVERFLOW);
    L.elem=newbase;
    L.listsize=L.listsize+LIST_INCREMENT;
    }
    q=L.elem+i-1;
    for(p=L.elem+L.length-1;p>=q;--p)
    {
   
        *(p+1)=*p;
    }
    *q=e;
    ++L.length;
    return OK;
}

Status ListDelete(SqList &L,int i,int &e)
{
   
    ElemType *p,*q;
    if(i<1||i>L.length)
        return ERROR;
    e=*(L.elem+i-1);
    for(int j=i;j<L.length;++j)
    {
   
        *(L.elem+j-1)=*(L.elem+j);
    }
    --L.length;
    return OK;
}

Boolean GetElem(SqList L,int i,ElemType &e)
{
   
    if((e=*(L.elem+i-1)))
        return OK;
    else
    {
   
        return FALSE;
    }
}

Status LocateElem(SqList L,int &i