实现两个链表的合并     可变长顺序表设计 数据结构

数据结构课程设计

题目一：实现两个链表的合并
题目二：可变长顺序表设计

班 级：计1101
姓 名：寸利芳
学 期：2012-2013学年第二学期
题目一：实现两个链表的合并
问题描述：
（1）建立两个链表A和B，链表元素个数分别为m和n个；
（2）假设元素分别为(x1,x2,…xm)，和(y1,y2, …yn)。把它们合并成一个线性表C：
当m>=n时，C=x1,y1,x2,y2,…xn,yn,…,xm
当n>m时，C=y1,x1,y2,x2,…ym,xm,…,yn
（3）输出线性表C；
（4）用直接插入排序法对C进行升序排序，生成链表D，并输出链表D。
基本要求：
（1）分别建立元素个数为m和n的链表A,B;
（2）将长链插入到短链中去，合并成C并进行输出；
（3）用直接插入法对C进行排序，，生成链表D，并输出链表D。
测试数据：
（1）A表（30，41，15，12，56，80）
B表（23，56，78，23，12，33，79，90，55）
（2）A表（30，41，15，12，56，80，23，12，34）
B表（23，56，78，23，12）
算法思想:
编写创建链表的函数cteat()，调用该函数创建两条链表，从终端输入数据，调用合并函数对两条链表按照要求进行合并，合并后通过传参调用排序函数对立链表进行排序，完成操作
模块划分：
(1) 结构体struct Node的创建。struct Node *create（int n）链表的创建。
(2) struct Node * connect(struct Node * A, int m, struct Node * B, int n) 算法的功
能是实现两个链表的交叉合并，并且可以根据两链表的长短将行不通的插入。
(3) void InsertSort(struct Node *l,)功能是对一合并好的链表进行升序插入排序。
(4) void print(struct Node *head)功能是对链表进行输出。
(5) main()函数主要是对算法进行测试。
数据结构：
struct Node //定义结构体
{
int data;
struct Node *next;
};
源程序：
#include<stdlib.h>
#include<stdio.h>
#include<malloc.h>
#define L sizeof(struct Node)//L代表struct Node类型数据的长度
struct Node //定义结构体
{
int data;
struct Node *next;
};
struct Node *create(int n)//链表创建函数 ，指针类型
{
int a=0;//输入的数据个数
struct Node *head;
struct Node *p1, *p2;
head=(struct Node *) malloc(L);
p1 = (struct Node *) malloc(L); //开辟一个新单元
head ->next= NULL;//链表无结点
scanf("%ld", &p1->data);
while(a<n)//录入链表信息
{
if (head->next==NULL)
head->next = p1;//p1指向新开辟的结点
else
p2->next = p1;//p1所指结点连接在p2所指结点的后面
p2 = p1;//p2链表的最后一个结点
p1 = (struct Node *) malloc(L);
if(n!=1)
scanf("%ld", &p1->data);
n--; //控制输入的个数
}
p2->next = NULL;
free(p1);
return (head);//函数返回head的值
}//链表创建函数结束
void print(struct Node *head)//输出函数
{
struct Node *p;
p = head->next;
if (head != NULL)
do//循环实现输出
{
printf("%ld ", p->data);
p = p->next;
} while (p != NULL);
printf("\n");
}
//链表的交叉合并算法
struct Node * connect(struct Node * A, int m, struct Node * B, int n)
{
struct Node *head, *p1, *p2, *p,*head2;
head2=(struct Node*)malloc(sizeof(struct Node));
/*判断A，B大小并合并 */
if (m >= n)
{
head = p1 = A->next;
p2 = B->next;
}
else
{
head = p1 = B->next;
p2 = A->next;
// temp = m, m = n, n = temp; /*交换a和b*/
}
p = head; /*此时p指向p1中的第一个元素*/
while (p2 != NULL)
{
p1 = p1->next;
p->next = p2;
p = p2;
p2 = p2->next;
p->next = p1;
p = p1;
}
head2->next=head;
return head2;
}
void InsertSort(struct Node *l) //排序函数
{
struct Node *p,*q,*r;
p=l->next;
l->next=NULL;
while(p!=NULL)
{
r=p;
p=p->next;
q=l;
while(q->next != NULL && q->next->data < r->data)
q=q->next;
r->next = q->next;
q->next = r;
}
}
int main()
{
struct Node *p1, *p2;
int a,b,h;
printf("* * * * * * * * * * * * 实 现 两 个 链 表 的 合 并 * * * * * * * * * * * * * * * \n");
printf("\n请输入A链表的长度m:\n");
scanf("%d", &a);
printf("请输入A链表的数据：");
p1 = create(a);
printf("\n请输入B链表的长度n:\n");
scanf("%d", &b);
printf("请输入B链表的数据：");
p2 = create(b);
p1 = connect(p1, a, p2, b);
h = a + b;
printf("\n合并后的链表：");
print(p1);
InsertSort(p1);
printf("\n排序后的链表:");
print(p1);
printf("\n谢谢使用!\n");
return 0;
}
测试结果：





结果分析：程序运行结果和预测的完全相同，说明所设计的链表的合并是正确的。
题目二：可变长顺序表设计
问题描述：
用动态数组对顺序表进行初始化、求数据元素个数、插入、删除、取数据元素，编写每个操作的函数。
测试数据：
23 4 6765 3434 5
算法思想:
用malloc为顺序表申请一段空间，从终端输入需要申请的空间大小，写出初始化、插入、删除、获取元素的函数，其中在插入函数中需要每次为插入的数据申请新的空间。编写主函数，从终端输入测试数据，在主函数中调用需要执行操作的函数来完成操作
模块划分：
(1)结构体typedef struct的创建。
(2)void Initiate(SeqList *s,int max)算法的功能是实现顺序表的初始化，用来建立存储顺序表的动态数组空间及给相关数据域赋值
(3)int ListLength(SeqList *L)功能是求顺序表中元素的个数。
(4)int Insert(SeqList *s))功能是插入元素操作。
(5)int Delete(seq *s)功能是删除元素操作。
(6)int getdata(seq *s)功能是取元素操作。
(7)void print(SeqList *s,int max)功能是对顺序表进行输出。
(8)main()函数主要是对算法进行测试。
数据结构：
typedef struct
{
int *str;
int Length;
}SeqList;
源程序：
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
typedef struct
{
int *str;
int Length;
}SeqList;
void main()
{
SeqList L;
int m;
int max;
void Initiate(SeqList *s,int max);//函数声明
int ListLength(SeqList *s);
int Insert(SeqList *s);
int Delete(SeqList *s);
int getdata(SeqList *s);
void print(SeqList *s,int);
printf("* * * * * * * * * * * *可变长顺序表设计* * * * * * * * * * * * *\n");
printf("\n输入可变长顺序表的元素个数: \n");
scanf("%d",&max);
printf("输入可变长顺序表的元素:\n");
Initiate(&L,max);
m=ListLength(&L);
printf("输出当前数据元素个数: %d\n",m);
Insert(&L);
Delete(&L);
getdata(&L);

}
void Initiate(SeqList *s,int max)//初始化顺序表
{
int i,x;
s->str=(int *)malloc(sizeof(int)*max);//动态申请空间
s->Length=max;
for(i=0; i<max;i++)
{
scanf("%d",&x);
s->str[i]=x;
}
}
int ListLength(SeqList *L)
{
return L->Length;
}

int Insert(SeqList *s)
{
int i,j,x;
printf("\n请输入要插入的位置及数据: ");
scanf("%d %d",&j,&x);
if(j<0)
{
printf("参数不合法!\n");
return 0;
}
else
{
realloc(s->str,(s->Length+1)*sizeof(int));//新结点申请空间
for(i=s->Length-1;i>=j-1;i--)
{
s->str[i+1]=s->str[i];
}
s->str[j-1]=x;
s->Length++;
printf("新的顺序表是：");
for(i=0;i<s->Length;i++)
printf("%d ",s->str[i]);
printf("\n");
return 1;
}
}
void print(SeqList *s,int max)
{
int i;
for(i=0;i<max;i++)
{
printf("%d ",s->str[i]);
}
}
int Delete(SeqList *s)
{
int i,j,x;
printf("\n请输入要删除数据的位置 ：");
scanf("%d",&j);
if(j<0||j>s->Length)
{
printf("参数不合法!\n");
return 0;
}
x=s->str[j-1];
for(i=j;i<s->Length;i++)
{
s->str[i-1]=s->str[i];
}

s->Length--;
printf("删除的数据为:%d\n",x);
printf("新的顺序表为: ");
for(i=0;i<s->Length;i++)
printf("%d ",s->str[i]);
printf("\n");
return 1;
}
int getdata(SeqList *s)
{
int j,x;
printf("\n请输入要获取元素的位置:");
scanf("%d",&j);
if(j<0||j>s->Length)
{
printf("参数不合法!\n");
return 0;
}
else
{
x=s->str[j-1];
printf("获取的元素为: %d\n",x);
return 1;
}
}
测试结果：



结果分析：程序运行结果和预测的完全相同，说明所设计的可变长顺序表是正确的。