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

数据结构课程设计

     题目一：实现两个链表的合并

题目二：可变长顺序表设计

班    级：计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;

}

}

测试结果：

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