清华严蔚敏《大数据结构》地全部代码实现C语言

合集下载

严蔚敏版大数据结构所有算法代码

严蔚敏版数据结构所有算法代码------------------------线性数据结构-----------------------------2013年9月//线性表、链表//栈、队列//数组、广义表//串-------------------------线性表----------------------typedef struct{char name[20];//注意如果应用指针的形式//在初始化每个结点时一定要先为结点中的每个变量开辟内存空间char sex;char addr[100];unsigned int age;char phonenum[20];}node;//结点描述typedef struct{node *p;int length;//当前顺序表长度int listsize;//当前分配的线性表长度}list;//线性表描述list L;//定义一个线性表int initlist(list &l)//构造一个空的线性表{l.p=(node*)malloc(LIST_INIT_SIZE*sizeof(node));if(!(l.p))exit(1);l.length=0;l.listsize=LIST_INIT_SIZE;return true;}void destroylist(list &l)//销毁线性表操作{if(l.p!=NULL){free(l.p);printf("销毁成功!\n");}elseprintf("线性表不存在！\n");}int clearlist(list &l)//将线性表置空操作{if(l.p==NULL){printf("线性表不存在！\n");return false;}else{free(l.p);l.p=(node*)malloc(l.listsize*sizeof(node));l.length=0;}return true;}int listempty(list &l)//判断线性表是否为空表{if(l.p==NULL)return true;elsereturn false;}int getelem(list &l,int i,node &e)//用e返回表中第i个数据元素{if(l.p==NULL)return false;elsee=l.p[i-1];return true;}int priorelem(list &l,int i,node &pre_e)//得到第i个元素的前驱元素{if(i==0||l.p==NULL)return false;elsepre_e=l.p[i-1];return true;}int nextelem(list &l,int i,node &next_e)//得到表中第i个元素的后继元素{if(i>=l.length||l.p==NULL)return false;elsenext_e=l.p[i+1];return true;}int insertlist(list &l,int i,node &e)//将元素e插入到表l中第i个元素的后面{node *q,*k;if(i<1||i>l.length+1)return false;if(l.length>=l.listsize){l.p=(node*)realloc(l.p,(l.listsize+LISTINCREMENT)*sizeof(node));if(!l.p)exit(1);l.listsize+=LISTINCREMENT;}k=&l.p[i-1];for(q=&l.p[l.length-1];q>k;q--)*(q+1)=*q;*k=e;l.length++;return true;}int deletelist(list &l,int i,node &e)//删除表中第i个元素并用e返回其值{node *q;int j=i-1;if(i<1||i>l.length)return false;e=l.p[i-1];for(q=&l.p[i-1];j<l.length-1;j++)*q=*(++q);l.length--;return true;}void mergerlist(list la,list lb,list &lc)//归并两个按非递减排列的线性表{int la_len,lb_len,i=1,j=1,k=0;node ai,bj;la_len=la.length;lb_len=lb.length;while(i<=la_len&&j<=lb_len){getelem(la,i,ai);getelem(lb,j,bj);if(ai.a<=bj.a){insertlist(lc,++k,ai);i++;}else{insertlist(lc,++k,bj);j++;}}while(i<=la_len){getelem(la,i,ai);insertlist(lc,++k,ai);i++;}while(j<=lb_len){getelem(lb,j,bj);insertlist(lc,++k,bj);j++;}}int ListAscendingOrder(list &l)//按结点中某一元素的比较升序排列线性表中的结点{node e;int i,j;if(l.p==NULL||l.length==1)return ERROR;for(i=0;i<l.length-1;i++)for(j=i+1;j<l.length;j++)if(l.p[i].num>=l.p[j].num){e=l.p[i];l.p[i]=l.p[j];l.p[j]=e;}return OK;}//省略降序排列void MergerList(list la,list lb,list &lc)//将两线性表升序排列后再归并{node *q,*k,e1;int i=0,j=0,m=0,n;ListAscendingOrder(la);ListAscendingOrder(lb);printf("表a升序排列后为：\n");for(i=0;i<la.length;i++)printf("%d ",la.p[i].num);printf("\n");printf("表b升序排列后为：\n");for(i=0;i<lb.length;i++)printf("%d ",lb.p[i].num);printf("\n");i=0;while(i<la.length&&j<lb.length){if(la.p[i].num<=lb.p[j].num){e1=la.p[i];i++;}else{e1=lb.p[j];j++;}if(e1.num!=lc.p[lc.length-1].num)InsertList(lc,++m,e1);}if(i<la.length)while(i<la.length){if(la.p[i].num!=lc.p[lc.length-1].num)InsertList(lc,++m,la.p[i]);i++;}if(j<lb.length)while(j<lb.length){if(lb.p[j].num!=lc.p[lc.length-1].num)InsertList(lc,++m,lb.p[j]);j++;}printf("按升序排列再归并两表为：\n");for(n=0;n<lc.length;n++)printf("%d ",lc.p[n].num);printf("\n");}----------------------链表----------------------------- typedef struct{int num;}node;typedef struct LIST{node data;struct LIST *next;}list,*slist;int CreatList(slist &head)//此处应为只针对的引用{head=(list *)malloc(sizeof(list));if(!head)return ERROR;head->next=NULL;return OK;}void InvertedList(slist &head1,slist &head2){//构造新表逆置单链表函数list *p,*q;p=head1->next;q=p->next;if(p==NULL)printf("链表为空无法实现逆置操作\n");else{while(q!=NULL){p->next=head2->next;head2->next=p;p=q;q=q->next;}p->next=head2->next;head2->next=p;printf("逆置成功！?\n");}}void InsertList(slist &head,node &e)//此处应为指针的引用{//而不应该是list *headlist *p,*q;p=(list *)malloc(sizeof(list));q=head;while(q->next!=NULL)q=q->next;p->next=q->next;q->next=p;p->data=e;}void InvertedList(sqlist &head){//-------不构造新表逆置单链表函数---------// list *p,*q,*k;p=head->next;q=p->next;k=q->next;p->next=NULL;while(k!=NULL){q->next=p;p=q;q=k;k=k->next;}q->next=p;head->next=q;}//----交换链表中第i个和第j个结点，函数实现如下——// int SwapListNode(sqlist &head,int i,int j){int m,n,m1,n1,sum=0;list *p,*q,*k,*c,*d,*ba;ba=head->next;while(ba!=NULL){sum++;ba=ba->next;}if(i==j||i>sum||j>sum||i<1||j<1){printf("所要交换的两个结点有误！\n");return ERROR;}if(i<j){ m=i; n=j;}else{ m=j;n=i;}p=head;q=head;for(m1=1;m1<=m;m1++)p=p->next;for(n1=1;n1<=n;n1++)q=q->next;if(p->next==q){//如果结点相邻k=head;while(k->next!=p)k=k->next;//相邻两结点的交换p->next=q->next;q->next=p;k->next=q;}else{//如果结点不相邻k=head;c=head;while(k->next!=p)k=k->next;while(c->next!=q)c=c->next;d=p->next;//不相邻两结点之间的交换p->next=q->next;c->next=p;k->next=q;q->next=d;}return OK;}//-----将链表中结点按结点中某一项大小升序排列，函数实现如下-----// int AscendingList(sqlist &head){int m,n,sum=0,i,j;list *p,*q,*k;k=head->next;while(k!=NULL){sum++;k=k->next;}for(i=1;i<sum;i++)for(j=i+1;j<=sum;j++){p=head->next;m=1;while(m!=i){m++;p=p->next;}q=head->next;n=1;while(n!=j){n++;q=q->next;}if(p->data.exp>q->data.exp)//如果按exp降序排列，则应将>改为<；SwapListNode(head,i,j);}return OK;}//-----将两链表合并为一个链表------//int AddList(sqlist &head1,sqlist &head2,sqlist &head3){//已将表head1和表head2按某一项升序排列过sqlist p,q;node e;p=head1->next;q=head2->next;while(p!=NULL&&q!=NULL){if(p->data.exp<q->data.exp){InsertList(head3,p->data);p=p->next;}elseif(p->data.exp>q->data.exp){InsertList(head3,q->data);q=q->next;}elseif(p->data.exp==q->data.exp){e.coefficient=p->data.coefficient+q->data.coefficient;e.exp=p->data.exp;//e.exp=q->data.exp;InsertList(head3,e);p=p->next;q=q->next;}}if(p!=NULL)while(p!=NULL){InsertList(head3,p->data);p=p->next;}//如果p中有剩余，则直接将p中剩余元素插入head3中if(q!=NULL)while(q!=NULL){InsertList(head3,q->data);q=q->next;}//如果q中有剩余，则直接将q中的剩余元素插入head3中return 0;}-----------------------栈------------------------------//---------利用栈结构实现数制之间的转换------书3.2.1//typedef struct{int num;}node;typedef struct{node *base;node *top;int stacksize;}stack;//顺序栈结构定义int CreatStack(stack &stackll){stackll.base=(node *)malloc(INITSTACKSIZE*sizeof(node));if(!stackll.base)exit(OVERFLOW);stackll.top=stackll.base;stackll.stacksize=INITSTACKSIZE;return OK;}void push(stack &s,node e){//进栈操作if(s.top-s.base>=s.stacksize){ s.base=(node*)realloc(s.base,(s.stacksize+INCRESTACKMENT)*sizeof(node));if(!s.base)exit(OVERFLOW);s.top=s.base+s.stacksize;//可以不写此语句；s.stacksize+=INCRESTACKMENT;}*(s.top++)=e;//*s.top++=e;}void pop(stack &s,node &e){//出栈操作if(s.top==s.base||s.base==NULL)printf("信息有误！\n");elsee=*--s.top;}//-------取栈顶元素函数------//void gettop(stack &s,node &e){if(s.base==s.top)printf("栈为空，无法取得栈顶元素！\n");else{e=*(s.top-1);}}//-----栈的应用：括号匹配的检验------书3.2.2////省略了大部分上述已有代码//int zypd(char c){//判断是否为左括号字符if(c=='['||c=='{'||c=='(')return OK;elsereturn ERROR;}int main(void){stack s;node e1,e2,e3;char st[INITSTACKSIZE];int i=0,j;CreatStack(s);printf("请输入括号字符，以'#'做结束符：");scanf("%c",&st[i]);while(st[i]!='#'){i++;scanf("%c",&st[i]);}if(!zypd(st[0]))printf("输入字符不合法！\n");else{for(j=0;j<i;j++){if(zypd(st[j])){//如果是左括号则将此字符压入栈中e1.c=st[j];push(s,e1);}else{//如果当前st[j]元素不是左括号//则取出栈顶元素，比较栈顶元素与当前st[j]元素是否项匹配//如果匹配，则栈顶元素出栈gettop(s,e2);if(e2.c=='['&&st[j]==']'||e2.c=='{'&&st[j]=='}'||e2.c=='('&&st[j] ==')')pop(s,e3);else{printf("括号验证失败！\n");break;}}}if(s.top==s.base)//当循环结束时，如果栈为空栈说明输入的括号合法printf("括号验证成功！\n");}getchar();system("pause");return 0;}//----------链栈描述---------//typedef struct Node{int num;struct Node *next;}node;typedef struct{Node *top;Node *base;}stack;void InitStack(stack &s){s.base=(Node *)malloc(sizeof(node));if(!s.base)exit(1);else{s.base->next=NULL;s.top=s.base;}}void InsertStack(stack &s,node e){node *p;p=(node *)malloc(sizeof(node));if(!p)exit(1);else{*p=e;p->next=s.top;s.top=p;}}void DeleteStack(stack &s,node &e){node *p;if(s.top==s.base)printf("栈为空！\n");else{p=s.top;s.top=s.top->next;e=*p;free(p);}}--------------------队列---------------------- //------链队列的描述及操作-------//typedef struct Node{int a;struct Node *next;}Qnode,*QueuePtr;typedef struct{QueuePtr front;QueuePtr rear;}LinkQueue;void InitQueue(LinkQueue &Q){Q.front=(Qnode *)malloc(sizeof(Qnode));if(!Q.front)exit(1);Q.rear=Q.front;Q.front->next=NULL;}void InsertQueue(LinkQueue &Q,Qnode e){QueuePtr p;p=(Qnode *)malloc(sizeof(Qnode));if(!p)exit(1);*p=e;p->next=NULL;Q.rear->next=p;Q.rear=p;}void DeleteQueue(LinkQueue &Q,Qnode &e){Qnode *p;if(Q.front==Q.rear)printf("队列为空！\n");else{p=Q.front->next;e=*p;Q.front->next=p->next;if(p==Q.rear)Q.rear=Q.front;free(p);}}//-------------循环队列---------------// typedef struct node{int data;struct node *next;}node;typedef struct queue{node *base;int front;int rear;}Queue;int tag;void InitQueue(Queue &Q){Q.base=(node *)malloc(MAX*sizeof(node));if(!Q.base)exit(1);Q.front=Q.rear=0;tag=0;}void InsertQueue(Queue &Q,node e){if(tag==1&&Q.front==Q.rear)printf("循环队列已满！\n");else{Q.base[Q.rear]=e;Q.rear=(Q.rear+1)%MAX;if(Q.rear==Q.front)tag=1;}}void DeleteQueue(Queue &Q,node &e){if(tag==0&&Q.front==Q.rear)printf("队列为空！\n");else{e=Q.base[Q.front];Q.front=(Q.front+1)%MAX;if(Q.front==Q.rear)tag=0;}}int EmptyQueue(Queue &Q){if(Q.front==Q.rear&&tag==0)return 1;elsereturn 0;}--------------------------串----------------------------------- //-----------串：堆分配存储形式的一些操作------------------// typedef struct string{char *ch;int length;}sstring;void CreatString(sstring &T){T.ch=(char*)malloc(sizeof(char));T.length=0;}void StringAssign(sstring &T,char *s){//将串s的值赋值给串Tif(T.ch)free(T.ch);T.ch=(char*)malloc(strlen(s)*sizeof(char));//或者T.ch=(char*)malloc(sizeof(char));//动态开辟空间不同于静态内存开辟之处if(!T.ch){printf("ERROR");exit(1);}strcpy(T.ch,s);T.length=strlen(s);}void ClearString(sstring &T){if(T.ch)free(T.ch);T.length=0;}void ConcatString(sstring &T,sstring s1,sstring s2){//串连接if(T.ch)free(T.ch);T.ch=(char*)malloc((strlen(s1.ch)+strlen(s2.ch))*sizeof(char));if(!T.ch){printf("ERROR\n");exit(1);}strcpy(T.ch,s1.ch);strcat(T.ch,s2.ch);T.length=strlen(s1.ch)+strlen(s2.ch);}void SubString(sstring &sub,sstring s,int pos,int len){//取子串操作，取串s中位置从pos至len处的子串于sub中int i,j=0;if(sub.ch)free(sub.ch);sub.ch=(char *)malloc((len-pos+1+1)*sizeof(char));if(!sub.ch){printf("ERROR\n");exit(1);}for(i=pos-1;i<len;i++)sub.ch[j++]=s.ch[i];sub.ch[j]='\0';sub.length=strlen(sub.ch);}int CountString(sstring s1,sstring s2){//判断子串s2在母串s1中出现的次数int i,j,k,count=0;if(s1.length==0||s2.length==0||s2.length>s1.length){printf("ERROR\n");return 0;}else{for(i=0;i<s1.length;i++){k=1;for(j=0;j<s2.length;j++){if(s2.ch[j]!=s1.ch[i+j]){k=0;break;}}if(k)count++;}}return count;}void Deletestring(sstring &s,int pos,int len) {//删除s串中位置从pos到len处的元素int i,j,k;if(s.length==0)printf("ERROR\n");else{for(i=pos-1,j=len;j<s.length;i++,j++) s.ch[i]=s.ch[j];s.ch[i]='\0';s.length-=(len-pos)+1;}}void DeleteSub(sstring &s1,sstring s2){//删除母串s1中的子串s2int i,j,k,tag=0;for(i=0;i<s1.length;i++){k=1;if(tag)i--;for(j=0;j<s2.length;j++)if(s2.ch[j]!=s1.ch[i+j]){k=0;break;}if(k){Deletestring(s1,i+1,i+s2.length);tag=1;}}}----------------KMP算法----------------int index_kmp(string T,string S,int pos){int i=pos,j=1;while(i<=S.length&&j<=T.length){if(S.ch[i]==T.ch[j]){i++;j++;}elsej=next[j+1];}if(j>T.length)return i-T.length;elsereturn 0;}void get_next(string T){int i=1,j=0;next[1]=0;while(i<=T.length){if(j-1==0||T.ch[i]==T.ch[j]){i++;j++;if(T.ch[i]!=T.ch[j])next[i]=j;elsenext[i]=next[j];}elsej=next[j];}}———————----------------数组——————————————-----------矩阵转置的经典算法---------for(i=0;i<row;i++)for(j=0;j<col;j++)b[j][i]=a[i][j];时间复杂度为O（row*col),每个元素都要存储，相对于稀疏矩阵来说比较浪费存储空间。

清华严蔚敏《数据结构》的的全部代码实现C语言.doc

/* c1.h (程序名 ) */#include <string.h>#include <ctype.h>#include <malloc .h> /* malloc() 等 */#include <limits.h> /* INT _MAX 等 */#include <stdio.h> /* EOF(=^Z 或 F6),NULL */#include <stdlib.h> /* atoi() */#include <io.h> /* eof() */#include <math.h> /* floor(),ceil(),abs() */#include <process.h> /* exit() *//* 函数结果状态代码*/#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1/* #define OVERFLOW -2因为在math.h中已定义OVERFLOW的值为3,故去掉此行*/ typedef int Status; /* Status 是函数的类型 ,其值是函数结果状态代码，如OK 等 */typedef int Boolean ; /* Boolean 是布尔类型 ,其值是 TRUE 或 FALSE *//* algo2-1.c 实现算法 2.1 的程序*/#include"c1.h"typedef int ElemType ;#include"c2-1.h"/*c2-1.h线性表的动态分配顺序存储结构*/#define LIST_INIT_SIZE10 /*线性表存储空间的初始分配量*/#define LISTINCREMENT 2/* 线性表存储空间的分配增量*/typedef struct{ElemType *elem ; /* 存储空间基址*/int length; /*当前长度*/int listsize; /* 当前分配的存储容量(以 sizeof(ElemType )为单位 ) */}SqList;#include "bo2-1.c"/* bo2-1.c顺序表示的线性表(存储结构由c2-1.h 定义 )的基本操作 (12 个) */ Status InitList (SqList *L ) /* 算法 2.3 */{ /* 操作结果：构造一个空的顺序线性表*/(*L ).elem=(ElemType*) malloc ( LIST_INIT_SIZE * sizeof(ElemType));if (!( *L ).elem)exit (OVERFLOW); /* 存储分配失败*/(*L ).length=0; /*空表长度为0 */(*L ).listsize =LIST_INIT_SIZE ; /*初始存储容量*/return OK;}Status DestroyList (SqList *L ){ /* 初始条件：顺序线性表L 已存在。

《数据结构》——严蔚敏C语言版书中的易考代码

《数据结构》——严蔚敏C语言版书中的易考代码void MergeList(List La, List Lb, List &Lc) { // 算法2.2// 已知线性表La和Lb中的元素按值非递减排列。

// 归并La和Lb得到新的线性表Lc，Lc的元素也按值非递减排列。

int La_len, Lb_len; ElemType ai, bj int i=1, j=1, k=0;InitList(Lc);La_len = ListLength(La);Lb_len = ListLength(Lb);while ((i <= La_len) && (j <= Lb_len)) { // La和Lb均非空GetElem(La, i, ai);GetElem(Lb, j, bj);if (ai <= bj) { ListInsert(Lc, ++k, ai); ++i;} else {ListInsert(Lc, ++k, bj);++j;}}while (i <= La_len) {GetElem(La, i++, ai); ListInsert(Lc, ++k, ai);} while (j <= Lb_len) {GetElem(Lb, j++, bj); ListInsert(Lc, ++k, bj);}} // MergeListStatus ListInsert_Sq(SqList &L, int i, ElemType e) { // 算法2.4 // 在顺序线性表L的第i个元素之前插入新的元素e，// i的合法值为1≤i≤ListLength_Sq(L)+1ElemType *p;if (i < 1 || i > L.length+1) return ERROR; // i值不合法if (L.length >= L.listsize) { // 当前存储空间已满，增加容量ElemType *newbase = (ElemType *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof (ElemType)); if (!newbase) return ERROR; // 存储分配失败L.elem = newbase; // 新基址L.listsize += LISTINCREMENT; // 增加存储容量}ElemType *q = &(L.elem[i-1]); // q为插入位置for (p = &(L.elem[L.length-1]); p>=q; --p) *(p+1) = *p;// 插入位置及之后的元素右移*q = e; // 插入e++L.length; // 表长增1return OK;} // ListInsert_Sqvoid MergeList_Sq(SqList La, SqList Lb, SqList &Lc) { // 算法2.7 // 已知顺序线性表La和Lb的元素按值非递减排列。

严蔚敏《数据结构》(C语言版)笔记和习题(含考研真题)详解

严蔚敏《数据结构》（C语言版）笔记和习题（含考研真题）详解第1章绪论一、什么是数据结构数据结构是一门研究非数值计算的程序设计问题中计算机的操作对象以及它们之间的关系和操作等的学科。

二、基本概念和术语1数据数据是对客观事物的符号表示，是计算机科学中所有能输入到计算机中并能被计算机程序处理的符号的总称。

2数据元素数据元素是数据的基本单位。

3数据对象数据对象是性质相同的数据元素的集合，是数据的一个子集。

4数据结构数据结构是相互之间存在一种或多种特定关系的数据元素的集合。

（1）数据结构的基本结构根据数据元素之间关系的不同特性，通常有下列四类基本结构：①集合。

数据元素属于“同一个集合”，并无其他复杂关系。

②线性结构。

数据元素之间存在一个对一个的关系。

③树形结构。

数据元素之间存在一个对多个的关系。

④图状结构或网状结构。

数据元素之间存在多个对多个的关系。

【注意】区分这四种基本结构可以根据元素间的对应关系。

如图1-1所示为上述四类基本结构的关系图。

图1-1 四类基本结构的关系图（2）数据结构的形式定义数据结构的形式定义为：Data_Structure=(D,S)其中：D表示数据元素的有限集，S表示D上关系的有限集。

（3）数据结构在计算机中的表示数据结构包括数据元素的表示和关系，在计算机中称为数据的物理结构（又称存储结构）。

其中，关系有两种表示方法：顺序映象和非顺序映象。

这两种表示方法对应两种存储结构：顺序存储结构和链式存储结构。

a．顺序映象：用相对位置来表示数据元素之间的逻辑关系。

b．非顺序映象：用指针表示数据元素之间的逻辑关系。

5数据类型数据类型是一个值的集合和定义在这个值集上的一组操作的总称。

6抽象数据类型抽象数据类型（ADT）由一个值域和定义在该值域上的一组操作组成。

【注意】抽象数据类型是对数据类型架构的一种全局体现，使我们能够更加清晰地看待某一数据类型。

7多形数据类型多形数据类型是指其值的成分不确定的数据类型。

数据结构源代码

数据结构源代码(清华大学+严蔚敏)(总24页)--本页仅作为文档封面，使用时请直接删除即可----内页可以根据需求调整合适字体及大小--void Union(List &La, List Lb) { ur; ata != e) i = S[i].cur; ur为头指针，ur = i+1;space[MAXSIZE-1].cur = 0;} ur;if (space[0].cur) space[0].cur = space[space[0].cur].cur; return i;} ur = space[0].cur; space[0].cur = k;} ur为头指针。

int i, j, k, m, n, p, r;ElemType b;InitSpace_SL(space); ata = random_next_c1(); ata); ur = i; r = i; ur = 0; ur; ur && space[k].data!=b) {ur;}if (k == space[r].cur) {ata = b;space[i].cur = space[r].cur;space[r].cur = i;} else { ur = space[k].cur;Free_SL(space, k);if (r == k) r = p; f", fabs(q->);} else printf("%.2f", q->;if (q->>=1) printf("x");if (q->>1) printf("^%d", q->;}q=q->next;if (++i % 6 == 0) printf("\n ");}printf("\n");return OK;}int Compare(PElemType a, PElemType b) {if < return -1;if > return 1;return 0;}void AddPolyn(PLinkList &Pa, PLinkList &Pb) { Move disk %i from %c to %c\n", ++c, n, x, z);if (n==1)move(x, 1, z); Move disk %i from %cto %c\n",++Count,n,x,z);}== col) {[q].i=[p].j;[q].j =[p].i;[q].e =[p].e; ++q;} }return OK;} ];cpot[1] = 1;; q = cpot[col];[q].i =[p].j; [q].j =[p].i;[q].e =[p].e; ++cpot[col];} ; ; * [q].e;} =arow;[].j=ccol;[].e=ctemp[ccol];} ata,[0].parent);for (j=i; [j].parent>=0; j=[j].parent)printf("\t%d(%d%3d)\n",j,[j].data,[j].parent);return 1;}arent = j;return OK;} arent>[j].parent) { arent+=[i].parent;[i].parent=j;} else { arent+=[j].parent; [j].parent=i;}return OK;} arent>=0; j=[j].parent)printf("\t%d(%d%3d)\n", j, [j].data, [j].parent);for (k=i; k!=j; k=t) {t=[k].parent; [k].parent=j;}return 1;} eight=w[i-1];HT[i].parent=0;HT[i].lchild=0;HT[i].rchild=0;}for (i=n+1; i<=m; i++) { eight=0;HT[i].parent=0;HT[i].lchild=0;HT[i].rchild=0;}printf("\n哈夫曼树的构造过程如下所示：\n");printf("HT初态:\n 结点 weight parent lchild rchild"); for (i=1; i<=m; i++)printf("\n%4d%8d%8d%8d%8d",i,HT[i].weight,HT[i].parent,HT[i].lchild, HT[i].rchild);printf(" 按任意键，继续 ...");getch();for (i=n+1; i<=m; i++) { i-1]中选择parent为0且weight最小的两个结点，arent = i; HT[s2].parent = i;HT[i].lchild = s1; HT[i].rchild = s2;HT[i].weight = HT[s1].weight + HT[s2].weight;printf("\nselect: s1=%d s2=%d\n", s1, s2);printf(" 结点 weight parent lchild rchild");for (j=1; j<=i; j++)printf("\n%4d%8d%8d%8d%8d",j,HT[j].weight,HT[j].parent,HT[j].lchild, HT[j].rchild);printf(" 按任意键，继续 ...");getch();}arent; f!=0; c=f, f=HT[f].parent)child==c) cd[--start] = '0';else cd[--start] = '1';HC[i] = (char *)malloc((n-start)*sizeof(char));eight=w[i-1];HT[i].parent=0;HT[i].lchild=0;HT[i].rchild=0;}for (i=n+1; i<=m; i++) { eight=0;HT[i].parent=0;HT[i].lchild=0;HT[i].rchild=0;}printf("\n哈夫曼树的构造过程如下所示：\n");printf("HT初态:\n 结点 weight parent lchild rchild"); for (i=1; i<=m; i++)printf("\n%4d%8d%8d%8d%8d",i,HT[i].weight,HT[i].parent,HT[i].lchild, HT[i].rchild);printf(" 按任意键，继续 ...");getch();for (i=n+1; i<=m; i++) { i-1]中选择parent为0且weight最小的两个结点，arent = i; HT[s2].parent = i;HT[i].lchild = s1; HT[i].rchild = s2;HT[i].weight = HT[s1].weight + HT[s2].weight;printf("\nselect: s1=%d s2=%d\n", s1, s2);printf(" 结点 weight parent lchild rchild");for (j=1; j<=i; j++)printf("\n%4d%8d%8d%8d%8d",j,HT[j].weight,HT[j].parent,HT[j].lchild, HT[j].rchild);printf(" 按任意键，继续 ...");getch();}eight = 0;while (p) {if (HT[p].weight==0) { eight = 1; if (HT[p].lchild != 0) { p = HT[p].lchild; cd[cdlen++] ='0'; }else if (HT[p].rchild == 0) { eight==1){ eight = 2;if (HT[p].rchild != 0) { p = HT[p].rchild; cd[cdlen++] ='1'; }} else { eight==2，退回退到父结点，编码长度减1HT[p].weight = 0; p = HT[p].parent; --cdlen;}}} dj = INFINITY; nfo= NULL;}for (k=0; k<; ++k ) { dj = w; nfo); dj = [i][j].adj; ata); irstin = [i].firstout = NULL; irstin, [i].firstout, NULL}irstin;p->tlink=[j].firstout;[j].firstin = [i].firstout = p;djvex=u; closedge[j].lowcost=[k][j].adj; }}closedge[k].lowcost = 0; owcost =owcost | closedge[vi].lowcost>0, vi∈V-U }printf(closedge[k].adjvex, [k]); owcost = 0; dj < closedge[j].lowcost) {dj };closedge[j].adjvex=[k];closedge[j].lowcost=[k][j].adj;}}} irstarc;if(p) {v = p->adjvex;DFSArticul(G, v); ata); irstarc; p!=NULL; p=p->nextarc) {ata); vernum-1]InitStack(S);for (i=0; i<; ++i) ata); ++count; irstarc; p;p=p->nextarc) {k = p->adjvex; vernum-1]for (int j=0; j<; ++j) irstarc; p; p=p->nextarc) {k = p->adjvex; irstarc; p; p=p->nextarc) {k=p->adjvex; dut=p->info; irstarc; p; p=p->nextarc) {k=p->adjvex;dut=p->info;ee = ve[j]; el = vl[k]-dut;tag = (ee==el) '*' : ' ';printf(j, k, dut, ee, el, tag); dj;for (w=0; w<; ++w) P[v][w] = FALSE; dj<D[w])) {dj;for(j=0;j<;j++) P[w][j] = P[v][j]; dj;for (u=0; u<; ++u) P[v][w][u] = FALSE;if (D[v][w] < INFINITY) { ey=key; ey!=key; --i); ey)) return mid; ey)) high = mid - 1;high]及其累计权值表swkeynum]中查找i，.m],p->ptr[s...m] int the newpointer *apint i,j,n=q->keynum;ap = (BTree)malloc(sizeof(BTNode));ap->ptr[0] = q->ptr[s];for (i=s+1,j=1; i<=n; i++,j++) {ap->key[j] = q->key[i];ap->ptr[j] = q->ptr[i];}ap->keynum = n-s;ap->parent = q->parent;for (i=0; i<=n-s; i++)m], q->ptr[s..m]和m]移入新结点*aps = (m+1)/2; split(q, s, ap); x = q->key[s];if (q->parent) { ey != NULLKEY) && ey))) ey)))return SUCCESS; ey == NULLKEY)，ey, [i-1].key)) {ey, [j].key); --j)[j+1] = [j]; high]中折半查找有序插入的位置m = (low+high)/2; ey, [m].key)) high = m-1; ext; i-1]中记录已按关键字有序排列，ext;q = [p].next; ext=p;前后记录位置的增量是dk，而不是1；r[0]只是暂存单元，不是哨兵。

清华严蔚敏《数据结构》的全部代码实现C语言,DOC

/*c1.h(程序名)*/#include<string.h>#include<ctype.h>#include<malloc.h>/*malloc()等*/#include<limits.h>/*INT_MAX等*/#include<stdio.h>/*EOF(=^Z或F6),NULL*/ #include<stdlib.h>/*atoi()*/#include<io.h>/*eof()*/#include#include/*#define#define#define#define#define/*algo2-1.c实现算法2.1的程序*/#include"c1.h"typedefintElemType;#include"c2-1.h"/*c2-1.h线性表的动态分配顺序存储结构*/#define LIST_INIT_SIZE10/*线性表存储空间的初始分配量*/#define LISTINCREMENT2/*线性表存储空间的分配增量*/typedefstruct{ElemType*elem;/*存储空间基址*/int length;/*当前长度*/int}SqListStatus{/*(*L).if(!(*Lexit(*L).(*L).return}{/*free((*L(*L).(*L).(*L).return}{/*(*L).return}StatusListEmpty(SqList L){/*初始条件：顺序线性表L已存在。

操作结果：若L为空表，则返回TRUE，否则返回FALSE*/ if(L.length==0)return TRUE;elsereturn FALSE;}int List Length(SqList L)return L.length;}Status Get Elem(SqList L,int i,ElemType*e){/*初始条件：顺序线性表L已存在，1≤i≤ListLength(L)*//*操作结果：用e返回L中第i个数据元素的值*/if(i<1||i>L.length)exit(ERROR);*e=*(L.elem+i-1);return OK;}int Locate Elem(SqList L,ElemType e,Status(*compare)(ElemType,ElemType)) {/*/*/*ElemTypeint i=1;p=L.elemwhile++i;if(i<=L.returnelsereturn}Status{/*/*/*int i=2;ElemTypewhile{p++;i++;}if(i>L.return INFEASIBLE;else{*pre_e=*--p;return OK;}}Status Next Elem(SqList L,ElemType cur_e,ElemType*next_e){/*初始条件：顺序线性表L已存在*//*否则操作失败，next_e无定义*/int i=1;ElemType*p=L.elem;while(i<L.length&&*p!=cur_e){i++;p++;}if(i==L.length)return INFEASIBLE;else{return}}Status{/*/*ElemTypeifreturnif((*L).{)); ifexit(*L).(*L).}q=(*L).for(p=(*q=e;/*++(*L).return}Status ListDelete(SqList*L,int i,ElemType*e)/*算法2.5*/{/*初始条件：顺序线性表L已存在，1≤i≤ListLength(L)*//*操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1*/ElemType*p,*q;if(i<1||i>(*L).length)/*i值不合法*/return ERROR;p=(*L).elem+i-1;/*p为被删除元素的位置*/*e=*p;/*被删除元素的值赋给e*/for(++p;p<=q;++p)/*被删除元素之后的元素左移*/*(p-1)=*p;(*L).length--;/*表长减1*/return OK;}Status ListTraverse(SqList L,void(*vi)(ElemType*)){/*初始条件：顺序线性表L已存在*//*操作结果：依次对L的每个数据元素调用函数vi()。

严蔚敏版数据结构所有算法代码Word版

数据结构(严蔚敏)上机代码完整版

数据结构第一、二次上机：#include <stdio.h>#include <malloc.h>#include <stdlib.h>#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2#define list_init_size 100 //线性表存储空间的初始分配量#define LISTINCREMENT 10 //线性表存储空间的分配增量typedef int Status;typedef int ElemType;typedef struct{ElemType *elem; //存储空间基址int length; //当前长度int listsize; //当前分配的存储容量（以sizeof(ElemType)为单位）}SqList;Status InitList_Sq(SqList &L){//构造一个空的线性表LL.elem =(ElemType * )malloc(list_init_size*sizeof(ElemType));if(!L.elem )exit(OVERFLOW);//存储分配失败L.length =0; //空表长度为0L.listsize =list_init_size;//初始存储容量return OK;}//Initlist_SqStatus ListInsert_Sq(SqList &L,int i,ElemType e){//在顺序线性表L中第i个位置之前插入新的元素e，//i的合法值为1<=i<=ListLength_Sq(L)+1ElemType *p,*q,*newbase; //定义指针if(i<1||i>L.length +1)return ERROR; //i值不合法if(L.length >=L.listsize ){ //当前存储空间已满，增加分配newbase=(ElemType * )realloc(L.elem ,(L.listsize +LISTINCREMENT)*sizeof(ElemType));if(!newbase)exit(OVERFLOW); //存储分配失败L.elem =newbase; //新基址L.listsize +=LISTINCREMENT; //增加存储容量}q=&(L.elem [i-1]); //q为插入位置for(p=&(L.elem [L.length -1]);p>=q;--p)*(p+1)=*p; //插入位置及之后的元素右移*q=e; //插入e++L.length ; //表长增1return OK;}//ListInsert_SqStatus ListDelete_Sq(SqList &L,int i,ElemType &e){//在顺序线性表L中删除第i个元素，并用e返回其值//i的合法值为1<=i<=ListLength_Sq(L)ElemType *p,*q; //定义指针if((i<1) || (i>L.length ))return ERROR; //i值不合法p=&(L.elem [i-1]); //p为被删除元素的位置e=*p; //被删除元素的值赋给eq=L.elem +L.length -1; //表尾元素的位置for(++p;p<=q;++p)*(p-1)=*p; //被删除元素之后的元素左移--L.length ; //表长减1return OK;}//ListDelete_sqvoid display(SqList L){ //定义for循环函数int i;for(i=0;i<=L.length -1;i++)printf("%d\n",L.elem [i]);}int LocateElem_Sq(SqList L,ElemType e){//在顺序线性表L中查找第1个值与e满足compare()的元素的位序//若找到，则返回其在L中的位序，否则返回0ElemType *p;int i=1; //i的初值为第一个元素的位序p=L.elem ; //p的初值为第一个元素的存储位置while(i<=L.length && *p++!=e) ++i;if(i<=L.length) return i;else return 0;}//LocateElem_Sqvoid MergeList_Sq(SqList La,SqList Lb,SqList &Lc ){//已知顺序线性表La和Lb的元素按值非递减排列//归并La和Lb得到新的顺序线性表Lc，Lc的元素也按非递减排列ElemType *pa,*pb,*pc,*pa_last,*pb_last;pa=La.elem ;pb=Lb.elem ;Lc.listsize =Lc.length =La.length +Lb.length ;pc=Lc.elem =(ElemType *)malloc(Lc.listsize *sizeof(ElemType));if(!Lc.elem )exit(OVERFLOW); //存储分配失败pa_last=La.elem +La.length -1;pb_last=Lb.elem +Lb.length -1;while(pa<=pa_last && pb<=pb_last){//归并if(*pa<=*pb)*pc++=*pa++;else*pc++=*pb++;}while(pa<=pa_last) *pc++=*pa++; //插入La的剩余元素while(pb<=pb_last) *pc++=*pb++; //插入Lb的剩余元素}//MergeList_Sqvoid main(){/*SqList L;//定义线性表InitList_Sq(L);//调用空表//插入数据ListInsert_Sq(L,1,10);ListInsert_Sq(L,2,20);ListInsert_Sq(L,1,30);ListInsert_Sq(L,3,40);printf("插入后：\n");display(L);//调用循环函数ListInsert_Sq(L,3,100);//在L表第三个位置插入100printf("插入后：\n");display(L);ElemType e;//定义eListDelete_Sq(L,3,e);//删除L表的第三个元素，用e表示printf("删除后：\n");display(L);printf("被删除元素：%d\n\n\n\n",e);*/SqList La,Lb,Lc;InitList_Sq(La);ListInsert_Sq(La,1,3);ListInsert_Sq(La,2,5);ListInsert_Sq(La,3,8);ListInsert_Sq(La,4,11);printf("La插入后：\n");display(La);InitList_Sq(Lb);ListInsert_Sq(Lb,1,2);ListInsert_Sq(Lb,2,6);ListInsert_Sq(Lb,3,8);ListInsert_Sq(Lb,4,9);ListInsert_Sq(Lb,5,11);ListInsert_Sq(Lb,6,15);ListInsert_Sq(Lb,7,20);printf("Lb插入后：\n");display(Lb);MergeList_Sq(La,Lb,Lc);printf("归并后：\n");display(Lc);printf("\n");int a=LocateElem_Sq( Lc, 5);printf("%d\n",a);}第三次上机：#include <stdio.h>#include <malloc.h>#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int ElemType;typedef struct LNode{ElemType data;struct LNode *next;}LNOde,*LinkList;Status GetElem_L(LinkList L,int i,ElemType &e){//L为带头结点的单链表的头指针//当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR LinkList p;p=L->next;int j=1; //初始化，p指向第一个结点，j为计数器while(p&&j<i){//顺指针向后查找，直到p指向第i个元素或p为空p=p->next;++j;}if(!p||j>i)return ERROR; //第i个元素不存在e=p->data; //取第i个元素return OK;}//GetElem_LStatus ListInsert_L(LinkList &L,int i,ElemType e){//在带头结点的单链线性表L中第i个位置之前插入元素eLinkList p,s;p=L;int j=0;while(p&&j<i-1)p=p->next;++j;} //寻找第i-1个结点if(!p||j>i-1) return ERROR; //i小于或者大于表长+1s=(LinkList)malloc(sizeof(LNode)); //生成新结点s->data=e;s->next=p->next; //插入L中p->next=s;return OK;}//ListInsert_LStatus ListDelete_L(LinkList &L,int i,ElemType &e){//在带头结点的单链线性表L中，删除第i个元素，并由e返回其值LinkList p,q;p=L;int j=0;while(p->next&&j<i-1){//寻找第i个结点，并令p指向其前趋p=p->next;++j;}if(!(p->next)||j>i-1) return ERROR; //删除位置不合理q=p->next;p->next=q->next; //删除并释放结点e=q->data;free(q);return OK;}//ListDelete_Lvoid CreateList_L(LinkList &L,int n){//逆位序输入n个元素的值，建立带表头结点的单链线性表LLinkList p;L=(LinkList)malloc(sizeof(LNode));L->next =NULL; //先建立一个带头结点的单链表for(int i=n;i>0;--i){p=(LinkList)malloc(sizeof(LNode)); //生成新结点scanf("%d",&p->data); //输入元素值p->next=L->next ;L->next =p; //插入到表头}//CreateList_Lvoid display(LinkList L){ LinkList p=L->next;//定义for循环函数while(p){printf("%d,",p->data);p=p->next;}printf("\n");}void main(){LinkList L;CreateList_L(L,3);display(L);ListInsert_L(L,2,100);display(L);ElemType e;ListDelete_L(L,2,e);display(L);printf("被删除的值=%d\n",e);GetElem_L(L,3,e);printf("获取的值=%d\n",e); }第四次上机#include <stdio.h>#include <malloc.h>#include <stdlib.h>#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int SElemType;typedef int Status;#define STACK_INIT_SIZE 100 //存储空间初始分配量#define STRCKINCREMENT 10 //存储空间分配增量typedef struct{SElemType *base; //在栈构造之前和销毁之后，base的值为NULL SElemType *top; //栈顶指针int stacksize; //当前已分配的存储空间，以元素为单位}SqStack;Status InitStack(SqStack &S){//构造一个空栈SS.base =(SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));if(!S.base )exit(OVERFLOW); //存储分配失败S.top =S.base ;S.stacksize =STACK_INIT_SIZE;return OK;}//InitStackStatus GetTop(SqStack S,SElemType &e){//若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERRORif(S.top ==S.base )return ERROR;e=*(S.top -1);return OK;}//GetTopStatus Push(SqStack &S,SElemType e){//插入元素e为新的栈顶元素if(S.top - S.base >=S.stacksize ){//栈满，追加存储空间S.base =(SElemType * )realloc(S.base ,(S.stacksize +STRCKINCREMENT) * sizeof(SElemType));if(!S.base )exit(OVERFLOW); //存储分配失败S.top =S.base +S.stacksize ;S.stacksize +=STRCKINCREMENT;}*S.top ++=e;return OK;}//PushStatus Pop(SqStack &S,SElemType &e){//若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR if(S.top ==S.base )return ERROR;e=*--S.top ;return OK;}//PopStatus StackEmpty(SqStack S){if(S.top==S.base)return TRUE;else return ERROR;}void conversion(){//对于输入的任意一个非负十进制整数，打印输出与其等值的八进制数SqStack S;int N;SElemType e;InitStack(S); //构造空栈scanf("%d",&N);while(N){Push(S,N % 8);N=N/8;}printf("转换成八进制后的数为：");while(!StackEmpty(S)){Pop(S,e);printf("%d",e);}printf("\n");}//conversionvoid main(){SqStack S;SElemType e,x;InitStack(S);Push(S,5);Push(S,4);Push(S,3);Push(S,2);Push(S,1);GetTop(S,e);printf("栈顶元素为%d\n",e);printf("\n");Pop(S,x);printf("删除的栈顶元素为%d\n",x);printf("\n");printf("输入一个十进制数：");conversion();}第五次上机/*队列的链式存储*/#include <stdio.h>#include <malloc.h>#include <stdlib.h>#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int QElemType;typedef int Status;typedef struct QNode{QElemType data;struct QNode *next;}QNode,*QueuePtr;typedef struct{QueuePtr front; //队头指针QueuePtr rear; //队尾指针}LinkQueue;Status InitQueue(LinkQueue &Q){//构造一个空队列QQ.front =Q.rear =(QueuePtr)malloc(sizeof(QNode));if(!Q.front )exit(OVERFLOW); //存储分配失败Q.front ->next =NULL;return OK;}Status DestroyQueue(LinkQueue &Q){//销毁队列Qwhile(Q.front ){Q.rear =Q.front ->next ;free(Q.front );Q.front =Q.rear ;}return OK;}Status EnQueue(LinkQueue &Q,QElemType e){//插入元素e为Q的新的队尾元素QueuePtr p;p=(QueuePtr)malloc(sizeof(QNode));if(!p)exit(OVERFLOW); //存储分配失败p->data=e;p->next=NULL;Q.rear ->next =p;Q.rear =p;return OK;}Status DeQueue(LinkQueue &Q,QElemType &e){//若队列不为空，则删除Q的队头元素，用e返回其值，并返回OK；//否则返回ERRORQueuePtr p;if(Q.front ==Q.rear )return ERROR;p=Q.front ->next ;e=p->data;Q.front ->next =p->next;if(Q.rear ==p)Q.rear =Q.front ;return OK;}void disp(LinkQueue Q){QueuePtr p;p=Q.front->next;//定义for 循环函数while(p){printf("%d ",p->data);p=p->next;}printf("\n");}void main(){LinkQueue Q;QElemType e;InitQueue(Q);printf("插入的元素为：\n");EnQueue(Q,25);EnQueue(Q,5);EnQueue(Q,12);EnQueue(Q,60);EnQueue(Q,33);disp(Q);printf("删除队头元素后：\n");DeQueue(Q,e);disp(Q);DestroyQueue(Q);if(DestroyQueue(Q)==1)printf("销毁队列成功！\n");elseprintf("销毁队列失败！\n");}附加：/*队列的顺序存储*/#define MAXQSIZE 100 //最大队列长度QElemType *base //初始化的动态分配存储空间int front; //头指针，若队列不空，指向队列头元素int rear; //尾指针，若队列不空，指向队列尾元素的下一个位置}SqQueue;Status InitQueue(SqQueue &Q){//构造一个空队列Q.base =(QElemType *)malloc(MAXQSIZE * sizeof(QElemType));if(!Q.base )exit(OVERFLOW); //存储分配失败Q.front =Q.rear =0;return OK;}int QueueLenth(SqQueue Q){//返回Q的元素个数，即队列的长度return(Q.rear -Q.front +MAXQSIZE)%MAXQSIZE;}Status EnQueue(SqQueue &Q,QElemType e){//插入元素e为Q的新的队尾元素if((Q.rear +1) % MAXQSIZE ==Q.front) return ERROR; //队列满Q.base [Q.rear ]=e;Q.rear =(Q.rear +1) % MAXQSIZE;return OK;}Status DeQueue(SqQueue &Q,QElemType &e){//若队列不为空，则删除Q的队头元素，用e返回其值，并返回OK；//否则返回ERRORif(Q.front ==Q.rear ) return ERROR;e=Q.base [Q.front ];Q.front =(Q.front +1)% MAXQSIZE;return OK;}第六次上机#include <stdio.h>#include <malloc.h>#include <stdlib.h>#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef char TElemType;//二叉树的二叉链表存储表示typedef struct BiTNode{TElemType data;struct BiTNode *lchild,*rchild; //左右孩子指针}BiTNode,*BiTree;Status CreateBiTree(BiTree &T){//按先序次序输入二叉树中结点的值（一个字符），空格字符表示空树，//构造二叉树链表表示的二叉树Tchar ch;scanf("%c",&ch);if(ch==' ')T=NULL;else{if(!(T=(BiTNode *)malloc(sizeof(BiTNode)))) exit(OVERFLOW);T->data =ch; //生成根结点CreateBiTree(T->lchild ); //构造左子树CreateBiTree(T->rchild ); //构造右子树}return OK;}//CreateBiTreevoid PreOrderTraverse(BiTree T){//先序遍历if(T){printf("%c ",T->data ); //输出结点PreOrderTraverse(T->lchild );PreOrderTraverse(T->rchild );}}void InOrderTraverse(BiTree T){//中序遍历if(T){PreOrderTraverse(T->lchild );printf("%c ",T->data );PreOrderTraverse(T->rchild );}}void PostOrderTraverse(BiTree T){ //后序遍历if(T){PreOrderTraverse(T->lchild );PreOrderTraverse(T->rchild );printf("%c ",T->data );}}void main(){BiTree T;CreateBiTree(T);printf("\n PreOrder: \n ");PreOrderTraverse(T);}选择是难，更何况是心灵选择。

清华严蔚敏《大数据结构》地全部代码实现C语言

/* c1.h (程序名) */#include<string.h>#include<ctype.h>#include<malloc.h> /* malloc()等 */#include<limits.h> /* INT_MAX等 */#include<stdio.h> /* EOF(=^Z或F6),NULL */#include<stdlib.h> /* atoi() */#include<io.h> /* eof() */#include<math.h> /* floor(),ceil(),abs() */#include<process.h> /* exit() *//* 函数结果状态代码 */#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1/* #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行 */ typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */ typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE *//* algo2-1.c 实现算法2.1的程序 */#include"c1.h"typedef int ElemType;#include"c2-1.h"/*c2-1.h 线性表的动态分配顺序存储结构 */#define LIST_INIT_SIZE 10 /* 线性表存储空间的初始分配量 */#define LISTINCREMENT 2/* 线性表存储空间的分配增量 */typedef struct{ElemType*elem; /* 存储空间基址 */int length; /* 当前长度 */int listsize; /* 当前分配的存储容量(以sizeof(ElemType)为单位) */ }SqList;#include"bo2-1.c"/* bo2-1.c 顺序表示的线性表(存储结构由c2-1.h定义)的基本操作(12个) */ Status InitList(SqList*L) /* 算法2.3 */{ /* 操作结果：构造一个空的顺序线性表 */(*L).elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!(*L).elem)exit(OVERFLOW); /* 存储分配失败 */(*L).length=0; /* 空表长度为0 */(*L).listsize=LIST_INIT_SIZE; /* 初始存储容量 */return OK;}Status DestroyList(SqList*L){ /* 初始条件：顺序线性表L已存在。

数据结构源代码(清华大学+严蔚敏)

void Union(List &La, List Lb) { // 算法2.1// 将所有在线性表Lb中但不在La中的数据元素插入到La中int La_len,Lb_len,i;ElemType e;La_len = ListLength(La); // 求线性表的长度Lb_len = ListLength(Lb);for (i=1; i<=Lb_len; i++) {GetElem(Lb, i, e); // 取Lb中第i个数据元素赋给e if (!LocateElem(La, e, equal)) // La中不存在和e相同的数据元素ListInsert(La, ++La_len, e); // 插入}} // unionvoid MergeList(List La, List Lb, List &Lc) { // 算法2.2// 已知线性表La和Lb中的元素按值非递减排列。

// 归并La和Lb得到新的线性表Lc，Lc的元素也按值非递减排列。

int La_len, Lb_len;ElemType ai, bj;int i=1, j=1, k=0;InitList(Lc);La_len = ListLength(La);Lb_len = ListLength(Lb);while ((i <= La_len) && (j <= Lb_len)) { // La和Lb均非空GetElem(La, i, ai);GetElem(Lb, j, bj);if (ai <= bj) {ListInsert(Lc, ++k, ai);++i;} else {ListInsert(Lc, ++k, bj);++j;}}while (i <= La_len) {GetElem(La, i++, ai); ListInsert(Lc, ++k, ai);}while (j <= Lb_len) {GetElem(Lb, j++, bj); ListInsert(Lc, ++k, bj);}} // MergeListStatus InitList_Sq(SqList &L) { // 算法2.3// 构造一个空的线性表L。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

/* c1.h (程序名) */#include<string.h>#include<ctype.h>#include<malloc.h> /* malloc()等*/#include<limits.h> /* INT_MAX等*/#include<stdio.h> /* EOF(=^Z或F6),NULL */#include<stdlib.h> /* atoi() */#include<io.h> /* eof() */#include<math.h> /* floor(),ceil(),abs() */#include<process.h> /* exit() *//* 函数结果状态代码*/#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1/* #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行*/ typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等*/ typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE *//* algo2-1.c 实现算法2.1的程序*/#include"c1.h"typedef int ElemType;#include"c2-1.h"/*c2-1.h 线性表的动态分配顺序存储结构*/#define LIST_INIT_SIZE 10 /* 线性表存储空间的初始分配量*/#define LISTINCREMENT 2/* 线性表存储空间的分配增量*/typedef struct{ElemType*elem; /* 存储空间基址*/int length; /* 当前长度*/int listsize; /* 当前分配的存储容量(以sizeof(ElemType)为单位) */}SqList;#include"bo2-1.c"/* bo2-1.c 顺序表示的线性表(存储结构由c2-1.h定义)的基本操作(12个) */ Status InitList(SqList*L) /* 算法2.3 */{ /* 操作结果：构造一个空的顺序线性表*/(*L).elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!(*L).elem)exit(OVERFLOW); /* 存储分配失败*/(*L).length=0; /* 空表长度为0 */(*L).listsize=LIST_INIT_SIZE; /* 初始存储容量*/return OK;}Status DestroyList(SqList*L){ /* 初始条件：顺序线性表L已存在。

操作结果：销毁顺序线性表L */ free((*L).elem);(*L).elem=NULL;(*L).length=0;(*L).listsize=0;return OK;}Status ClearList(SqList*L){ /* 初始条件：顺序线性表L已存在。

操作结果：将L重置为空表*/ (*L).length=0;return OK;}Status ListEmpty(SqList L){ /* 初始条件：顺序线性表L已存在。

操作结果：若L为空表，则返回TRUE，否则返回FALSE */if(L.length==0)return TRUE;elsereturn FALSE;}int List Length(SqList L){ /* 初始条件：顺序线性表L已存在。

操作结果：返回L中数据元素个数*/return L.length;}Status Get Elem(SqList L,int i,ElemType *e){ /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) *//* 操作结果：用e返回L中第i个数据元素的值*/if(i<1||i>L.length)exit(ERROR);*e=*(L.elem+i-1);return OK;}int Locate Elem(SqList L,ElemType e,Status(*compare)(ElemType,ElemType)){ /* 初始条件：顺序线性表L已存在，compare()是数据元素判定函数(满足为1,否则为0) */ /* 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。

*//* 若这样的数据元素不存在，则返回值为0。

算法2.6 */ElemType *p;int i=1; /* i的初值为第1个元素的位序*/p=L.elem; /* p的初值为第1个元素的存储位置*/while(i<=L.length&&!compare(*p++,e))++i;if(i<=L.length)return i;elsereturn 0;}Status Prior Elem(SqList L,ElemType cur_e,ElemType *pre_e){ /* 初始条件：顺序线性表L已存在*//* 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，*/ /* 否则操作失败，pre_e无定义*/int i=2;ElemType *p=L.elem+1;while(i<=L.length&&*p!=cur_e){p++;i++;}if(i>L.length)return INFEASIBLE;else{*pre_e=*--p;return OK;}}Status Next Elem(SqList L,ElemType cur_e,ElemType *next_e){ /* 初始条件：顺序线性表L已存在*//* 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，*/ /* 否则操作失败，next_e无定义*/int i=1;ElemType *p=L.elem;while(i<L.length&&*p!=cur_e){i++;p++;}if(i==L.length)return INFEASIBLE;else{*next_e=*++p;return OK;}}Status ListInsert(SqList*L,int i,ElemType e) /* 算法2.4 */{ /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1 *//* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */ElemType *newbase,*q,*p;if(i<1||i>(*L).length+1) /* i值不合法*/return ERROR;if((*L).length>=(*L).listsize) /* 当前存储空间已满,增加分配*/{newbase=(ElemType*)realloc((*L).elem,((*L).listsize+LISTINCREMENT)*sizeof(ElemType));if(!newbase)exit(OVERFLOW); /* 存储分配失败*/(*L).elem=newbase; /* 新基址*/(*L).listsize+=LISTINCREMENT; /* 增加存储容量*/}q=(*L).elem+i-1; /* q为插入位置*/for(p=(*L).elem+(*L).length-1;p>=q;--p) /* 插入位置及之后的元素右移*/*(p+1)=*p;*q=e; /* 插入e */++(*L).length; /* 表长增1 */return OK;}Status ListDelete(SqList*L,int i,ElemType *e) /* 算法2.5 */{ /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) *//* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */ ElemType *p,*q;if(i<1||i>(*L).length) /* i值不合法*/return ERROR;p=(*L).elem+i-1; /* p为被删除元素的位置*/*e=*p; /* 被删除元素的值赋给e */q=(*L).elem+(*L).length-1; /* 表尾元素的位置*/for(++p;p<=q;++p) /* 被删除元素之后的元素左移*/*(p-1)=*p;(*L).length--; /* 表长减1 */return OK;}Status ListTraverse(SqList L,void(*vi)(ElemType*)){ /* 初始条件：顺序线性表L已存在*//* 操作结果：依次对L的每个数据元素调用函数vi()。

一旦vi()失败，则操作失败*/ /* vi()的形参加'&'，表明可通过调用vi()改变元素的值*/ElemType *p;int i;p=L.elem;for(i=1;i<=L.length;i++)vi(p++);pr int f("\n");return OK;}Status equal(ElemType c1,ElemType c2){ /* 判断是否相等的函数，Union()用到*/if(c1==c2)return TRUE;elsereturn FALSE;}void Union(SqList*L a,SqList Lb) /* 算法2.1 */{ /* 将所有在线性表Lb中但不在La中的数据元素插入到La中*/ ElemType e;int La_len,Lb_len;int i;La_len=List Length(*L a); /* 求线性表的长度*/Lb_len=List Length(Lb);for(i=1;i<=Lb_len;i++){Get Elem(Lb,i,&e); /* 取Lb中第i个数据元素赋给e */if(!Locate Elem(*L a,e,equal)) /* La中不存在和e相同的元素,则插入之*/ ListInsert(La,++La_len,e);}}void pr int(ElemType *c){pr int f("%d ",*c);}void main(){SqList La,Lb;Status i;int j;i=InitList(&La);if(i==1) /* 创建空表La成功*/for(j=1;j<=5;j++) /* 在表La中插入5个元素*/i=ListInsert(&La,j,j);pr int f("La= "); /* 输出表La的容*/ListTraverse(La,pr int);InitList(&Lb); /* 也可不判断是否创建成功*/for(j=1;j<=5;j++) /* 在表Lb中插入5个元素*/i=ListInsert(&Lb,j,2*j);pr int f("Lb= "); /* 输出表Lb的容*/ListTraverse(Lb,pr int);Union(&La,Lb);pr int f("new La= "); /* 输出新表La的容*/ListTraverse(La,pr int);}/* algo2-2.c 实现算法2.2的程序*/#include"c1.h"typedef int ElemType;#include"c2-1.h"#include"bo2-1.c"void MergeList(SqList La,SqList Lb,SqList*L c) /* 算法2.2 */{ /* 已知线性表La和Lb中的数据元素按值非递减排列。