已知线性表LA和LB中的数据元素按值非递减有序排列，现要求将LA和LB归并为一个新的线性表LC，且LC中的数据元素仍按值非递减有序排列。例如，设 LA=（3,5,8,11） LB=（2,6,8,9,1

最新推荐文章于 2023-06-07 15:36:23 发布
最新推荐文章于 2023-06-07 15:36:23 发布
阅读量1.2w 收藏 96
点赞数 15
分类专栏： 数据结构（C语言版）严蔚敏 吴伟民 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AKK188888881/article/details/107267695
版权

已知线性表LA和LB中的数据元素按值非递减有序排列，现要求将LA和LB归并为一个新的线性表LC，且LC中的数据元素仍按值非递减有序排列。例如，设
LA=（3,5,8,11）
LB=（2,6,8,9,11,15,20）
则
LC=（2,3,5,6,8,8,9,11,11,15,20）。

法一：用数组下标解决
main.cpp

#include <stdio.h>
#include <stdlib.h>

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASALBE -1
#define OVERFLOW -2

#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define ElemType int

typedef int Status;

typedef struct
{
	ElemType* elem;
	int length;
	int listsize;
}SqList;

Status InitList(SqList& L);//InitList
Status DestroyList(SqList& L);//DestroyList
Status ClearList(SqList& L);//ClearList
Status ListEmpty(SqList& L);//ListEmpty
Status ListLength(SqList& L);//ListLength
Status GetElem(SqList& L, int i, int& e);//GetElem
Status compare(ElemType a, ElemType b);//compare
Status LocateElem(SqList L, ElemType e, Status(*compare)(ElemType, ElemType));//LocateElem
Status PriorElem(SqList L, int cur_e, int &pre_e);//PriorElem
Status NextElem(SqList L, int cur_e, int& next_e);//NextElem
Status ListInsert(SqList& L, int i, ElemType e);//ListInsert
Status ListDelete(SqList& L,int i,ElemType& e);//ListDelete
Status visit(SqList& L);//visit
Status ListTraverse(SqList& L, Status(*p)(int, SqList));//ListTraverse
void output(SqList& L);//output
void MergeList_1(SqList La, SqList Lb, SqList& Lc);//MergeList_1

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

Status DestroyList(SqList& L)
{
	free(&L);
	return OK;
}//DestroyList

Status ClearList(SqList& L)
{
	free(L.elem);//释放指针L.elem指向的内存，但是指针L.elem指向的地址还是不变，指向的是顺序表的第一个元素的节点
	//动态指针是在堆上维护的，动态指针定义后，程序为指针分配了一块内存，而且保证这块内存不会被其他乱七八糟的东西修改。
	//free或者delete的时候，是放弃了指针对这个内存的占用，放弃之后，内存的值（顺序表的第一个元素的节点的值）会改写成随机值。
	L.elem = NULL;//使顺序表的指针L.elem，使指针L.elem指向NULL（即0），防止产生野指针，避免误访问没有使用权的指针
	//野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）
	L.length = 0;
	return OK;
}//ClearList

Status ListEmpty(SqList& L)
{
	if (L.length == 0)
		return TRUE;
	else
		return FALSE;
}//ListEmpty

Status ListLength(SqList& L)
{
	return L.length;
}//ListLength

Status GetElem(SqList& L, int i, int& e)
{
	int j;
	for (j = 0; j < ListLength(L); j++)//遍历顺序表L
	{
		if (j == i)//用j定位i 
		{
			e = L.elem[j];//把L中第j个，也就是第i个数据元素的值赋值给整数e 
			return e;
			break;
		}
	}
	return ERROR;
}//GetElem

Status compare(ElemType a, ElemType b)
{
	if (a == b)
		return OK;
	else
		return ERROR;
}//compare

Status LocateElem(SqList L, ElemType e, Status(*compare)(ElemType, ElemType))
{
	int i = 0;
	ElemType *p = L.elem;
	while (i <= (L.length - 1) && !(*compare)(*p++, e))
		++i;
	if (i <= L.length - 1)
	{
		if (i == 0)
			return 0;//和else其他这种情况做个区分 
		else
			return i;
	}
	else
		return 0;
}//LocateElem

Status PriorElem(SqList L, int cur_e, int &pre_e)
{
	int i, judge;
	for (i = 0, judge = 0; i < ListLength(L); i++)
	{
		if (i != 0 && cur_e == L.elem[i])
		{
			judge = 1;
			pre_e = L.elem[i - 1];
			break;
		}
	}
	if (judge == 0)
		return ERROR;
	else
		return pre_e;
}//PriorElem

Status NextElem(SqList L, int cur_e, int& next_e)
{
	int i, judge;
	for (i = 0, judge = 0; i < ListLength(L); i++)
	{
		if (i != ListLength(L) - 1 && cur_e == L.elem[i])
		{
			judge = 1;
			next_e = L.elem[i + 1];
			break;
		}
	}
	if (judge == 0)
		return ERROR;
	else
		return next_e;
}//NextElem

Status ListInsert(SqList& L, int i, ElemType e)//在元素第i个（0<=i<=n-1）之前插入一个数据元素 ，和第n-1个元素之后插入一个数据元素 
{
	if (i<0 || i>L.length)
		return ERROR;
	if (L.length >= L.listsize)
	{
		ElemType* newbase = (ElemType *)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));
		if (!newbase)
			exit(OVERFLOW);
		L.elem = newbase;
		L.listsize += LISTINCREMENT;
	}

	ElemType* q = &(L.elem[i]);
	for (ElemType *p = &(L.elem[L.length - 1]); p >= q; --p)
		*(p + 1) = *p;
	*q = e;
	++L.length;
	return OK;
}//ListInsert


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

Status visit(int i, SqList L)
{
	if (L.elem[i] != NULL)
		return OK;
	else
		return ERROR;
}//visit

Status ListTraverse(SqList& L, Status(*p)(int, SqList))
{
	int i, judge;
	for (i = 0, judge = 0; i < ListLength(L); i++)
	{
		visit(i, L);
		if (visit(i, L) == 1)
			return OK;
		else
			return ERROR;
	}
	return ERROR;
}//ListTraverse

void output(SqList& L)
{
	int i;
	printf("Result:");
	for (i = 0; i < ListLength(L); i++)
		printf("%d ", L.elem[i]);
	printf("\n");
}//output

void MergeList_1(SqList La, SqList Lb, SqList& Lc)
{
	InitList(Lc);//初始化得到一个空的顺序表Lc 
	Status La_len = ListLength(La);   Status Lb_len = ListLength(Lb);//求出顺序表La和Lb的长度分别为La_len和Lb_len 
	Status i, j, k;
	i = j = k = 0;
	int ai, bj;
	while ((i <= La_len - 1) && (j <= Lb_len - 1))//遍历顺序表La和Lb 
	{
		GetElem(La, i, ai);	GetElem(Lb, j, bj); //把第i个数据元素的值赋值给ai和bj 
		if (ai <= bj)//如果顺序表La第i个数据元素的值小于等于顺序表Lb第j个数据元素的值 
		{
			ListInsert(Lc, k++, ai);//在顺序表Lc中第k++个位置之前插入新的数据元素ai
			++i;//继续向后遍历顺序表La 
		}
		else//如果顺序表La第i个数据元素的值大于顺序表Lb第j个数据元素的值，即顺序表Lb第j个数据元素的值小于顺序表La第i个数据元素的值
		{
			ListInsert(Lc, k++, bj);//在顺序表Lc中第k++个位置之前插入新的数据元素bj
			++j;//继续向后遍历顺序表Lb
		}
	}
	while (i <= La_len - 1)//若Lb扫描完毕，但没有扫描完La 
	{
		GetElem(La, i++, ai);
		ListInsert(Lc, k++, ai);
	}
	while (j <= Lb_len - 1)//若La扫描完毕，但没有扫描完Lb
	{
		GetElem(Lb, j++, bj);
		ListInsert(Lc, k++, bj);
	}
}//MergeList_1

int main()
{
	SqList *La = (SqList*)malloc(sizeof(SqList));
	printf("InitList La Status: %d\n", InitList(*La));
	int k = 5;//随便设一个 
	int i, n, *r = &k;
	printf("Enter List Li Length: ");
	scanf("%d", &n);
	printf("Enter %d numbers: ", n);
	for (i = 0; i < n; i++)
	{
		scanf("%d", &La->elem[i]);
		La->length++;
	}

//	printf("ListLength: %d\n", ListLength(*La));
//	printf("ListEmpty Status: %d\n", ListEmpty(*La));
//	printf("GetElem: %d\n", GetElem(*La, 3, *r));//此时e是8，即*r是8 
//	printf("LocateElem: %d\n", LocateElem(*La, 6, compare));//此时e是6 
//	printf("PriorElem %d\n", PriorElem(*La, 6, *r));//此时pre_e是10，即*r是10 
//	printf("NextElem: %d\n", NextElem(*La, 6, *r));//此时next_e是8，即*e是8 
//	printf("ListInsert Status: %d\n", ListInsert(*La, 1, 15));//在i=1的位置之前插入一个数字15 
//	output(*La);
//	printf("ListDelete Status: %d\n", ListDelete(*La, 2, *r));//删除i=2位置上的元素的值 
//	output(*La);
//	printf("ListTraverse Status: %d\n", ListTraverse(*La, visit));
//	output(*La);

	SqList *Lb = (SqList*)malloc(sizeof(SqList));
	printf("InitList Lb Status: %d\n", InitList(*Lb));
	int m;
	printf("Enter List Lb length: ");
	scanf("%d", &m);
	printf("Enter %d numbers: ", m);
	for (i = 0; i < m; i++)
	{
		scanf("%d", &Lb->elem[i]);
		Lb->length++;
	}

	SqList *Lc = (SqList*)malloc(sizeof(SqList));
	MergeList_1(*La, *Lb, *Lc);
	output(*Lc);
	printf("ClearList Status: %d\n", ClearList(*Lc));
	output(*Lc);
	printf("ListEmpty Status: %d\n", ListEmpty(*Lc));
	output(*Lc);
	printf("DestroyList Status: %d\n", DestroyList(*Lc));
	//	output(*La);//线性表销毁，不要再输出此线性表 
	return 0;
}

在这里插入图片描述
在VS2019下，需将源文件的scanf改为scanf_s：

#include <stdio.h>
#include <stdlib.h>

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASALBE -1
#define OVERFLOW -2

#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define ElemType int

typedef int Status;

typedef struct
{
	ElemType* elem;
	int length;
	int listsize;
}SqList;

Status InitList(SqList& L);//InitList
Status DestroyList(SqList& L);//DestroyList
Status ClearList(SqList& L);//ClearList
Status ListEmpty(SqList& L);//ListEmpty
Status ListLength(SqList& L);//ListLength
Status GetElem(SqList& L, int i, int& e);//GetElem
Status compare(ElemType a, ElemType b);//compare
Status LocateElem(SqList L, ElemType e, Status(*compare)(ElemType, ElemType));//LocateElem
Status PriorElem(SqList L, int cur_e, int& pre_e);//PriorElem
Status NextElem(SqList L, int cur_e, int& next_e);//NextElem
Status ListInsert(SqList& L, int i, ElemType e);//ListInsert
Status ListDelete(SqList& L, int i, ElemType& e);//ListDelete
Status visit(SqList& L);//visit
Status ListTraverse(SqList& L, Status(*p)(int, SqList));//ListTraverse
void output(SqList& L);//output
void MergeList_1(SqList La, SqList Lb, SqList& Lc);//MergeList_1

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

Status DestroyList(SqList& L)
{
	free(&L);
	return OK;
}//DestroyList

Status ClearList(SqList& L)
{
	free(L.elem);//释放指针L.elem指向的内存，但是指针L.elem指向的地址还是不变，指向的是顺序表的第一个元素的节点
	//动态指针是在堆上维护的，动态指针定义后，程序为指针分配了一块内存，而且保证这块内存不会被其他乱七八糟的东西修改。
	//free或者delete的时候，是放弃了指针对这个内存的占用，放弃之后，内存的值（顺序表的第一个元素的节点的值）会改写成随机值。
	L.elem = NULL;//使顺序表的指针L.elem，使指针L.elem指向NULL（即0），防止产生野指针，避免误访问没有使用权的指针
	//野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）
	L.length = 0;
	return OK;
}//ClearList

Status ListEmpty(SqList& L)
{
	if (L.length == 0)
		return TRUE;
	else
		return FALSE;
}//ListEmpty

Status ListLength(SqList& L)
{
	return L.length;
}//ListLength

Status GetElem(SqList& L, int i, int& e)
{
	int j;
	for (j = 0; j < ListLength(L); j++)//遍历顺序表L
	{
		if (j == i)//用j定位i 
		{
			e = L.elem[j];//把L中第j个，也就是第i个数据元素的值赋值给整数e 
			return e;
			break;
		}
	}
	return ERROR;
}//GetElem

Status compare(ElemType a, ElemType b)
{
	if (a == b)
		return OK;
	else
		return ERROR;
}//compare

Status LocateElem(SqList L, ElemType e, Status(*compare)(ElemType, ElemType))
{
	int i = 0;
	ElemType* p = L.elem;
	while (i <= (L.length - 1) && !(*compare)(*p++, e))
		++i;
	if (i <= L.length - 1)
	{
		if (i == 0)
			return 0;//和else其他这种情况做个区分 
		else
			return i;
	}
	else
		return 0;
}//LocateElem

Status PriorElem(SqList L, int cur_e, int& pre_e)
{
	int i, judge;
	for (i = 0, judge = 0; i < ListLength(L); i++)
	{
		if (i != 0 && cur_e == L.elem[i])
		{
			judge = 1;
			pre_e = L.elem[i - 1];
			break;
		}
	}
	if (judge == 0)
		return ERROR;
	else
		return pre_e;
}//PriorElem

Status NextElem(SqList L, int cur_e, int& next_e)
{
	int i, judge;
	for (i = 0, judge = 0; i < ListLength(L); i++)
	{
		if (i != ListLength(L) - 1 && cur_e == L.elem[i])
		{
			judge = 1;
			next_e = L.elem[i + 1];
			break;
		}
	}
	if (judge == 0)
		return ERROR;
	else
		return next_e;
}//NextElem

Status ListInsert(SqList& L, int i, ElemType e)//在元素第i个（0<=i<=n-1）之前插入一个数据元素 ，和第n-1个元素之后插入一个数据元素 
{
	if (i<0 || i>L.length)
		return ERROR;
	if (L.length >= L.listsize)
	{
		ElemType* newbase = (ElemType*)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));
		if (!newbase)
			exit(OVERFLOW);
		L.elem = newbase;
		L.listsize += LISTINCREMENT;
	}

	ElemType* q = &(L.elem[i]);
	for (ElemType* p = &(L.elem[L.length - 1]); p >= q; --p)
		*(p + 1) = *p;
	*q = e;
	++L.length;
	return OK;
}//ListInsert


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

Status visit(int i, SqList L)
{
	if (L.elem[i] != NULL)
		return OK;
	else
		return ERROR;
}//visit

Status ListTraverse(SqList& L, Status(*p)(int, SqList))
{
	int i, judge;
	for (i = 0, judge = 0; i < ListLength(L); i++)
	{
		visit(i, L);
		if (visit(i, L) == 1)
			return OK;
		else
			return ERROR;
	}
	return ERROR;
}//ListTraverse

void output(SqList& L)
{
	int i;
	printf("Result:");
	for (i = 0; i < ListLength(L); i++)
		printf("%d ", L.elem[i]);
	printf("\n");
}//output

void MergeList_1(SqList La, SqList Lb, SqList& Lc)
{
	InitList(Lc);//初始化得到一个空的顺序表Lc 
	Status La_len = ListLength(La);   Status Lb_len = ListLength(Lb);//求出顺序表La和Lb的长度分别为La_len和Lb_len 
	Status i, j, k;
	i = j = k = 0;
	int ai, bj;
	while ((i <= La_len - 1) && (j <= Lb_len - 1))//遍历顺序表La和Lb 
	{
		GetElem(La, i, ai);	GetElem(Lb, j, bj); //把第i个数据元素的值赋值给ai和bj 
		if (ai <= bj)//如果顺序表La第i个数据元素的值小于等于顺序表Lb第j个数据元素的值 
		{
			ListInsert(Lc, k++, ai);//在顺序表Lc中第k++个位置之前插入新的数据元素ai
			++i;//继续向后遍历顺序表La 
		}
		else//如果顺序表La第i个数据元素的值大于顺序表Lb第j个数据元素的值，即顺序表Lb第j个数据元素的值小于顺序表La第i个数据元素的值
		{
			ListInsert(Lc, k++, bj);//在顺序表Lc中第k++个位置之前插入新的数据元素bj
			++j;//继续向后遍历顺序表Lb
		}
	}
	while (i <= La_len - 1)//若Lb扫描完毕，但没有扫描完La 
	{
		GetElem(La, i++, ai);
		ListInsert(Lc, k++, ai);
	}
	while (j <= Lb_len - 1)//若La扫描完毕，但没有扫描完Lb
	{
		GetElem(Lb, j++, bj);
		ListInsert(Lc, k++, bj);
	}
}//MergeList_1

int main()
{
	SqList* La = (SqList*)malloc(sizeof(SqList));
	printf("InitList La Status: %d\n", InitList(*La));
	int k = 5;//随便设一个 
	int i, n, * r = &k;
	printf("Enter List Li Length: ");
	scanf_s("%d", &n);
	printf("Enter %d numbers: ", n);
	for (i = 0; i < n; i++)
	{
		scanf_s("%d", &La->elem[i]);
		La->length++;
	}

	//	printf("ListLength: %d\n", ListLength(*La));
	//	printf("ListEmpty Status: %d\n", ListEmpty(*La));
	//	printf("GetElem: %d\n", GetElem(*La, 3, *r));//此时e是8，即*r是8 
	//	printf("LocateElem: %d\n", LocateElem(*La, 6, compare));//此时e是6 
	//	printf("PriorElem %d\n", PriorElem(*La, 6, *r));//此时pre_e是10，即*r是10 
	//	printf("NextElem: %d\n", NextElem(*La, 6, *r));//此时next_e是8，即*e是8 
	//	printf("ListInsert Status: %d\n", ListInsert(*La, 1, 15));//在i=1的位置之前插入一个数字15 
	//	output(*La);
	//	printf("ListDelete Status: %d\n", ListDelete(*La, 2, *r));//删除i=2位置上的元素的值 
	//	output(*La);
	//	printf("ListTraverse Status: %d\n", ListTraverse(*La, visit));
	//	output(*La);

	SqList* Lb = (SqList*)malloc(sizeof(SqList));
	printf("InitList Lb Status: %d\n", InitList(*Lb));
	int m;
	printf("Enter List Lb length: ");
	scanf_s("%d", &m);
	printf("Enter %d numbers: ", m);
	for (i = 0; i < m; i++)
	{
		scanf_s("%d", &Lb->elem[i]);
		Lb->length++;
	}

	SqList* Lc = (SqList*)malloc(sizeof(SqList));
	MergeList_1(*La, *Lb, *Lc);
	output(*Lc);
	printf("ClearList Status: %d\n", ClearList(*Lc));
	output(*Lc);
	printf("ListEmpty Status: %d\n", ListEmpty(*Lc));
	output(*Lc);
	printf("DestroyList Status: %d\n", DestroyList(*Lc));
	//	output(*La);//线性表销毁，不要再输出此线性表 
	return 0;
}

法二：用指针解决
main.cpp

#include <stdio.h>
#include <stdlib.h>

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASALBE -1
#define OVERFLOW -2

#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define ElemType int

typedef int Status;

typedef struct
{
	ElemType* elem;
	int length;
	int listsize;
}SqList;

Status InitList(SqList& L);//InitList
Status DestroyList(SqList& L);//DestroyList
Status ClearList(SqList& L);//ClearList
Status ListEmpty(SqList& L);//ListEmpty
Status ListLength(SqList& L);//ListLength
Status GetElem(SqList& L, int i, int& e);//GetElem
Status compare(ElemType a, ElemType b);//compare
Status LocateElem(SqList L, ElemType e, Status(*compare)(ElemType, ElemType));//LocateElem
Status PriorElem(SqList L, int cur_e, int &pre_e);//PriorElem
Status NextElem(SqList L, int cur_e, int& next_e);//NextElem
Status ListInsert(SqList& L, int i, ElemType e);//ListInsert
Status ListDelete(SqList& L,int i,ElemType& e);//ListDelete
Status visit(SqList& L);//visit
Status ListTraverse(SqList& L, Status(*p)(int, SqList));//ListTraverse
void output(SqList& L);//output
void MergeList_2(SqList La, SqList Lb, SqList& Lc);//MergeList_2

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

Status DestroyList(SqList& L)
{
	free(&L);
	return OK;
}//DestroyList

Status ClearList(SqList& L)
{
	free(L.elem);//释放指针L.elem指向的内存，但是指针L.elem指向的地址还是不变，指向的是顺序表的第一个元素的节点
	//动态指针是在堆上维护的，动态指针定义后，程序为指针分配了一块内存，而且保证这块内存不会被其他乱七八糟的东西修改。
	//free或者delete的时候，是放弃了指针对这个内存的占用，放弃之后，内存的值（顺序表的第一个元素的节点的值）会改写成随机值。
	L.elem = NULL;//使顺序表的指针L.elem，使指针L.elem指向NULL（即0），防止产生野指针，避免误访问没有使用权的指针
	//野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）
	L.length = 0;
	return OK;
}//ClearList

Status ListEmpty(SqList& L)
{
	if (L.length == 0)
		return TRUE;
	else
		return FALSE;
}//ListEmpty

Status ListLength(SqList& L)
{
	return L.length;
}//ListLength

Status GetElem(SqList& L, int i, int& e)
{
	int j;
	for (j = 0; j < ListLength(L); j++)//遍历顺序表L
	{
		if (j == i)//用j定位i 
		{
			e = L.elem[j];//把L中第j个，也就是第i个数据元素的值赋值给整数e 
			return e;
			break;
		}
	}
	return ERROR;
}//GetElem

Status compare(ElemType a, ElemType b)
{
	if (a == b)
		return OK;
	else
		return ERROR;
}//compare

Status LocateElem(SqList L, ElemType e, Status(*compare)(ElemType, ElemType))
{
	int i = 0;
	ElemType *p = L.elem;
	while (i <= (L.length - 1) && !(*compare)(*p++, e))
		++i;
	if (i <= L.length - 1)
	{
		if (i == 0)
			return TRUE;//和else其他这种情况做个区分 
		else
			return i;
	}
	else
		return 0;
}//LocateElem

Status PriorElem(SqList L, int cur_e, int &pre_e)
{
	int i, judge;
	for (i = 0, judge = 0; i < ListLength(L); i++)
	{
		if (i != 0 && cur_e == L.elem[i])
		{
			judge = 1;
			pre_e = L.elem[i - 1];
			break;
		}
	}
	if (judge == 0)
		return ERROR;
	else
		return pre_e;
}//PriorElem

Status NextElem(SqList L, int cur_e, int& next_e)
{
	int i, judge;
	for (i = 0, judge = 0; i < ListLength(L); i++)
	{
		if (i != ListLength(L) - 1 && cur_e == L.elem[i])
		{
			judge = 1;
			next_e = L.elem[i + 1];
			break;
		}
	}
	if (judge == 0)
		return ERROR;
	else
		return next_e;
}//NextElem

Status ListInsert(SqList& L, int i, ElemType e)//在元素第i个（0<=i<=n-1）之前插入一个数据元素 ，和第n-1个元素之后插入一个数据元素 
{
	if (i<0 || i>L.length)
		return ERROR;
	if (L.length >= L.listsize)
	{
		ElemType* newbase = (ElemType *)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));
		if (!newbase)
			exit(OVERFLOW);
		L.elem = newbase;
		L.listsize += LISTINCREMENT;
	}

	ElemType* q = &(L.elem[i]);
	for (ElemType *p = &(L.elem[L.length - 1]); p >= q; --p)
		*(p + 1) = *p;
	*q = e;
	++L.length;
	return OK;
}//ListInsert


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

Status visit(int i, SqList L)
{
	if (L.elem[i] != NULL)
		return OK;
	else
		return ERROR;
}//visit

Status ListTraverse(SqList& L, Status(*p)(int, SqList))
{
	int i, judge;
	for (i = 0, judge = 0; i < ListLength(L); i++)
	{
		visit(i, L);
		if (visit(i, L) == 1)
			return OK;
		else
			return ERROR;
	}
	return ERROR;
}//ListTraverse

void output(SqList& L)
{
	int i;
	printf("Result:");
	for (i = 0; i < ListLength(L); i++)
		printf("%d ", L.elem[i]);
	printf("\n");
}//output

void MergeList_2(SqList La, SqList Lb, SqList& Lc)
{
	ElemType* pa = La.elem; ElemType* pb = Lb.elem;
	Lc.listsize = Lc.length = La.length + Lb.length;
	ElemType* pc = Lc.elem = (ElemType*)malloc(Lc.listsize * sizeof(ElemType));
	if (!Lc.elem)
		exit(OVERFLOW);
	ElemType* pa_last = La.elem + La.length - 1;
	ElemType* 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++;
	while (pb <= pb_last)
		*pc++ = *pb++;
}//MergeList_2

int main()
{
	SqList *La = (SqList*)malloc(sizeof(SqList));
	printf("InitList La Status: %d\n", InitList(*La));
	int k = 5;//随便设一个 
	int i, n, *r = &k;
	printf("Enter List Li Length: ");
	scanf("%d", &n);
	printf("Enter %d numbers: ", n);
	for (i = 0; i < n; i++)
	{
		scanf("%d", &La->elem[i]);
		La->length++;
	}

//	printf("ListLength: %d\n", ListLength(*La));
//	printf("ListEmpty Status: %d\n", ListEmpty(*La));
//	printf("GetElem: %d\n", GetElem(*La, 3, *r));//此时e是8，即*r是8 
//	printf("LocateElem: %d\n", LocateElem(*La, 6, compare));//此时e是6 
//	printf("PriorElem %d\n", PriorElem(*La, 6, *r));//此时pre_e是10，即*r是10 
//	printf("NextElem: %d\n", NextElem(*La, 6, *r));//此时next_e是8，即*e是8 
//	printf("ListInsert Status: %d\n", ListInsert(*La, 1, 15));//在i=1的位置之前插入一个数字15 
//	output(*La);
//	printf("ListDelete Status: %d\n", ListDelete(*La, 2, *r));//删除i=2位置上的元素的值 
//	output(*La);
//	printf("ListTraverse Status: %d\n", ListTraverse(*La, visit));
//	output(*La);

	SqList *Lb = (SqList*)malloc(sizeof(SqList));
	printf("InitList Lb Status: %d\n", InitList(*Lb));
	int m;
	printf("Enter List Lb length: ");
	scanf("%d", &m);
	printf("Enter %d numbers: ", m);
	for (i = 0; i < m; i++)
	{
		scanf("%d", &Lb->elem[i]);
		Lb->length++;
	}
//	output(*Lb);

	SqList *Lc = (SqList*)malloc(sizeof(SqList));
	MergeList_2(*La, *Lb, *Lc);
	output(*Lc);
	printf("ClearList Status: %d\n", ClearList(*Lc));
	output(*Lc);
	printf("ListEmpty Status: %d\n", ListEmpty(*Lc));
	output(*Lc);
	printf("DestroyList Status: %d\n", DestroyList(*Lc));
	//	output(*La);//线性表销毁，不要再输出此线性表 
	return 0;
}

在这里插入图片描述
在VS2019下，需将源文件的scanf改为scanf_s：

#include <stdio.h>
#include <stdlib.h>

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASALBE -1
#define OVERFLOW -2

#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define ElemType int

typedef int Status;

typedef struct
{
	ElemType* elem;
	int length;
	int listsize;
}SqList;

Status InitList(SqList& L);//InitList
Status DestroyList(SqList& L);//DestroyList
Status ClearList(SqList& L);//ClearList
Status ListEmpty(SqList& L);//ListEmpty
Status ListLength(SqList& L);//ListLength
Status GetElem(SqList& L, int i, int& e);//GetElem
Status compare(ElemType a, ElemType b);//compare
Status LocateElem(SqList L, ElemType e, Status(*compare)(ElemType, ElemType));//LocateElem
Status PriorElem(SqList L, int cur_e, int& pre_e);//PriorElem
Status NextElem(SqList L, int cur_e, int& next_e);//NextElem
Status ListInsert(SqList& L, int i, ElemType e);//ListInsert
Status ListDelete(SqList& L, int i, ElemType& e);//ListDelete
Status visit(SqList& L);//visit
Status ListTraverse(SqList& L, Status(*p)(int, SqList));//ListTraverse
void output(SqList& L);//output
void MergeList_2(SqList La, SqList Lb, SqList& Lc);//MergeList_2

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

Status DestroyList(SqList& L)
{
	free(&L);
	return OK;
}//DestroyList

Status ClearList(SqList& L)
{
	free(L.elem);//释放指针L.elem指向的内存，但是指针L.elem指向的地址还是不变，指向的是顺序表的第一个元素的节点
	//动态指针是在堆上维护的，动态指针定义后，程序为指针分配了一块内存，而且保证这块内存不会被其他乱七八糟的东西修改。
	//free或者delete的时候，是放弃了指针对这个内存的占用，放弃之后，内存的值（顺序表的第一个元素的节点的值）会改写成随机值。
	L.elem = NULL;//使顺序表的指针L.elem，使指针L.elem指向NULL（即0），防止产生野指针，避免误访问没有使用权的指针
	//野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）
	L.length = 0;
	return OK;
}//ClearList

Status ListEmpty(SqList& L)
{
	if (L.length == 0)
		return TRUE;
	else
		return FALSE;
}//ListEmpty

Status ListLength(SqList& L)
{
	return L.length;
}//ListLength

Status GetElem(SqList& L, int i, int& e)
{
	int j;
	for (j = 0; j < ListLength(L); j++)//遍历顺序表L
	{
		if (j == i)//用j定位i 
		{
			e = L.elem[j];//把L中第j个，也就是第i个数据元素的值赋值给整数e 
			return e;
			break;
		}
	}
	return ERROR;
}//GetElem

Status compare(ElemType a, ElemType b)
{
	if (a == b)
		return OK;
	else
		return ERROR;
}//compare

Status LocateElem(SqList L, ElemType e, Status(*compare)(ElemType, ElemType))
{
	int i = 0;
	ElemType* p = L.elem;
	while (i <= (L.length - 1) && !(*compare)(*p++, e))
		++i;
	if (i <= L.length - 1)
	{
		if (i == 0)
			return TRUE;//和else其他这种情况做个区分 
		else
			return i;
	}
	else
		return 0;
}//LocateElem

Status PriorElem(SqList L, int cur_e, int& pre_e)
{
	int i, judge;
	for (i = 0, judge = 0; i < ListLength(L); i++)
	{
		if (i != 0 && cur_e == L.elem[i])
		{
			judge = 1;
			pre_e = L.elem[i - 1];
			break;
		}
	}
	if (judge == 0)
		return ERROR;
	else
		return pre_e;
}//PriorElem

Status NextElem(SqList L, int cur_e, int& next_e)
{
	int i, judge;
	for (i = 0, judge = 0; i < ListLength(L); i++)
	{
		if (i != ListLength(L) - 1 && cur_e == L.elem[i])
		{
			judge = 1;
			next_e = L.elem[i + 1];
			break;
		}
	}
	if (judge == 0)
		return ERROR;
	else
		return next_e;
}//NextElem

Status ListInsert(SqList& L, int i, ElemType e)//在元素第i个（0<=i<=n-1）之前插入一个数据元素 ，和第n-1个元素之后插入一个数据元素 
{
	if (i<0 || i>L.length)
		return ERROR;
	if (L.length >= L.listsize)
	{
		ElemType* newbase = (ElemType*)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));
		if (!newbase)
			exit(OVERFLOW);
		L.elem = newbase;
		L.listsize += LISTINCREMENT;
	}

	ElemType* q = &(L.elem[i]);
	for (ElemType* p = &(L.elem[L.length - 1]); p >= q; --p)
		*(p + 1) = *p;
	*q = e;
	++L.length;
	return OK;
}//ListInsert


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

Status visit(int i, SqList L)
{
	if (L.elem[i] != NULL)
		return OK;
	else
		return ERROR;
}//visit

Status ListTraverse(SqList& L, Status(*p)(int, SqList))
{
	int i, judge;
	for (i = 0, judge = 0; i < ListLength(L); i++)
	{
		visit(i, L);
		if (visit(i, L) == 1)
			return OK;
		else
			return ERROR;
	}
	return ERROR;
}//ListTraverse

void output(SqList& L)
{
	int i;
	printf("Result:");
	for (i = 0; i < ListLength(L); i++)
		printf("%d ", L.elem[i]);
	printf("\n");
}//output

void MergeList_2(SqList La, SqList Lb, SqList& Lc)
{
	ElemType* pa = La.elem; ElemType* pb = Lb.elem;
	Lc.listsize = Lc.length = La.length + Lb.length;
	ElemType* pc = Lc.elem = (ElemType*)malloc(Lc.listsize * sizeof(ElemType));
	if (!Lc.elem)
		exit(OVERFLOW);
	ElemType* pa_last = La.elem + La.length - 1;
	ElemType* 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++;
	while (pb <= pb_last)
		*pc++ = *pb++;
}//MergeList_2

int main()
{
	SqList* La = (SqList*)malloc(sizeof(SqList));
	printf("InitList La Status: %d\n", InitList(*La));
	int k = 5;//随便设一个 
	int i, n, * r = &k;
	printf("Enter List Li Length: ");
	scanf_s("%d", &n);
	printf("Enter %d numbers: ", n);
	for (i = 0; i < n; i++)
	{
		scanf_s("%d", &La->elem[i]);
		La->length++;
	}

	//	printf("ListLength: %d\n", ListLength(*La));
	//	printf("ListEmpty Status: %d\n", ListEmpty(*La));
	//	printf("GetElem: %d\n", GetElem(*La, 3, *r));//此时e是8，即*r是8 
	//	printf("LocateElem: %d\n", LocateElem(*La, 6, compare));//此时e是6 
	//	printf("PriorElem %d\n", PriorElem(*La, 6, *r));//此时pre_e是10，即*r是10 
	//	printf("NextElem: %d\n", NextElem(*La, 6, *r));//此时next_e是8，即*e是8 
	//	printf("ListInsert Status: %d\n", ListInsert(*La, 1, 15));//在i=1的位置之前插入一个数字15 
	//	output(*La);
	//	printf("ListDelete Status: %d\n", ListDelete(*La, 2, *r));//删除i=2位置上的元素的值 
	//	output(*La);
	//	printf("ListTraverse Status: %d\n", ListTraverse(*La, visit));
	//	output(*La);

	SqList* Lb = (SqList*)malloc(sizeof(SqList));
	printf("InitList Lb Status: %d\n", InitList(*Lb));
	int m;
	printf("Enter List Lb length: ");
	scanf_s("%d", &m);
	printf("Enter %d numbers: ", m);
	for (i = 0; i < m; i++)
	{
		scanf_s("%d", &Lb->elem[i]);
		Lb->length++;
	}
	//	output(*Lb);

	SqList* Lc = (SqList*)malloc(sizeof(SqList));
	MergeList_2(*La, *Lb, *Lc);
	output(*Lc);
	printf("ClearList Status: %d\n", ClearList(*Lc));
	output(*Lc);
	printf("ListEmpty Status: %d\n", ListEmpty(*Lc));
	output(*Lc);
	printf("DestroyList Status: %d\n", DestroyList(*Lc));
	//	output(*La);//线性表销毁，不要再输出此线性表 
	return 0;
}
AKK188888881
关注
  • 15
    点赞
  • 踩
  • 96
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构——线性表的合并和有序表的合并
Labrador_Katie的博客
01-05 1186
线性表的合并和有序表的合并线性表的合并有序表的合并 线性表的合并 问题描述： 假设利用两个线性表La和Lb分别表示两个集合A和B，现要求一个新的集合A = A∪B La = (7， 5， 3， 11)     Lb = (2, 6, 3) ➡   La = (7, 5, 3, 11, 2, 6)     算法步骤： 依次取出Lb中的每个元素，执行以下操作： 在La中查找该元素 如果找不到，则将其插入L
严《数据结构》算法2.2（两个非递减有序的LA、LB归并（merge）为一个新的线性表LC）
weixin_45888287的博客
05-06 2494
严《数据结构》算法2.2（两个非递减有序的LA、LB归并（merge）为一个新的线性表LC）（结构体是个好东西） //注意最后一行代码，需要借助指针得到c.len的值，否则，main()中的c.len会取随意值 #include<stdio.h> #define Size 100 struct array //array结构体len代表使用的空间，而Initlist的Size是开辟的空...
算法2.2 已知线性表LA和LB中的数据元素按值非递减有序排列，现要求将LA和LB归并为一个新的线性表LC，且LC中的数据元素仍按值非递减有序排列。
热门推荐
Made in Code
06-23 1万+
数据结构（C语言版）严蔚敏 吴伟民 算法2.2 已知线性表LA和LB中的数据元素按值非递减有序排列，现要求将LA和LB归并为一个新的线性表LC，且LC中的数据元素仍按值非递减有序排列。例如，设 LA=（3,5,8,11） LB=（2，6,8,9,11,15,20） 则 LC=(2,3,5,6,8,8,9,11,11,15,20) 说明：为了展示结果，代码加入线性表的抽象数据类型的全部构造，实际是UnionList函数达成该练习结果，因为该函数内需要调用抽象数据类型构造的其他函数，所以全部列出。 代码块： #
利用C++实现线性表有序表的合并（顺序表实现 and 链表实现）
qq_44757691的博客
11-19 2854
已知线性表La和Lb中的元素按值非递减有序排列，现要求将La和Lb归并为一个新的线性表Lc，且Lc中的数据元素仍按值非递减有序排列。
数组合并的错误
changpantai的博客
09-26 189
两个数组的有序合并（请问错在哪里了？） 题目： 两个不同的数组，将其进行有序合并； 输入要求： 有多组测试数据，每组测试数据占两行。第一行是集合A，第一个整数m（0<=m<=100）代表集合A起始有m个元素，后面有m个非递减排序的整数，代表A中的元素。第二行是集合B，第一个整数n(0<=n<=100)代表集合B起始有n个元素，后面有n个非递减排序的整数，代表B中的元素。每行中整数之间用一个空格隔开。 输出要求： 每组测试数据只要求输出一行，这一行含有 m+n 个来自集合 A 和集合B
归并La和Lb得到新的线性表Lc.pdf
最新发布
06-11
归并La和Lb得到新的线性表Lc.pdf
两个非递减存储顺序线性表归并为非递减顺序线性表
11-01
数据结构的线性表实现，顺序线性表的建立，输入，输出，排序，以及归并。可以参考一下
【算法——有序表的合并】
lflcodeplus的博客
10-24 7221
目录一、题目描述1、描述2、分析二、顺序有序表的合并1、算法思想2、算法描述三、链式有序表的合并1、算法思想2、算法描述四、完整程序源码五、运行结果展示 一、题目描述 1、描述 【题目】已知线性表 LA 和 LB 的数据元素按值非递减有序排列，现要求将 LA 和 LB 归并为一个新的线性表 LC ,且 LC 中的数据元素仍按值非递减有序排列。例如，设： LA = (3,5,8,11) LB = (2,6,8,9,11,15,20) 则 LC = (2,3,5,6,8,8,9,11,11,15,20) 2、分
算法2-2：有序线性表的有序合并
m0_74242327的博客
06-07 253
第一行是集合A，第一个整数m（0<=m<=100）代表集合A起始有m个元素，后面有m个非递减排序的整数，代表A中的元素。第二行是集合B，第一个整数n(0<=n<=100)代表集合B起始有n个元素，后面有n个非递减排序的整数，代表B中的元素。已知线性表 LA 和 LB 中的数据元素按值非递减有序排列，现要求将 LA 和 LB 归并为一个新的线性表 LC， 且 LC 中的数据元素仍然按值非递减有序排列。例如，设LA=(3,5,8,11) ,LB=(2,6,8,9,11,15,20) 则。结果依旧是非递减的。
数据结构基础：链式有序表的合并
weirdo_cy的博客
03-16 6499
链式有序表的合并 1.简单描述： 线性表LA和LB中的数据元素按值非递减有序排列，现要求将LA和LB归并为一个新的线性表LC，且LC中的数据元素仍按值非递减有序排序。 A=（3，5，8，11） B=（2，6，8，9，11） C =（2，3，5，6，8，8，9，11，11） 2.算法思想 1.从线性表LA中取出第一个数据元素； 2.从线性表LB中取出第一个数据元素； 3.将两个元素进行比较； ...
数据结构实验报告-线性表-两个有序线性表的归并算法
04-10
实验内容及要求： 从键盘输入数据，建立两个有序线性表(每个线性表的输入数据按由小到大次序输入来建立线性表，不必考虑排序算法)；输出建好的这两个有序线性表；将这两个有序线性表归并为一个有序线性表；输出归并后的有序线性表。 从键盘实现数据输入与输出的格式自拟；要求完成两个同样功能的程序，一个程序采用顺序存储结构，另一个程序采用链表实现线性表的存储。其中链表实现时，要求利用两个升序链表的结点实现归并，即归并时不能新建结点，归并后原来两个升序链表的存储空间不在存在。 实验目的：掌握两个有序线性表的归并算法。
数据结构实验
04-13
实验1：顺序表基本操作 一、实验目的 1.学会定义线性表的顺序存储类型，实现C程序的基本结构，对线性表的一些基本操作和具体的函数定义。 2.掌握顺序表的基本操作，实现顺序表的插入、删除、查找以及求并集等运算。 3.掌握对多函数程序的输入、编辑、调试和运行过程。 二、实验要求 1．预习C语言中结构体的定义与基本操作方法。 2．对顺序表的每个基本操作用单独的函数实现。 3．编写完整程序完成下面的实验内容并上机运行。 4．整理并上交实验报告。 三、实验内容： 1．编写程序实现顺序表的下列基本操作： (1)初始化顺序表La。 (2)将La置为空表。 (3)销毁La。 (4)在La中插入一个新的元素。 (5)删除La中的某一元素。 (6)在La中查找某元素，若找到，则返回它在La中第一次出现的位置，否则返回0。 (7)打印输出La中的元素值。 2．编写程序完成下面的操作： (1)构造两个顺序线性表La和Lb，其元素都按值非递减顺序排列。 (2)实现归并La和Lb得到新的顺序表Lc，Lc的元素也按值非递减顺序排列。 (3)假设两个顺序线性表La和Lb分别表示两个集合A和B，利用 union_Sq操作实现A=A∪B。 四、思考与提高 假设两个顺序线性表La和Lb分别表示两个集合A和B，如何实现A=A ∩B ？ 实验2：单链表基本操作 一、 实验目的 1. 学会定义单链表的结点类型，实现对单链表的一些基本操作和具体的函数定义，了解并掌握单链表的类定义以及成员函数的定义与调用。 2. 掌握单链表基本操作及两个有序表归并、单链表逆置等操作的实现。 二 、实验要求 1．预习C语言中结构体的定义与基本操作方法。 2．对单链表的每个基本操作用单独的函数实现。 3．编写完整程序完成下面的实验内容并上机运行。 4．整理并上交实验报告。 三、实验内容 1．编写程序完成单链表的下列基本操作： (1)初始化单链表La。 (2)在La中第i个元素之前插入一个新结点。 (3)删除La中的第i个元素结点。 (4)在La中查找某结点并返回其位置。 (5)打印输出La中的结点元素值。 2 .构造两个带有表头结点的有序单链表La、Lb，编写程序实现将La、Lb合并成一个有序单链表Lc。 合并思想是：程序需要3个指针：pa、pb、pc，其中pa，pb分别指向La表与Lb表中当前待比较插入的结点，pc 指向Lc表中当前最后一个结点。依次扫描La和Lb中的元素，比较当前元素的值，将较小者链接到*pc之后，如此重复直到La或Lb结束为止，再将另一个链表余下的内容链接到pc所指的结点之后。 3．构造一个单链表L，其头结点指针为head，编写程序实现将L逆置。（即最后一个结点变成第一个结点，原来倒数第二个结点变成第二个结点，如此等等。） 四、思考与提高 1．如果上面实验内容2中合并的表内不允许有重复的数据该如何操作？ 2．如何将一个带头结点的单链表La分解成两个同样结构的单链表Lb，Lc，使得Lb中只含La表中奇数结点，Lc中含有La表的偶数结点？ 实验3:循环队列基本操作 一 、实验目的 1．熟悉并能实现循环队列的定义和基本操作。 2．了解用队列解决实际应用问题。 二、实验要求 1．进行队列的基本操作时要注意队列“先进先出”的特性。 2．复习关于队列操作的基础知识。 3．编写完整程序完成下面的实验内容并上机运行。 4．整理并上交实验报告。 三、实验内容 1．任意输入队列长度和队列中的元素值，构造一个顺序循环队列，对其进行清空、插入新元素、返回队头元素以及删除队头元素操作。 2．约瑟夫环的实现：设有n个人围坐在圆桌周围，现从某个位置 i 上的人开始报数，数到 m 的人就站出来。下一个人，即原来的第m+1个位置上的人，又从1开始报数，再是数到m的人站出来。依次重复下去，直到全部的人都站出来，按出列的先后又可得到一个新的序列。由于该问题是由古罗马著名的史学家Josephus提出的问题演变而来，所以通常称为Josephus 问题。 例如：当n=8,m=4,i=1时，得到的新序列为： 4，8，5，2，1，3，7，6 编写程序选择循环队列作为存储结构模拟整个过程，并依次输出出列的各人的编号。 实验4：矩阵的压缩存储及相关操作 (第11周星期三7、8节) 一 、实验目的 1．掌握下三角矩阵的输入、输出、转置算法。 2．理解稀疏矩阵的三元组表类型定义，掌握稀疏矩阵的输入、输出、转置算法。 二 、实验要求 1．认真阅读和掌握本实验的算法思想。 2．编写完整程序完成下面的实验内容并上机运行。 三、实验内容 1．所谓上（下）三角矩阵是指矩阵的下（上）三角中的元素均为常数或零的n阶矩阵。此时除了存储上（下）三角矩阵中的元素之外再加一个存储常数的空间即可。三角矩阵中的重复元素c可共享一个存储空间，其余的元素正好有n×(n+1)/2个，因此，三角矩阵可压缩到向量Sa[0……n×(n+1)/2]中，其中c存放在向量的最后一个分量中。用向量Sa[0……n×(n+1)/2]压缩存储下三角矩阵，编写程序任意输入一个下三角矩阵，对其进行转置，输出转置后的矩阵。 2．用三元组顺序表压缩存储稀疏矩阵，编写程序任意输入一个稀疏矩阵，对其进行转置，输出转置后的矩阵。 四、思考与提高 如何计算一个三元组表表示的稀疏矩阵对角线元素之和以及两个三元组表表示的稀疏矩阵的乘积？ 实验5：二叉树的建立及遍历 （第十三周星期三7、8节） 一 、实验目的 1．学会实现二叉树结点结构和对二叉树的基本操作。 2．掌握对二叉树每种操作的具体实现，学会利用递归方法编写对二叉树这种递归数据结构进行处理的算法。 二 、实验要求 1．认真阅读和掌握和本实验相关的教材内容。 2．编写完整程序完成下面的实验内容并上机运行。 3．整理并上交实验报告。 三、实验内容 1．编写程序任意输入二叉树的结点个数和结点值，构造一棵二叉树，采用三种递归遍历算法(前序、中序、后序)对这棵二叉树进行遍历并计算出二叉树的高度。 2 .编写程序生成下面所示的二叉树，并采用中序遍历的非递归算法对此二叉树进行遍历 四、思考与提高 1．如何计算二叉链表存储的二叉树中度数为1的结点数？ 2．已知有—棵以二叉链表存储的二叉树，root指向根结点，p指向二叉树中任一结点，如何求从根结点到p所指结点之间的路径? 实验6：二分查找、Hash查找算法的程序实现 （第十五三周星期三7、8节） 一、 实验目的 1 .熟练掌握二分查找算法并能在有序表中进行查找操作。 2. 掌握Hash表的相关算法。 二 、实验要求 1．认真阅读和掌握和本实验相关的教材内容。 2．复习顺序表及二叉树的基本操作过程。 3．编写完整程序完成下面的实验内容并上机运行。 4．整理并上交实验报告。 三、实验内容 1．二分查找又称为折半查找，它要求要查找的顺序表必须是有序表，即表中结点按关键字有序．并且要用顺序存储结构。 基本思想是：首先将给定值key与表中中间位置记录的关键字相比较，若二者相等，则查找成功，否则根据比较的结果确定下次查找的范围是在中间记录的前半部分还是后半部分，然后在新的查找范围内进行同样的查找，如此重复下去，直到在表中找到关键字与给定值相等的记录，或者确定表中没有这样的记录。 编写程序构造一个有序表La，从键盘接收一个关键字key，用二分查找法在La 中查找key，若找到则提示查找成功并输出key所在的位置，否则提示没有找到信息。 2．编写程序实现Hash表的建立、删除、插入以及查找操作。 程序应包含的主要功能函数有： Hash( )：计算哈希地址 InitialHash( )：初始化哈希表 SearchHash( )：在哈希表中查找关键字 InsertHash( )：向哈希表中插入关键字 DeleteHash( )：删除哈希表中某一关键字 PrintHash ( )：打印输出哈希表 四、思考与提高 如何利用二分查找算法在一个有序表中插入一个元素x，并保持表的有序性？ 实验7：至少三种排序算法的程序实现 （第十六周星期三7、8节） 一、 实验目的 1．掌握简单插入排序、冒泡排序、快速排序、堆排序以及归并排序的算法并加以应用。 2．对各种查找、排序技术的时间、空间复杂性有进一步认识。 二 、实验要求 1．认真阅读和掌握和本实验相关的教材内容。 2．编写完整程序完成下面的实验内容并上机运行。 3．整理并上交实验报告。 三、实验内容 编写程序实现下述五种算法至少三种，并用以下无序序列加以验证： 49，38，65，97，76，13，27，49 1．简单插入排序 2．冒泡排序 3．快速排序 4．归并排序 5．堆排序 四、思考与提高 1．设有1000个无序的元素，希望用最快的速度挑出其中前10个最大的元素，采用哪一种排序方法最好？为什么？ 2．如何构造一种排序方法，使五个整数至多用七次比较就可以完成排序任务？ 实验8：集成实验 一、 实验目的 目的：扩大编程量，完成模块化程序设计的全过程。 二 、实验要求 1．认真阅读和掌握和本实验相关的教材内容。 2．编写完整程序完成下面的实验内容并上机运行。 3．整理并上交实验报告。 三、实验内容 将已经实现的模块装配在一起，由菜单进行管理，形成一个小型多功能软件。 while(1){ menuList(); scanf(&n); switch(n){ case 1:……;break; case 2:……;break; . . case 0:return; } } 如： • MenuSelect( ){ int select; SqList A , B , C ; MenuList( ); /* 打印菜单 */ scanf(“%d”,&select;); switch(select){ case 1: InitList_Sq( &A ); break; case 2: InitList_Sq( &B ); break; case 3: Insert(&A);break; case 4: Insert(&B );break; case 5: Union(&A ,B);break; ………….. default: printf(“\n ERROR\n”); } } 四、思考与提高 1． 优化已完成的程序，使整个实验形成至少三级菜单管理； 2．美化输出界面，使得操作友好。
将所有在线性表Lb中但不在La中的数据元素插入到La中
12-25
将所有在线性表Lb中但不在La中的数据元素插入到La中
已知线性表中的元素以值递增有序排列，并以单链表作存储结构。试写一高效的算法，删除表中所有值相同的多余元素（使得操作后的线性表中所有元素的值均不相同）
11-24
包含一个函数，参数为链表表头地址，返回经过处理的新的链表表头地址。该函数将一个按照升序排列的链表中的重复元素删除，时间复杂度为（n）
数据结构实验报告1-线性表-两个有序表的归并-实验内容及要求.docx
07-06
从键盘输入数据，建立两个有序线性表(每个线性表的输入数据按由小到大次序输入来建立线性表，不必考虑排序算法)；输出建好的这两个有序线性表；将这两个有序线性表归并为一个有序线性表；输出归并后的有序线性表。 从键盘实现数据输入与输出的格式自拟；要求完成两个同样功能的程序，一个程序采用顺序存储结构，另一个程序采用链表实现线性表的存储。其中链表实现时，要求利用两个升序链表的结点实现归并，即归并时不能新建结点，归并后原来两个升序链表的存储空间不在存在。 实验目的：掌握两个有序线性表的归并算法。
假设利用两个线性表LA和LB分别表示两个集合A和B（即线性表中的数据元素即为集合中的成员），现要求一个新的集合A=AUB。这就要求对线性表作如下操作：扩大线性表LA，将存在于线性表LB中而不存在于线性
AKK188888881的博客
07-09 8456
假设利用两个线性表LA和LB分别表示两个集合A和B（即线性表中的数据元素即为集合中的成员），现要求一个新的集合A=AUB。这就要求对线性表作如下操作：扩大线性表LA，将存在于线性表LB中而不存在于线性表LA中的数据元素插入到线性表LA中去。只要从线性表LB中依次取得每个数据元素，并依值在线性表LA中进行查访，若不存在，则插入之。 #include <stdio.h> #include <stdlib.h> #define TRUE 1 #define FALSE 0 #define
两个N×N矩阵相乘的算法。
AKK188888881的博客
07-04 4750
两个N×N矩阵相乘的算法。 #include<stdio.h> #define n 3 int main() { int i, j, k; int a[n][n] = { 1,2,3,4,5,6,7,8,9 }, b[n][n] = { 1,2,3,4,5,6,7,8,9 }, c[n][n] = { 0 }; for (i = 0; i < n; ++i) //i是数组a的行 { for (j = 0; j < n; ++j) //j是数组b的列,k是数组a的
抽象数据类型线性表（顺序表）的定义构造
AKK188888881的博客
07-09 1811
抽象数据类型线性表（顺序表）的定义构造 main.cpp #include <stdio.h> #include <stdlib.h> #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASALBE -1 #define OVERFLOW -2 #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 #define ElemType int
已知线性表LA和LB中的元素按值非递减有序排列，现要求将LA和LB归并为一个新的线性表LC，且LC中的元素仍按值非递减有序排列。请用c语言程序实现上述代码。
03-20
以下是C语言程序实现上述代码： #include <stdio.h> void merge(int LA[], int LB[], int LC[], int lenA, int lenB) { int i = 0, j = 0, k = 0; while (i < lenA && j < lenB) { if (LA[i] <= LB[j]) { LC[k++] = LA[i++]; } else { LC[k++] = LB[j++]; } } while (i < lenA) { LC[k++] = LA[i++]; } while (j < lenB) { LC[k++] = LB[j++]; } } int main() { int LA[] = {1, 3, 5, 7, 9}; int LB[] = {2, 4, 6, 8, 10}; int lenA = sizeof(LA) / sizeof(int); int lenB = sizeof(LB) / sizeof(int); int LC[lenA + lenB]; merge(LA, LB, LC, lenA, lenB); printf("Merged array: "); for (int i = 0; i < lenA + lenB; i++) { printf("%d ", LC[i]); } printf("\n"); return 0; }

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值