实验1-线性表的顺序实现
- lab1_01_ans.c
/**********************************/
/*文件名称：lab1-01.c */
/**********************************/
/*基于sequlist.h中定义的顺序表，编写算法函数reverse(sequence_list *L)，实现顺序表的就地倒置。*/
#include "sequlist.h"
/*请将本函数补充完整，并进行测试*/
void reverse(sequence_list *L)
{
int i,j;
datatype x;
i=0;
j=L->size-1;
while (i<j)
{
x=L->a[i];
L->a[i]=L->a[j];
L->a[j]=x;
i++;
j--;
}
}
- lab1_02_ans.c
/**********************************/
/*文件名称：lab1_02.c */
/**********************************/
/*编写一个算法函数void sprit( sequence_list *L1,sequence_list *L2,sequence_list *L3)，
将顺序表L1中的数据进行分类，奇数存放到存到顺序表L2中，偶数存到顺序表L3中，编写main()进行测试。
*/
#include "sequlist.h"
/*请将本函数补充完整，并进行测试*/
void sprit(sequence_list *L1,sequence_list *L2,sequence_list *L3)
{
int i,j,k;
i=j=k=0;
for (i=0;i<L1->size;i++)
{
if (L1->a[i]%2==1)
L2->a[j++]=L1->a[i];
else
L3->a[k++]=L1->a[i];
}
L2->size=j;
L3->size=k;
}
- lab1_03_ans.c
/*已知顺序表L1，L2中数据由小到大有序，请用尽可能快的方法将L1与L2中的数据合并到L3中，使数据在L3中按升序排列。*/
#include "sequlist.h"
/*请将本函数补充完整，并进行测试*/
void merge(sequence_list *L1,sequence_list *L2,sequence_list *L3)
{
int i,j,k;
i=j=k=0;
while (i<L1->size && j<L2->size )
{
if (L1->a[i]<L2->a[j])
L3->a[k++]=L1->a[i++];
else
L3->a[k++]=L2->a[j++];
}
while (i<L1->size)
L3->a[k++]=L1->a[i++];
while (j<L2->size)
L3->a[k++]=L2->a[j++];
L3->size=k;
}
- lab1_04_ans.c
/*假设顺序表la与lb分别存放两个整数集合，函数inter(seqlist *la,seqlist *lb,seqlist *lc)
的功能是实现求顺序表la与lb的交集存放到顺序表lc中,请将函数补充完整. */
/**********************************/
/*文件名称：lab1_04.c */
/**********************************/
#include "sequlist.h"
/*请将本函数补充完整，并进行测试*/
void inter(sequence_list *la,sequence_list *lb,sequence_list *lc)
{
int i,j,k;
k=0;
for (i=0; i<la->size; i++)
{
j=0;
while (j<lb->size && la->a[i]!=lb->a[j])
j++;
if (j<lb->size)
lc->a[k++]=la->a[i];
}
lc->size=k;
}
- lab1_05_ans.c
/*
请编写一个算法函数partion(sequence_list *L)，尽可能快地将顺序表L中的所有奇数调整到表的左边，
所有偶数调整到表的右边，并分析算法的时间复杂度。
*/
/**********************************/
/*文件名称：lab1_05.c */
/**********************************/
#include "sequlist.h"
/*请将本函数补充完整，并进行测试*/
void partion(sequence_list *L)
{
int i,j;
datatype x;
i=0;
j=L->size-1;
do
{
while (i<j && L->a[i]%2==1 )
i++;
while (i<j && (L->a[j]&0x1)==0)
j--;
if (i<j)
{
x=L->a[i];
L->a[i++]=L->a[j];
L->a[j--]=x;
}
}while (i<j);
}
实验2-不带头结点的单链表
- lab2_01_ans.c
/*编写函数slnklist delx(linklist head, datatype x)，删除不带头结点单链表head中第一个值为x 的结点。
并构造测试用例进行测试。
*/
/**********************************/
/*文件名称：lab2_01.c */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
linklist delx(linklist head,datatype x)
{
linklist pre,p;
pre=NULL;
p=head;
while (p &&p->info!=x)
{
pre=p;
p=p->next;
}
if (p)
{
if (pre==NULL)
head=p->next;
else
pre->next=p->next;
free(p);
}
return head;
}
- lab2_02_ans.c
/**********************************/
/*文件名称：lab2_02.c */
/**********************************/
/*
假设线性表（a1,a2,a3,…an）采用不带头结点的单链表存储，
请设计算法函数linklist reverse1(linklist head)和
void reverse2(linklist *head)将不带头结点的单链表head就地倒置，
使表变成（an,an-1,…a3.a2,a1）。并构造测试用例进行测试。
*/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
linklist reverse1(linklist head)
{
linklist p,s;
p=head;
head=NULL;
while (p)
{
s=p;
p=p->next;
s->next=head;
head=s;
}
return head;
}
void reverse2(linklist *head)
{
linklist p,s;
p=*head;
*head=NULL;
while (p)
{
s=p;
p=p->next;
s->next=*head;
*head=s;
}
}
- lab2_03_ans.c
/*
假设不带头结点的单链表head是升序排列的，设计算法函数linklist insert(linklist head,datatype x)，
将值为x的结点插入到链表head中，并保持链表有序性。
分别构造插入到表头、表中和表尾三种情况的测试用例进行测试。
*/
/**********************************/
/*文件名称：lab2_03.c */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
linklist insert(linklist head ,datatype x)
{
linklist pre,p,s;
pre=NULL;
p=head;
while ( p && p->info<x )
{
pre=p;
p=p->next;
}
s=(linklist )malloc(sizeof(node));
s->info=x;
if (pre==NULL)
{
s->next=head;
head=s;
}
else
{
s->next=p;
pre->next=s;
}
return head;
}
- lab2_04_ans.c
/*
编写算法函数linklist delallx(linklist head, int x)，删除不带头结点单链表head中所有值为x的结点。
*/
/**********************************/
/*文件名称：lab2_04.c */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
linklist delallx(linklist head,int x)
{
linklist pre,p;
pre=NULL;
p=head;
while(p)
{
while (p &&p->info!=x) //找值为x的结点
{
pre=p;
p=p->next;
}
if (p) //找到了
{
if (pre==NULL) //删除的结点为第一个结点
{
head=p->next;
free(p);
p=head;
}
else //删除的结点不是第一个结点
{
pre->next=p->next;
free(p);
p=pre->next;
}
}
}
return head;
}
实验3-带头结点的单链表
- lab3_01_ans.c
/*编写函数void delx(linklist head, datatype x)，删除带头结点单链表head中第一个值为x 的结点。
并构造测试用例进行测试。
*/
/**********************************/
/*文件名称：lab3_01.c */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
void delx(linklist head,datatype x)
{
linklist pre,p;
pre=head;
p=head->next;
while (p && p->info!=x) //查找
{
pre=p;
p=p->next;
}
if (p) //删除
{
pre->next=p->next;
free(p);
}
}
- lab3_02_ans.c
/**********************************/
/*文件名称：lab3_02.c */
/**********************************/
/*
假设线性表（a1,a2,a3,…an）采用带头结点的单链表存储，请设计算法函数void reverse(linklist head)，
将带头结点的单链表head就地倒置，使表变成（an,an-1,…a3.a2,a1）。并构造测试用例进行测试。
*/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
void reverse(linklist head)
{
linklist p,s;
p=head->next;
head->next=NULL;
while (p)
{
s=p;
p=p->next;
s->next=head->next;
head->next=s;
}
}
- lab3_03_ans.c
/*
假设带头结点的单链表head是升序排列的，设计算法函数linklist insert(linklist head,datatype x)，
将值为x的结点插入到链表head中，并保持链表有序性。
分别构造插入到表头、表中和表尾三种情况的测试用例进行测试。
*/
/**********************************/
/*文件名称：lab3_03.c */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
void insert(linklist head ,datatype x)
{
linklist pre,p,s;
pre=head;
p=head->next;
while (p && p->info<x)
{
pre=p;
p=p->next;
}
s=(linklist)malloc(sizeof(node));
s->info=x;
s->next=p;
pre->next=s;
}
- lab3_04_ans.c
/*
编写算法函数void delallx(linklist head, int x)，删除带头结点单链表head中所有值为x的结点。
*/
/**********************************/
/*文件名称：lab3_04.c */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
void delallx(linklist head,int x)
{
linklist pre,p;
pre=head;
p=head->next;
while(p)
{
while (p &&p->info!=x) //查找
{
pre=p;
p=p->next;
}
if (p) //找到了
{
pre->next=p->next;
free(p);
p=pre->next; //删除后p回到pre的后继结点
}
}
}
- lab3_05_ans.c
/*
已知线性表存储在带头结点的单链表head中，请设计算法函数void sort(linklist head)，将head中的结点按结点值升序排列。
*/
/**********************************/
/*文件名称：lab3_05.c */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
void sort(linklist head)
{
linklist pre,q,p,s;
p=head->next;
head->next=NULL;
while (p)
{
s=p;
p=p->next; //取结点
pre=head;
q=head->next;
while (q && q->info<s->info) //找位置
{
pre=q;
q=q->next;
}
s->next=q; //将s指示的结点插入到pre与q指示的结点中间
pre->next=s;
}
}
- lab3_06_ans.c
/*
已知两个带头结点的单链表L1和L2中的结点值均已按升序排序，设计算法函数
linklist mergeAscend (linklist L1,linklist L2)将L1和L2合并成一个升序的
带头结单链表作为函数的返回结果；
设计算法函数linklist mergeDescend (linklist L1,linklist L2)
将L1和L2合并成一个降序的带头结单链表作为函数的返回结果；
并设计main()函数进行测试。
*/
/**********************************/
/*文件名称：lab3_06.c */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
linklist mergeAscend(linklist L1,linklist L2)
{
linklist L3,r3,p,q;
L3=r3=(linklist)malloc(sizeof(node));
p=L1->next;
q=L2->next;
while (p && q)
{
if (p->info<q->info)
{
L1->next=p->next;
r3->next=p;
r3=p;
p=L1->next;
}
else
{
L2->next=q->next;
r3->next=q;
r3=q;
q=L2->next;
}
}
if (p) r3->next=p;
if (q) r3->next=q;
free(L1);
free(L2);
return L3;
}
linklist mergeDescend(linklist L1,linklist L2)
{
linklist L3,r3,p,q;
L3=(linklist)malloc(sizeof(node));
L3->next=NULL;
p=L1->next;
q=L2->next;
while (p && q)
{
if (p->info<q->info)
{
L1->next=p->next;
p->next=L3->next;
L3->next=p;
p=L1->next;
}
else
{
L2->next=q->next;
q->next=L3->next;
L3->next=q;
q=L2->next;
}
}
while (p)
{
L1->next=p->next;
p->next=L3->next;
L3->next=p;
p=L1->next;
}
while (q)
{
L2->next=q->next;
q->next=L3->next;
L3->next=q;
q=L2->next;
}
free(L1);
free(L2);
return L3;
}
- lab3_07_ans.c
/*
设计一个算法linklist interSection(linklist L1,linklist L2)，
求两个单链表表示的集合L1和L2的交集，并将结果用一个新的带头
结点的单链表保存并返回表头地址。
*/
/**********************************/
/*文件名称：lab3_07.c */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
linklist interSection(linklist L1, linklist L2)
{
linklist head,r,p,q,s;
head=r=(linklist)malloc(sizeof(node));
p=L1->next;
while (p)
{
q=L2->next;
while (q && q->info!=p->info)
q=q->next;
if (q)//查找成功
{
s=(linklist)malloc(sizeof(node));
s->info=p->info;
r->next=s;
r=s;
}
p=p->next;
}
r->next=NULL;
return head;
}
- lab3_08_ans.c
/*
请编写一个算法函数void partion(linklist head)，
将带头结点的单链表head中的所有值为奇数的结点调整
到链表的前面，所有值为偶数的结点调整到链表的后面。
*/
/**********************************/
/*文件名称：lab3_08.c */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
void partion(linklist head)
{
linklist pre,p;
pre=head;
p=head->next;
while (p &&p->info%2==1)
{
pre=p;
p=p->next;
}
while (p)
{
while (p &&p->info%2==0)
{
pre=p;
p=p->next;
}
if (p)
{
pre->next=p->next;
p->next=head->next;
head->next=p;
p=pre->next;
}
}
}
- lab3_09_ans.c
/*
编写一个程序，用尽可能快的方法返回带头结点单链表中倒数第k个结点的地址，如果不存在，则返回NULL。
*/
/**********************************/
/*文件名称：lab3_09.c */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
linklist search(linklist head,int k)
{
linklist pre,p;
int count=0;
p=head->next;
while (p && count<k)
{
p=p->next;
count++;
}
if (count<k) return NULL;
pre=head->next;
while (p)
{
pre=pre->next;
p=p->next;
}
return pre;
}
实验4-栈与字符串
- lab4_01_ans.c
/*
利用顺序栈结构，编写算法函数void Dto16(unsigned int m)实现十进制无符号整数m到十六进制数的转换功能。
*/
/**********************************/
/*文件名称：lab4_01.c */
/**********************************/
#include "seqstack.h"
/*请将本函数补充完整，并进行测试*/
void Dto16(int m)
{ seqstack s; /*定义顺序栈*/
init(&s);
printf("十进制数%u对应的十六进制数是：",m);
while (m)
{
push(&s,m%16);
m/=16;
}
while (!empty(&s))
putchar( read(&s)<10? pop(&s)+48: pop(&s)+55 );
printf("
");
}
- lab4_02_ans.c
/*
利用链式栈结构，编写算法函数void Dto16(unsigned int m)实现十进制无符号整数m到十六进制数的转换功能。
*/
/**********************************/
/*文件名称：lab4_02.c */
/**********************************/
#include "linkstack.h"
/*请将本函数补充完整，并进行测试*/
void Dto16(unsigned int m)
{
linkstack s;
s=init();
printf("十进制数%u对应的十六进制数是：",m);
while (m)
{
s=push(s,m%16);
m/=16;
}
while (!empty(s))
{
printf("%x", read(s));
s=pop(s);
}
printf("
");
}
- lab4_04_ans.c
/*
已知字符串采用带结点的链式存储结构（详见linksrting.h文件），
请编写函数linkstring substring(linkstring s,int i,int len)，
在字符串s中从第i个位置起取长度为len的子串，函数返回子串链表。
*/
#include "linkstring.h"
/*请将本函数补充完整，并进行测试*/
linkstring substring(linkstring s, int i, int len)
{
linkstring head,r,q,p;
int k=1;
head=r=(linkstring)malloc(sizeof(linknode));
r->next=NULL;
p=s->next;
while (p && k<i) //找子串起点
{
p=p->next;
k++;
}
if (!p) return head; //起点超过链表长度
else
{
k=1;
while (p && k<=len) //生成子串链表
{
q=(linkstring)malloc(sizeof(linknode));
q->data=p->data;
r->next=q;
r=q;
p=p->next;
k++;
}
r->next=NULL;
return head;
}
}
- lab4_05_ans.c
/*
字符串采用带头结点的链表存储，设计算法函数void delstring(linkstring s, int i,int len)
在字符串s中删除从第i个位置开始，长度为len的子串。
*/
/**********************************/
/*文件名称：lab4_05.c */
/**********************************/
#include "linkstring.h"
/*请将本函数补充完整，并进行测试*/
void delstring(linkstring s, int i, int len)
{
linkstring p,q;
int k=1;
p=s->next;
while (p && k<i-1) //查找待删除子串的起始结点的前驱结点
{
p=p->next;
k++;
}
if (!p || !p->next) return ;
else
{
k=0;
while (p->next && k<len)
{
q=p->next;
p->next=q->next;
free(q);
k++;
}
}
}
- lab4_06_ans.c
/*
字符串采用带头结点的链表存储，编写函数linkstring index(linkstring s, linkstring t)，
查找子串t在主串s中第一次出现的位置，若匹配不成功，则返回NULL。
*/
#include "linkstring.h"
/*请将本函数补充完整，并进行测试*/
linkstring index(linkstring s, linkstring t)
{
linkstring p,s1,t1;
p=s->next;
while (p) //p记录匹配起点
{
s1=p; //s1记录主串比较的当前位置
t1=t->next; //t1记录子串比较的当前位置
while (s1 && t1 && s1->data==t1->data)
{
s1=s1->next;
t1=t1->next;
}
if (t1==NULL) return p;
p=p->next;
}
return NULL;
}
- lab4_07_ans.c
/*
利用朴素模式匹配算法，将模式t在主串s中所有出现的位置存储在带头结点的单链表中。
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef struct node
{ int data;
struct node *next;
}linknode;
typedef linknode *linklist;
/*朴素模式匹配算法,返回t中s中第一次出现的位置，没找到则返回-1，请将程序补充完整*/
int index(char *s,char *t)
{ int i,k,j;
int n,m;
n=strlen(s);
m=strlen(t);
for (i=0;i<n-m+1;i++)
{
k=i;
j=0;
while (j<m)
{
if (s[k]==t[j]) {k++;j++;}
else
break;
}
if (j==m) return i;
}
return -1;
}
/*利用朴素模式匹配算法，将模式t在s中所有出现的位置存储在带头结点的单链表中,请将函数补充完整*/
linklist indexall(char *s,char *t)
{
linklist head,r,p;
int i,k,j;
int n,m;
n=strlen(s);
m=strlen(t);
head=r=(linklist)malloc(sizeof(linknode));
for (i=0;i<n-m+1;i++)
{
k=i;
j=0;
while (j<m)
{
if (s[k]==t[j]) {k++;j++;}
else
break;
}
if (j==m) //匹配成功
{
p=(linklist)malloc(sizeof(linknode));
p->data=i;
r->next=p;
r=p;
}
}
r->next=NULL;
return head;
}
/*输出带头结点的单链表*/
void print(linklist head)
{ linklist p;
p=head->next;
while(p)
{ printf("%5d",p->data);
p=p->next;
}
printf("
");
}
- lab4_08_ans.c
/*
编写快速模式匹配KMP算法，请将相关函数补充完整。
*/
#define maxsize 100
typedef struct{
char str[maxsize];
int length ;
} seqstring;
/*求模式p的next[]值，请将函数补充完整*/
void getnext(seqstring p,int next[])
{
int i,j;
next[0]=-1;
i=0;j=-1;
while(i<p.length)
{
if(j==-1||p.str[i]==p.str[j])
{++i;++j;next[i]=j;}
else
j=next[j];
}
for(i=0;i<p.length;i++)
printf("%d",next[i]);
}
/*快速模式匹配算法，请将函数补充完整*/
int kmp(seqstring t,seqstring p,int next[])
{
int i,j;
i=0;j=0;
while (i<t.length && j<p.length)
{
if(j==-1||t.str[i]==p.str[j])
{i++; j++;}
else j=next[j];
}
if (j==p.length) return (i-p.length);
else return(-1);
}
实验5-递归
- lab5_01_ans.c
/*
编写递归算法int max(int a[],int left, int right)，求数组a[left..right]中的最大数。
*/
#include "ArrayIo.h"
/*请将本函数补充完整，并进行测试*/
int max(int a[],int left,int right)
{
int lmax,rmax,mid;
if (left==right) return a[left];
else
{
mid=(left+right)/2;
lmax=max(a,left,mid);
rmax=max(a,mid+1,right);
return lmax>rmax?lmax:rmax;
}
}
- lab5_02_ans.c
/*
请编写一个递归算法函数void partion(int a[], int left, int right)，
将数组a[left..right]中的所有奇数调整到表的左边，所有偶数调整到表的右边。
*/
#include "ArrayIo.h"
#define N 10
/*请将本函数补充完整，并进行测试*/
void partion(int a[], int left,int right)
{
int x;
if (left<right)
{
while (left<right && a[left]%2==1)
left++;
while (left<right && a[right]%2==0)
right--;
if (left<right)
{
x=a[left];
a[left]=a[right];
a[right]=x;
partion(a,left+1,right-1);
}
}
}
- lab5_03_ans.c
/*
请编写递归函数void bubbleSort(int a[],int n)，
对长度为n的数组采用冒泡法进行升序排序。
请编写递归函数int binSearch(int a[], int left, int right,int key)，
采用二分查找法在数组a[left..right]中查找值为key的元素所在的位置，
若查找失败函数返回-1。
*/
#include "ArrayIo.h"
#define N 10
/*请将本函数补充完整，并进行测试*/
void bubbleSort(int a[],int n)
{ int i,t;
int flag;
if(n>0)
{
flag=0;
for(i=0;i<n-1;i++)
{
if(a[i]>a[i+1])
{
t=a[i];
a[i]=a[i+1];
a[i+1]=t;
flag=1;
}
}
if (flag==1) bubbleSort(a,n-1);
}
return ;
}
int binSearch(int a[], int left,int right,int key)
{
int mid;
if (left>right)
return -1;
else
{
mid=(left+right)/2;
if (a[mid]==key)
return mid;
else
if (key<a[mid])
return binSearch(a,left,mid-1,key);
else
return binSearch(a,mid+1,right,key);
}
}
- lab5_04_ans.c
/*
已知带头结点的单链表结构定义同实验3，假设链表中所有结点值均不相同，
请编写一个递归函数linklist max(linklist head)，返回表中最大数所在的结点地址，若链表为空，返回NULL。
*/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
linklist max(linklist head)
{
linklist m;
if (head->next==NULL)
return NULL;
else
if (head->next->next==NULL)
return head->next;
else
{
m=max(head->next);
return head->next->info > m->info ? head->next:m;
}
}
实验6-树
- lab6_01_ans.c
/*
编写算法函数void levelorder(tree t)实现树的层次遍历。
*/
#include "tree.h"
void levelorder(tree t) /* t为指向树根结点的指针*/
{
tree queue[MAXLEN]; /*用队列存放待处理的结点*/
int head=0,end=1;
int i;
queue[head] = t; /*先将根节点入队*/
while( head < end )
{
for(i=0;i<m;i++) /*将队列中结点的下一层结点入队，逐层入队*/
{
if( queue[head]->child[i] )
{
queue[end++] = queue[head]->child[i];
}
}
printf("%c",queue[head++]->data); /*逐层出队*/
}
}
int main()
{
tree t;
printf("please input the preorder sequence of the tree:
");
t=createtree();
printf("
the levelorder is:");
levelorder(t);
return 0;
}
- lab6_02_ans.c
/*
假设树采用指针方式的孩子表示法表示，试编写一个非递归函数void PreOrder1(tree root)，实现树的前序遍历算法。
*/
#include "tree.h"
void PreOrder1(tree root)
{
tree stack[100];
int i;
int top=-1;
while (root || top!=-1)
{
if (root)
{
printf("%c",root->data); //输出根结点
for (i=m-1;i>0;i--) //所有非空孩子结点进栈
if (root->child[i]!=NULL)
{
top++;
stack[top]=root->child[i];
}
root=root->child[0]; //转第1棵子树
}
else
{
root=stack[top--]; //栈顶树出栈
}
}
}
int main ()
{
tree root;
printf("please input the preorder sequence of the tree:
");
root =createtree();
printf("前序序列是：
");
PreOrder1(root);
return 0;
}
- lab6_03_ans.c
/*
假设树采用指针方式的孩子表示法表示，试编写一个非递归函数void PostOrder1(tree t)，实现树的后序遍历算法。
*/
#include "tree.h"
int PostOrder1(tree root)
{
tree treeStack[MAXLEN]; /*储存待处理的结点*/
int top = -1;
tree printStack[MAXLEN]; /*储存已经处理完子树的、待输出的结点*/
int topp = -1;
int i;
if( root ) treeStack[++top] = root; /*根结点进栈*/
while( top != -1 )
{
root = treeStack[top--]; /*取一个待处理结点root*/
for(i=0;i<m;i++) /*将root的所有子结点进栈*/
{
if( root->child[i] ) treeStack[++top] = root->child[i];
}
printStack[++topp] = root; /*处理完root、将root进printStack*/
}
while( topp != -1 ) printf("%c",printStack[topp--]->data); /*输出后序序列*/
}
int PostOrder2(tree root)
{
tree treeStack[MAXLEN]; /*未处理完的结点*/
int subStack[MAXLEN]; /*正在处理的孩子的下标*/
int top = -1;
tree p;
int i;
treeStack[++top] = root;
subStack[top] = 0; /*首先处理child[0]这个分支*/
while( top != -1 )
{
p = treeStack[top];
while( subStack[top] < m ) /*处理所有分支*/
{
i = subStack[top];
if( p->child[i] )
{
p = p->child[i];
treeStack[++top] = p; /*有孩子则入栈*/
subStack[top] = 0; /*并处理刚入栈结点的child[0]*/
}
else {
subStack[top]++; /*该分支没有孩子，处理下一分支*/
}
}
printf("%c",p->data); /*出栈前再输出*/
top--; /*该结点处理完毕，返回处理父结点的child[i+1]*/
subStack[top]++;
}
}
int main ()
{ //AB###CE###FH###I####G###D### ,测试三度树
tree root;
printf("please input the preorder sequence of the tree:
");
root =createtree();
printf("后序序列是：
");
PostOrder1(root);
putchar('
');
PostOrder2(root);
return 0;
}
- lab6_04_ans.c
/*
假设树采用指针方式的孩子表示法表示，试编写一个函数int equal(tree t1, tree t2)，
判断两棵给定的树是否等价（两棵树等价当且仅当其根结点的值相等且其对应的子树均相互等价）。
*/
#include "tree.h"
#define TRUE 1
#define FALSE 0
int equal(tree t1,tree t2)
{
int flag=TRUE,i;
if (t1==NULL && t2==NULL)
return TRUE;
else
if (t1==NULL && t2!=NULL || t2==NULL && t1!=NULL)
return FALSE;
else
if (t1->data!=t2->data) return FALSE;
else
{
for (i=0;i<m;i++)
flag=flag&&equal(t1->child[i],t2->child[i]);
return flag;
}
}
int main ()
{
tree t1,t2;
printf("please input the preorder sequence of the tree:
");
t1=createtree();
getchar();
printf("please input the preorder sequence of the tree:
");
t2=createtree();
if ( equal(t1,t2) == TRUE)
{
printf ("两树相等
");
}
else
{
printf ("两树不相等
");
}
return 0;
}
- lab6_05_ans.c
/*
假设树采用指针方式的孩子表示法存储结构，试编写一个函数tree Ct(char s[])，
根据输入的树的括号表示字符串s，生成树的存储结构。例如，若要建立教材图6.4所示的树，
应输入A（B（E，F）,C,D（G（I，J，K）,H））。（说明，tree.h中定义的常量m表示树的最
大度，请根据建树的需要自行修改m的值）
*/
#include "tree.h"
/*请将本函数补充完整，并进行测试*/
tree Ct(char s[MAXLEN])
{
int length;
int i,j,top;
tree stack[100],root=NULL,temp = NULL,n;
int childSeq[m]; // 其第几个孩子
top = -1;
length = strlen (s);
for (i = 0;i < length;i++)
{
if (s[i] == ',')
{
continue;
}
else if (s[i] == '(')
{
stack[++top] = temp;
childSeq[top] = 0;
}
else if (s[i] == ')')
{
top--;
}
else if (top != -1)
{
n = (tree)malloc (sizeof (node));
n->data= s[i];
for (j = 0;j < m;j++)
{
n->child[j] = NULL;
}
temp = n;
stack[top]->child[childSeq[top]++] = temp;
}
else
{
root = (tree)malloc (sizeof (node));
root->data = s[i];
for (j = 0;j < m;j++)
{
root->child[j] = NULL;
}
temp = root;
}
}
return root;
}
int main ()
{
char s[MAXLEN];
tree root = NULL;
printf ("请用树的括号表示法输入一棵树:
");
scanf ("%s",s);
root = Ct(s);
preorder(root); /*前序遍历树*/
return 0;
}
实验7-二叉树
- lab7_01_ans.c
/*
编写算法函数void preorder1(bintree t)实现二叉树t的非递归前序遍历。
*/
#include "bintree.h"
char *a="ABC##D#E##F##"; /*扩充二叉树序树t的前序序列*/
/*函数preorder1()的功能是非递归前序遍历二叉树t，请将函数补充完整并调试运行*/
void preorder1(bintree t)
{
seqstack s;
init(&s);
while ( !empty(&s) || t )
{
if (t)
{
printf("%c",t->data);
push(&s, t);
t=t->lchild;
}
else
{
t=pop(&s);
t=t->rchild;
}
}
}
- lab7_02_ans.c
/*
编写算法函数void levelbintree(bintree t)，实现二叉树的层次遍历。
*/
#include "bintree.h"
char *a="ABC##D#E##F##"; /*扩充二叉树序树t的前序序列*/
void levelbintree(bintree t)
{
bintree queue[100];
int f,r;
f=0;r=1;
if (t)
{
queue[0]=t;
while (f<r)
{
t=queue[f++];
printf("%c",t->data);
if (t->lchild)
queue[r++]=t->lchild;
if (t->rchild)
queue[r++]=t->rchild;
}
}
}
- lab7_03_ans.c
/*
编写函数bintree prelist(bintree t)，bintree postfirst(bintree t)，
分别返回二叉树t在前序遍历下的最后一个结点地址和后序遍历下的第一个结点地址。
*/
#include "bintree.h"
char *a="ABC##D##EF#G###"; /*扩充二叉树序树t的前序序列*/
bintree prelast(bintree t) //递归实现
{
if (!t)
return t; //空树
else
if (t->lchild==NULL &&t->rchild==NULL) //树根是唯一的结点
return t;
else
if (t->rchild) //右子树非空
return prelast(t->rchild);
else
return prelast(t->lchild);
}
bintree prelast1(bintree t) //非递归实现
{
bintree p=t;
if (p)
{
while (p->lchild || p->rchild ) //p为非叶子
if (p->rchild)
p=p->rchild;
else
p=p->lchild;
}
return p;
}
bintree postfirst(bintree t)
{ bintree p=t;
if (p)
{
while (p->lchild || p->rchild )
if (p->lchild)
p=p->lchild;
else
p=p->rchild;
}
return p;
}
- lab7_04_ans.c
/*
假设二叉树采用链式方式存储，t为其根结点，编写一个函数int Depth(bintree t, char x)，求值为x的结点在二叉树中的层次。
*/
#include "bintree.h"
char *a="ABC##D##EF#G###"; /*扩充二叉树序树t的前序序列*/
/*
函数Depth，功能：求结点x所在的层次
*/
int Depth(bintree t,char x)
{
int m,n;
if( !t ) return -1; /*未找到的分支标记为-1*/
if( t->data == x ) return 1; /*找到返回1*/
m = Depth(t->lchild,x); /*因为没有子树就返回-1，所以没必要考虑是否存在子树*/
if( m != -1 ) return m+1; /*找到则加1往上计数*/
else
{ n = Depth(t->rchild,x);
if( n != -1 ) return n+1;
else return -1; /*没找到继续返回-1*/
}
}
- lab7_05_ans.c
/*
试编写一个函数，将一棵给定二叉树中所有结点的左、右子女互换。
*/
#include "bintree.h"
char *a="ABC##D##EF#G###"; /*扩充二叉树序树t的前序序列*/
/*请将本函数补充完整，并进行测试*/
void change(bintree t)
{
bintree temp; /*将t的左右结点交换*/
if (t)
{
temp = t->lchild;
t->lchild = t->rchild;
t->rchild = temp;
if( t->lchild ) change( t->lchild ); /*交换左子树*/
if( t->rchild ) change( t->rchild ); /*交换右子树*/
}
}
- lab7_06_ans.c
/*
试编写一个递归函数bintree buildBintree(char *pre, char *mid, int length)，
根据二叉树的前序序列pre、中序序列mid和前序序列长度length，构造二叉树的二叉链表存储结构，
函数返回二叉树的树根地址。
*/
#include "bintree.h"
#include <string.h>
char *a="";
/*
大概的原理：前序序列的第一个字符是树的根结点root（比如说是 A ），
并且A后面的是左子树的前序序列，然后右子树的前序序列
在中序序列中， A 左边的是左子树的中序序列， A 右边是右子树的中序序列
*/
bintree buildBintree(char *pre, char *mid,int length)
{
if( length )
{
/*↓↓以下两行，创建树的根节点*/
bintree root = (bintree)malloc(sizeof(binnode));
root->data = pre[0];
/*↓↓以下三行，将中序序列拆分成【左子树的中序序列】和【右子树的中序序列】*/
int i;
for(i=0;mid[i] != pre[0];i++) ;
mid[i] = ' ';
/*↓↓以下两行，递归建立左子树和右子树，同理，将前序序列拆分成【左子树的前序序列】和【右子树的前序序列】*/
root->lchild = buildBintree(pre+1,mid,i);
root->rchild = buildBintree(pre+i+1,mid+i+1,length-i-1);
/*最后return根结点*/
return root;
}
else return NULL;
}
实验8-图
- lab8_01_ans.c
/*
编写程序输出以邻接表为存储结构的无向图的各顶点的度。
*/
/**********************************/
/*文件名称：lab8_01.c */
/**********************************/
#include "ljb.h"
/* 输出以邻接表为存储结构的无向图g的各顶点的度 */
void degree(LinkedGraph g)
{
EdgeNode *p;
int count;
int i;
for (i=0;i<g.n;i++)
{
count=0;
p=g.adjlist[i].FirstEdge;
while (p)
{
count++;
p=p->next;
}
printf("D(%d)=%d
",i,count);
}
}
- lab8_02_ans.c
/*
图采用邻接表存储结构，编程对图进行广度优先遍历。
*/
/**********************************/
/*文件名称：lab8_02.c */
/**********************************/
#include "ljb.h"
int visited[M]; /*全局标志向量*/
/*请将本函数补充完整，并进行测试*/
void bfs(LinkedGraph g, int i)
{ /*从顶点i出发广度优先变量图g的连通分量*/
int queue[M],front,rear,v;
EdgeNode *p;
front=rear=0;
queue[rear++]=i;
visited[i]=1;
while (front<rear)
{
v=queue[front++];
printf("%c ", g.adjlist[v].vertex);
p=g.adjlist[v].FirstEdge;
while (p)
{
if (visited[p->adjvex]==0)
{
queue[rear++]=p->adjvex;
visited[p->adjvex]=1;
}
p=p->next;
}
}
}
/*函数功能：广度优先遍历图g
函数参数：邻接表g
*/
int BfsTraverse(LinkedGraph g)
{ int i,count=0;
for (i=0;i<g.n;i++)
visited[i]=0; /*初始化标志数组*/
for (i=0;i<g.n;i++)
if (!visited[i]) /*vi未访问过*/
{printf("
");
count++; /*连通分量个数加1*/
bfs(g,i);
}
return count;
}
- lab8_03_ans.c
/*
图采用邻接表存储结构，编程对图进行深度优先遍历。
*/
#include "ljb.h"
int visited[M];
/*请将本函数补充完整，并进行测试*/
void dfs(LinkedGraph g,int i)
{ /*从顶点i开始深度优先遍历图的连通分量*/
EdgeNode *p;
printf("visit vertex: %c
",g.adjlist[i].vertex);/*访问顶点i*/
visited[i]=1;
p=g.adjlist[i].FirstEdge;
while (p) /*从p的邻接点出发进行深度优先搜索*/
{
if (visited[p->adjvex]==0)
dfs(g,p->adjvex);
p=p->next;
}
}
/*函数功能：深度优先遍历图
函数参数：图的邻接表g
*/
void DfsTraverse(LinkedGraph g)
{ int i;
for (i=0;i<g.n;i++)
visited[i]=0; /*初始化标志数组*/
for (i=0;i<g.n;i++)
if (!visited[i]) /*vi未访问过*/
dfs(g,i);
}
- lab8_05_ans.c
/***************************************************/
/* Dijkstra单源最短路径算法 */
/***************************************************/
#include "ljjz.h" /*引入邻接矩阵创建程序*/
typedef enum{FALSE,TRUE} boolean;/*false为0,true为1*/
typedef int dist[M]; /* 距离向量类型*/
typedef int path[M]; /* 路径类型*/
/*函数功能：Dijkstra算法求解单源最短路径
函数参数：图的邻接矩阵g;源点v0;路径向量p；距离向量d
*/
void dijkstra(Mgraph g,int v0,path p,dist d)
{ boolean final[M]; /*表示当前元素是否已求出最短路径*/
int i,k,j,v,min,x;
/* 第1步 初始化集合S与距离向量d */
for (v=0;v<g.n;v++)
{
final[v]=FALSE;
d[v]=g.edges[v0][v];
if (d[v]<FINITY &&d[v]!=0)
p[v]=v0; else p[v]=-1;
}
final[v0]=TRUE;
d[v0]=0;
/* 第2步 依次找出n-1个结点加入S中 */
for (i=1;i<g.n;i++)
{
min=FINITY;
for (k=0;k<g.n;k++)
if (!final[k] && d[k]<min)
{
v=k;
min=d[k];
}
if (min==FINITY) return ;
final[v]=TRUE;
/*第3步 修改S与V-S中各结点的距离*/
for (k=0;k<g.n;++k)
if (!final[k] && (min+g.edges[v][k]<d[k]))
{
d[k]=min+g.edges[v][k];
p[k]=v;
}
}
}
/*函数功能：输出有向图的最短路径
函数参数：邻接矩阵g；路径向量p；距离向量d
*/
void print_gpd(Mgraph g,path p,dist d)
{
int st[M],i,pre,top=-1;
for (i=0;i<g.n;i++)
{ printf("
Distancd: %7d , path:" ,d[i]);
st[++top]=i;
pre=p[i];
while (pre!=-1) /*从第i个顶点开始向前搜索最短路径上的顶点*/
{ st[++top]=pre;
pre=p[pre];
}
while (top>0)
printf("%2d",st[top--]);
}
}
/*---------- 主程序 ------------*/
实验9-检索
- lab9_01_ans.c
/* 利用readData()函数从data1.txt中读入不同规模的数据存入数组，
编写基于数组的顺序查找算法，测试数据量为1万、5万、10万、20万、
30万、40万和50万时的数据查询时间。
*/
#include "ArrayIo.h"
#define N 10000 /*数据量*/
/*请将本函数补充完整，并进行测试*/
int seqsearch(int a[],int n,int key)
{
int i=n-1;
while (i>=0 &&a[i]!=key)
i--;
return i;
}
- lab9_02_ans.c
/* 利用creatLink()函数从data1.txt中读入不同规模的数据存入不带头结点的单链表，
编写基于单链表的顺序查找算法，测试数据量为1万、5万、10万、20万、
30万、40万和50万时的数据查询时间。
*/
#include "slnklist.h"
#define N 100 /*数据量*/
/*请将本函数补充完整，并进行测试*/
linklist seqsearch(linklist head, int key)
{
linklist p=head->next;
while (p && p->info!=key)
p=p->next;
return p;
}
- lab9_03_ans.c
/* 利用readData()函数从data2.txt中读入不同规模的有序数据存入数组，
编写基于数组的二分查找算法，测试数据量为1万、5万、10万、20万、30万、
40万和50万时的数据查询时间。
*/
#include "ArrayIo.h"
#define N 10000 /*数据量*/
/*请将本函数补充完整，并进行测试*/
int binSearch(int a[],int n,int key)
{
int left,right,mid;
left=0;
right=n-1;
while (left<=right)
{
mid=(left+right)/2;
if (a[mid]==key)
return mid;
else
if (key<a[mid])
right=mid-1;
else
left=mid+1;
}
return -1;
}
- lab9_04_ans.c
/* 利用readData()函数从data2.txt中读入不同规模的有序数据存入数组，
编写基于数组的二分查找递归算法。
*/
#include "ArrayIo.h"
#define N 10000 /*数据量*/
/*请将本函数补充完整，并进行测试*/
int binSearch(int a[],int low,int high,int key)
{ int mid;
if (low>high) return -1;
else
{
mid=(low+high)/2;
if (a[mid]==key) return mid;
else
if (key<a[mid])
return binSearch(a,low,mid-1,key);
else
return binSearch(a,mid+1,high,key);
}
}
实验10-排序
- lab10_01_ans.c
/*
请设计直接插入排序算法函数void insertSort(int a[],int n)，对a[1]..a[n]进行升序排序。
并测试在不同数据规模下的排序效率。
*/
#include "Arrayio.h"
#define N 500000 /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/
/*请将本函数补充完整，并进行测试*/
void insertSort(int a[],int n)
{ /*直接插入排序*/
int i,j;
for (i=2;i<=n;i++)
{
//每一趟将a[i]插入到a[1]..a[i-1]
a[0]=a[i];
j=i-1;
while ( a[j] > a[0])
{
a[j+1]=a[j];
j--;
}
a[j+1]=a[0];
}
}
- lab10_02_ans.c
/*
请设计二分插入排序算法函数void binInsertSort(int a[],int n)，对a[1]..a[n]进行升序排序。
并测试在不同数据规模下的排序效率。
*/
#include "Arrayio.h"
#define N 50000 /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/
/*请将本函数补充完整，并进行测试*/
void binInsertSort(int a[],int n)
{
int mid,left,right,i,j;
for (i=2;i<=n;i++)
{
left=1;
right=i-1;
while (left<=right)
{
mid=(left+right)/2;
if (a[i]<a[mid])
right=mid-1;
else
left=mid+1;
}
//插入的位置是left
a[0]=a[i];
for (j=i-1;j>=left;j--)
a[j+1]=a[j];
a[left]=a[0];
}
}
- lab10_03_ans.c
/*
请设计shell排序算法函数void shellSort(int a[],int n)，对a[1]..a[n]进行升序排序。
并测试在不同数据规模下的排序效率。
*/
#include "Arrayio.h"
#define N 500000 /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/
/*请将本函数补充完整，并进行测试*/
void shellSort(int a[],int n)
{
int i,j,d;
d=n/2;
while (d>=1)
{
for (i=d+1;i<=n;i++)
{
//每一趟将a[i]插入到a[1]..a[i-1]
a[0]=a[i];
j=i-d;
while ( j>=1 &&a[j] > a[0])
{
a[j+d]=a[j];
j=j-d;
}
a[j+d]=a[0];
}
d=d/2;
}
}
- lab10_04_ans.c
/*
请设计简单选择排序算法函数void selectSort(int a[],int n)，对a[1]..a[n]进行升序排序。
并测试在不同数据规模下的排序效率。
*/
#include "Arrayio.h"
#define N 50 /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/
/*请将本函数补充完整，并进行测试*/
void selectSort(int a[],int n)
{
int i,j,max;
for (i=1;i<n;i++)
{
max=i;
for (j=i+1;j<=n;j++)
if (a[j]>a[max])
max=j;
if (max!=i)
{
a[0]=a[i];
a[i]=a[max];
a[max]=a[0];
}
}
}
- lab10_05_ans.c
/*
请设计筛选函数void sift(int a[],int k,int n)，对a[k] 进行筛选，
并利用其设计堆排序算法函数void heapSort(int a[],int n)，
对a[1]..a[n]进行升序排序。并测试在不同数据规模下的排序效率。（详见lab10_05.c）
*/
#include "Arrayio.h"
#define N 500 /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/
/*请将本函数补充完整，并进行测试*/
void sift(int a[],int k,int n)
{
int i,j,finished;
i=k;
j=2*i;
a[0]=a[k];
finished=0;
while((j<=n)&&(!finished))
{
if((j<n)&&(a[j+1]>a[j]))
j++;
if(a[0]>=a[j])
finished=1;
else
{
a[i]=a[j];
i=j;
j=2*j;
}
}
a[i]=a[0];
}
void heapSort(int a[],int n)
{
int i;
for (i=n/2;i>=1;i--)
sift(a,i,n);
for (i=n;i>1;i--)
{
a[0]=a[i];
a[i]=a[1];
a[1]=a[0];
sift(a,1,i-1);
}
}
- lab10_06_ans.c
/*
请设计冒泡排序算法函数void bubbleSort(int a[],int n)，对a[1]..a[n]进行升序排序。
并测试在不同数据规模下的排序效率。
*/
#include "Arrayio.h"
#define N 50 /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/
/*请将本函数补充完整，并进行测试*/
void bubbleSort(int a[],int n)
{
int i;
int flag=1;
while (n>1 && flag==1)
{ flag=0;
for (i=1;i<n;i++)
{ if (a[i]>a[i+1])
{ a[0]=a[i];
a[i]=a[i+1];
a[i+1]=a[0];
flag=1;
}
}
n--;
}
}
- lab10_07_ans.c
/*
请设计快速排序算法函数void quickSort(int a[],int low,int high)，对a[low]..a[high]进行升序排序。
并测试在不同数据规模下的排序效率。
*/
#include "Arrayio.h"
#define N 500000 /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/
/*请将本函数补充完整，并进行测试*/
void quickSort(int a[],int low,int high )
{
int left,right;
if (low<high)
{
left=low;
right=high;
a[0]=a[low];
do
{//来加比较法的一次划分
while (left<right && a[right]>a[0])
right--;
if (left<right)
a[left++]=a[right];
while (left<right &&a[left]<=a[0])
left++;
if (left<right)
a[right--]=a[left];
}while (left!=right);
a[left]=a[0];
quickSort(a,low,left-1);
quickSort(a,left+1,high);
}
}
- lab10_08_ans.c
/*
请设计归并排序算法函数void mergeSort(int a[],int n)，对a[1]..a[n]进行升序排序。
并测试在不同数据规模下的排序效率。
*/
#include "Arrayio.h"
#define N 100000 /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/
/*请将本函数补充完整，并进行测试*/
void merge(int a[],int u,int m,int v)
{ /*将有序段a[u..m],a[m+1..v]归并到a[u..v]*/
int i,j,k,t;
int b[N+1];
i=u; j=m+1; k=u;
while (i<=m && j<=v)
{ if (a[i]<=a[j] )
{ b[k]=a[i];
i++;
}
else
{ b[k]=a[j];
j++;
}
k++;
}
while (i<=m)
b[k++]=a[i++];
while (j<=v)
b[k++]=a[j++];
/*将l2表中的内容拷贝回表l1*/
for (i=u;i<=v;i++)
a[i]=b[i];
}
/*----一趟归并------*/
int mergepass(int a[],int n,int len)
{ /*对a[1..n]进行长度为len的一趟并归*/
int i;
i=1;
while (i<=n-2*len+1)
{ merge(a,i,i+len-1,i+2*len-1);
i=i+2*len;
}
if (i+len-1<n)
merge(a,i,i+len-1,n);
}
/*----归并排序------*/
void mergeSort(int a[],int n)
{ int len;
len=1;
while (len<n)
{ mergepass(a,n,len);
len=len*2;
}
}
/*归并排序的递归实现*/
void mergeSortdc(int a[],int low,int high)
{
int mid;
if (low<high)
{
mid=(low+high)/2;
mergeSortdc(a,low,mid);
mergeSortdc(a,mid+1,high);
merge(a,low,mid,high);
}
}
- lab10_09_ans.c
/*
请设计基于链表的基数排序函数void radixSort(linklist head)，对带头结点的整型非负单链表进行升序排序。
并测试在不同数据规模下的排序效率。(注：链表中的最大整数为500000)
*/
#include "slnklist.h"
#define N 500000 /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/
struct node2
{
linklist front,rear;
};
/*请将本函数补充完整，并进行测试*/
void radixSort(linklist head)
{
struct node2 q[10];/*队列*/
linklist p,r;
int i,j,k,x;
for (j=0;j<10;j++)
q[j].rear=q[j].front=NULL;
for (i=0;i<6;i++) //排序的最大数为6位数，共进行6趟分配收集过程
{
p=head->next; //分配
while (p)
{
head->next=p->next;
x=p->info;
for (j=0;j<i;j++)
x=x/10;
k=x%10; //取出本次按位分配的值
if (q[k].front==NULL) //队列为空
{
q[k].front=q[k].rear=p;
}
else //队列不为空
{
q[k].rear->next=p;
q[k].rear=p;
}
p=head->next;
}
//收集
r=head; //r为链尾指针
for (j=0;j<10;j++)
{
if (q[j].front!=NULL)
{ r->next=q[j].front;
r=q[j].rear;
q[j].front=q[j].rear=NULL;
}
}
r->next=NULL;
}
}