数据结构编程题

已于 2023-04-12 09:44:14 修改
阅读量5.4k 收藏 100
点赞数 12
分类专栏： 数据结构（C语言版） 文章标签： 数据结构
于 2021-03-21 18:45:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43482612/article/details/115052946
版权

考研数据结构编程题（附完整代码）

1、给定一个含n(n≥1)个整数的数组，请设计一个在时间上尽可能高效的算法，找出数组中未出现的最小正整数。例如，数组{-5，3，2，3}中未出现的最小正整数是1；数组{1，2，3}中未出现的最小正整数是4。要求：

（1）给出算法的基本设计思想。
要求在时间上尽可能高效，因此采用空间换时间的方法。分配一个用于标记的数组B[n],用于记录A中是否出现了1到n中的正整数，B[0]对应正整数1，B[n=1]对应正整数n,初始化B中全部为0。由于A中含有n个整数，因此可能返回的值是1到n+1,当A中n个数恰好为1~n时返回n+1,当数组A中出现了小于等于0或大于n的值，可以不采取任何操作。经过以上分析可以得出算法流程：从A[0]开始遍历A，若0<A[i]<=n,则令B[A[i] - 1]=1，否则不做操作。对A遍历结束后开始遍历数组B，若能查找到第一个满足B[i]==0的下标i,返回i+1即为结果，此时说明A中未出现的最小正整数在1~n之间，若B[i]全部不为0，返回i+1(跳出循环时i=n,i+1=n+1),此时说明A中未出现的最小正整数是I+1.
（2）根据设计思想，采用C或C++语言描述算法，关键之处给出解释。
算法实现：

int findMissMin(int A[],int n) {
	int i,*B; //标记数组
	B=(int *)malloc(sizeof(int)*n); //分配空间
	memset(B,0,sizeof(int)*n); //赋初值为0 
	for (i = 0; i < n;i++)
		if (A[i]>0&&A[i]<=n) //若A[i]的值介于1~n,则标记数组B 
			B[A[i] - 1] = 1;
	for (i = 0; i < n;i++) //扫描数组B，找到目标值
		if (B[i]==0) break;
	return i+1; //返回结果
}

（3）说明你所设计算法的时间复杂度和空间复杂度。
时间复杂度：遍历A一次，遍历B一次，两次循环的操作步骤为O（1）量级，因此时间复杂度为O(n)。空间复杂度：额外分配了B[n],空间复杂度为O（n）.
附完整代码：

#include <iostream>
#include <malloc.h> 
#include <cstring>
using namespace std;
int findMissMin(int A[],int n) {
	int i,*B; //标记数组
	B=(int *)malloc(sizeof(int)*n); //分配空间
	memset(B,0,sizeof(int)*n); //赋初值为0 
	//遍历数组A[n]给B[n]赋标记值
	for (i = 0; i < n;i++)
		if (A[i]>0&&A[i]<=n) //若A[i]的值介于1~n,则标记数组B 
			B[A[i] - 1] = 1;
	for (i = 0; i < n;i++) //找到第一个满足B[i]=0的下标i
		if (B[i]==0) break;
	//说明A[n]中的标记值全为1，也就是说A[i]的值一一对应1<i<=n中的某个值，每个值只出现一次。那么说明数组中未出现的最小正整数为n+1。
	return i+1;
}
int main(){
	int A1[] = {-5,3,2,3};
	//获取数组的最大值
	cout <<"数组{-5,3,2,3}中未出现的最小正整数是："<< findMissMin(A1,4) << endl;
	int A2[] = {1,2,3};
	cout << "数组{1,2,3}中未出现的最小正整数是：" << findMissMin(A2, 3) << endl;
	int A3[] = { 1,5,6,2,0,88};
	cout << "数组{1,5,6,2,0,88}中未出现的最小正整数是：" << findMissMin(A3, 6) << endl;
	system("pause");
}

在这里插入图片描述

2、定义三元组（a,b,c)(a、b、c、均为正数）的距离D=|a-b|+|b-c|+|c-a|。给定3个非空整数集合S1、S2和S3，按升序分别存储在3个数组中。请设计一个尽可能高效的算法，计算并输出所有可能的三元组(a,b,c)(a∈S1,b∈S2,c∈S3)中的最小距离。例如S1={-1,0，9}，S2={-25，-10,10,11}，S3={2,9，17,30,41}，则最小距离为2，相应的三元组为{9,10,9}。要求：

（1）给出算法的基本设计思想。
①使用Dmin记录所有已处理的三元组的最小距离，初值为一个足够大的整数。
②集合S1、S2和S3分别保存在数组A、B、C中。数组的下标变量i=j=k=0,当i<|S1|,j<|S2|且k<|S3|时，（S表示集合中的元素个数），循环执行下面的a)~c)。
a)计算（A[i],B[j],C[k]）的距离D；（计算D）
b)若D<Dmin,则Dmin=D；（更新D)
c)将A[i]、B[j]、C[k]中的最小值的下标+1；（对照分析：最小值为a，最大值为c，这里c不变而更新a，试图寻找更小的距离D)
③输出Dmin,结束。
（2）根据设计思想，采用C或C++语言描述算法，关键之处给出解释。
算法实现：

#define INT_MAX 0x7fffffff
int abs_(int a){ //计算绝对值 
	if(a<0) return -a;
	else return a;
}
bool xls_min(int a,int b,int c){ //a是否是三个数中的最小值 
	if(a<=b&&a<=c) return true;
	return false;
}
int findMinofTrip(int A[],int n,int B[],int m,int C[],int p){
	//D_min用于记录三元组的最小距离，初值赋为INT_MAX 
	int i=0,j=0,k=0,D_min=INT_MAX,D;
	while(i<n&&j<m&&k<p&&D_min>0){
		cout<<A[i]<<' '<<B[j]<<' '<<C[k]<<endl;
		D=abs_(A[i]-B[j])+abs_(B[j]-C[k])+abs_(C[k]-A[i]); //计算D 
		if(D<D_min) D_min=D; //更新D
		if(xls_min(A[i],B[j],C[k])) i++; //更新a
		else if(xls_min(B[j],C[k],A[i])) j++;
		else k++;
	}
	return D_min; 
}

（3）说明你说设计算法的时间复杂度和空间复杂度。
设n=(|S1|+|S2|+|S3|），时间复杂度为O(n)，空间复杂度为O(1)。
附完整代码：

#include <iostream>
using namespace std;
int abs_(int a){ //计算绝对值 
	if(a<0) return -a;
	else return a;
}
bool xls_min(int a,int b,int c){ //a是否是三个数中的最小值 
	if(a<=b&&a<=c) return true;
	return false;
}
int findMinofTrip(int A[],int n,int B[],int m,int C[],int p){
	//D_min用于记录三元组的最小距离，初值赋为INT_MAX 
	int i=0,j=0,k=0,D_min=INT_MAX,D;
	while(i<n&&j<m&&k<p&&D_min>0){
		cout<<A[i]<<' '<<B[j]<<' '<<C[k]<<endl;
		D=abs_(A[i]-B[j])+abs_(B[j]-C[k])+abs_(C[k]-A[i]); //计算D 
		if(D<D_min) D_min=D; //更新D
		if(xls_min(A[i],B[j],C[k])) i++; //更新a
		else if(xls_min(B[j],C[k],A[i])) j++;
		else k++;
	}
	return D_min; 
}
int main(){
	int A[] = {-1,0,9};
	int B[] = {-25,-10,10,11};
	int C[] = {2,9,17,30,41};
	cout <<"最小距离是："<< findMinofTrip(A,3,B,4,C,5) << endl;
}

在这里插入图片描述

3、设L为带头结点的单链表，编写算法实现从尾到头反向输出每个结点的值。

算法实现（递归）：

void R_Print(LinkList L){
	//从尾到头输出单链表L中每个结点的值
	if(L->next!=NULL){
		R_Print(L->next); //递归 
	} 
	if(L!=NULL) printf(L->data);
} 
void R_Ignore_Head(LinkList L){
	if(L!=NULL) R_Print(L->next);
}

附完整代码：

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<math.h>
#define ERROR 0 
#define OK 1 
typedef char ElemType;
typedef int Status;
typedef struct LNode {
 	ElemType data;
 	struct LNode *next;
 }LNode,*LinkList; 
//操作结果:构造一个空的线性单链表L 
Status ListInit_L(LinkList &L){
	L=(LinkList)malloc(sizeof(LNode));//头结点申请地址 
 	if(!L){//if(L==NULL) 
 		printf("分配内存失败!\n");
  		exit(OVERFLOW);
  	}
 	else
  		L->next=NULL;
  	return OK;
}
 //初始条件:线性单链表L已存在 
 //操作结果:逆位序输入n个元素的值，建立带表头结点的线性单链表 L(头插法) 
void ListCreate_L(LinkList &L,int n){
 	L=(LinkList)malloc(sizeof(LNode));
 	L->next=NULL;//先建立一个带头结点的单链表 
 	LinkList p;
    srand(unsigned(time(0)));  //初始化随机数种子	
    printf("请输入你要插入的元素值(用空格隔开):");
 	for(int i=n;i>0;--i){
	 	p=(LinkList)malloc(sizeof(LNode));//生成新结点 
		p->data=rand()%100+1; //随机生成100以内的数字，比scanf()操作简单些 
		//插入到表头
	 	p->next=L->next; 
		L->next=p; //将结点p连接在头结点L之后 
	}
	printf("\n");
 }
//初始条件:线性单链表L已存在
//操作结果:将L重置为空表 
Status ListClear_L(LinkList &L){
	LinkList p=L->next;//p指向第一个结点 
	LinkList q;
	while(p)//没到表尾 
	{
		q=p->next;
        free(p);
        p=q;
	}
	L->next=NULL;//头结点指针域为空 
	return OK;
}
//初始条件:线性单链表L已存在 
//操作结果:销毁线性单链表L 
Status ListDestroy_L(LinkList &L){
	LinkList p;
	while(L)
	{
		p=L;
		L=L->next;
		free(p);
	}
	return OK;
}
//操作结果:显示单链表各个元素 
Status ListDis_L(LinkList &L){
   LinkList p=L->next;
   if(!p){
	   printf("这是一个空目录！\n");
       return ERROR;
	}
	printf("单链表:\n");
   while(p){
     printf("%d ",p->data);
     p=p->next;
   }
   printf("\n");
   return OK;
}
//递归：从尾到头输出单链表L中每个结点的值
void R_Print(LinkList L){
	if(L->next!=NULL){
		R_Print(L->next); //递归 
	} 
	if(L!=NULL) printf("%d ",L->data);
} 
void R_Ignore_Head(LinkList L){
	if(L!=NULL) R_Print(L->next);
}
int main(){
 	LinkList h;
 	ListInit_L(h);
 	ElemType e;
 	int k,i;
 	ListCreate_L(h,10);
 	ListDis_L(h);
 	printf("逆置L\n");
 	R_Ignore_Head(h);
 	ListClear_L(h);
 	printf("\n销毁后线性单链表L的元素为：\n",ListDestroy_L(h));	
 	system("pause");
 	return 0;
 }

在这里插入图片描述

4、有一个带头结点的单链表L，设计一个算法使其元素递增有序。

算法实现：

void Sort(LinkList &L){
	LNode *p=L->next,*pre;
	LNode *r=p->next; //r保持*p后继结点指针，以保证不断链 
	p->next=NULL; //构造只含一个数据结点的有序表 
	p=r;
	while(p!=NULL){
		r=p->next; //保存*p的后继结点指针 
		pre=L;
		while(pre->next!=NULL&&pre->next->data<p->data)
			pre=pre->next; //在有序表中查找插入*p的前驱节点*pre 
		p->next=pre->next; //将*p插入到*pre之后 
		pre->next=p;
		p=r; //扫描原单链表中剩下的结点 
	}
}

附完整代码：

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<math.h>
#define ERROR 0 
#define OK 1 
typedef char ElemType;
typedef int Status;
typedef struct LNode {
 	ElemType data;
 	struct LNode *next;
 }LNode,*LinkList; 
//操作结果:构造一个空的线性单链表L 
Status ListInit_L(LinkList &L){
	L=(LinkList)malloc(sizeof(LNode));//头结点申请地址 
 	if(!L){//if(L==NULL) 
 		printf("分配内存失败!\n");
  		exit(OVERFLOW);
  	}
 	else
  		L->next=NULL;
  	return OK;
}
 //初始条件:线性单链表L已存在 
 //操作结果:逆位序输入n个元素的值，建立带表头结点的线性单链表 L(头插法) 
void ListCreate_L(LinkList &L,int n){
 	L=(LinkList)malloc(sizeof(LNode));
 	L->next=NULL;//先建立一个带头结点的单链表 
 	LinkList p;
    srand(unsigned(time(0)));  //初始化随机数种子	
    printf("请输入你要插入的元素值(用空格隔开):");
 	for(int i=n;i>0;--i){
	 	p=(LinkList)malloc(sizeof(LNode));//生成新结点 
		p->data=rand()%100+1; //随机生成100以内的数字，比scanf()操作简单些 
		//插入到表头
	 	p->next=L->next; 
		L->next=p; //将结点p连接在头结点L之后 
	}
	printf("\n");
 }
//初始条件:线性单链表L已存在
//操作结果:将L重置为空表 
Status ListClear_L(LinkList &L){
	LinkList p=L->next;//p指向第一个结点 
	LinkList q;
	while(p)//没到表尾 
	{
		q=p->next;
        free(p);
        p=q;
	}
	L->next=NULL;//头结点指针域为空 
	return OK;
}
//初始条件:线性单链表L已存在 
//操作结果:销毁线性单链表L 
Status ListDestroy_L(LinkList &L){
	LinkList p;
	while(L)
	{
		p=L;
		L=L->next;
		free(p);
	}
	return OK;
}
//操作结果:显示单链表各个元素 
Status ListDis_L(LinkList &L){
   LinkList p=L->next;
   if(!p){
	   printf("这是一个空目录！\n");
       return ERROR;
	}
   while(p){
     printf("%d ",p->data);
     p=p->next;
   }
   printf("\n");
   return OK;
}
//将单链表L的结点重排，使其递增有序
void Sort(LinkList &L){
	LNode *p=L->next,*pre;
	LNode *r=p->next; //r保持*p后继结点指针，以保证不断链 
	p->next=NULL; //构造只含一个数据结点的有序表 
	p=r;
	while(p!=NULL){
		r=p->next; //保存*p的后继结点指针 
		pre=L;
		while(pre->next!=NULL&&pre->next->data<p->data)
			pre=pre->next; //在有序表中查找插入*p的前驱节点*pre 
		p->next=pre->next; //将*p插入到*pre之后 
		pre->next=p;
		p=r; //扫描原单链表中剩下的结点 
		ListDis_L(L); //查看单链表L递增排序的过程 
	}
} 
int main(){
 	LinkList h;
 	ListInit_L(h);
 	ElemType e;
 	int k,i;
 	ListCreate_L(h,10);
 	ListDis_L(h);
 	printf("重排L递增\n");
 	Sort(h);
 	ListClear_L(h);
 	printf("销毁后线性单链表L的元素为：\n",ListDestroy_L(h));	
 	system("pause");
 	return 0;
 }

在这里插入图片描述

代码调试过程

5、给定一个带表头结点的单链表，设head为头指针，结点结构为(data,next),data为整形元素，next为指针，试写出算法：按递增次序输出单链表中各结点的数据元素，并释放结点所占的存储空间（要求：不允许使用数组作为辅助空间）。

算法实现：

//L是带头结点的单链表的头指针，本算法按递增顺序输出单链表中的数据元素 
void Min_Delete(LinkList &L){
	while(L->next!=NULL){  //循环到仅剩头结点 
		LNode *pre=L; //pre为元素最小值结点的前驱节点的指针 
		LNode *p=pre->next; //p为工作指针 
		while(p->next!=NULL){
			if(p->next->data<pre->next->data) 
			pre=p; //记住当前最小值结点的前驱 
			p=p->next;
		}
		printf("%d\n",pre->next->data); //输出元素最小值结点的元素 
		LinkList u=pre->next; //删除元素值最小的结点 
		pre->next=u->next;
		free(u);  
	}
	free(L); //释放头结点
}

完整代码：

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<math.h>
#define ERROR 0 
#define OK 1 
typedef char ElemType;
typedef int Status;
typedef struct LNode {
 	ElemType data;
 	struct LNode *next;
 }LNode,*LinkList; 
//操作结果:构造一个空的线性单链表L 
Status ListInit_L(LinkList &L){
	L=(LinkList)malloc(sizeof(LNode));//头结点申请地址 
 	if(!L){//if(L==NULL) 
 		printf("分配内存失败!\n");
  		exit(OVERFLOW);
  	}
 	else
  		L->next=NULL;
  	return OK;
}
 //初始条件:线性单链表L已存在 
 //操作结果:逆位序输入n个元素的值，建立带表头结点的线性单链表 L(头插法) 
void ListCreate_L(LinkList &L,int n){
 	L=(LinkList)malloc(sizeof(LNode));
 	L->next=NULL;//先建立一个带头结点的单链表 
 	LinkList p;
    srand(unsigned(time(0)));  //初始化随机数种子	
    printf("请输入你要插入的元素值(用空格隔开):");
 	for(int i=n;i>0;--i){
	 	p=(LinkList)malloc(sizeof(LNode));//生成新结点 
		p->data=rand()%100+1; //随机生成100以内的数字，比scanf()操作简单些 
		//插入到表头
	 	p->next=L->next; 
		L->next=p; //将结点p连接在头结点L之后 
	}
	printf("\n");
 }
//初始条件:线性单链表L已存在
//操作结果:将L重置为空表 
Status ListClear_L(LinkList &L){
	LinkList p=L->next;//p指向第一个结点 
	LinkList q;
	while(p)//没到表尾 
	{
		q=p->next;
        free(p);
        p=q;
	}
	L->next=NULL;//头结点指针域为空 
	return OK;
}
//初始条件:线性单链表L已存在 
//操作结果:销毁线性单链表L 
Status ListDestroy_L(LinkList &L){
	LinkList p;
	while(L)
	{
		p=L;
		L=L->next;
		free(p);
	}
	return OK;
}
//操作结果:显示单链表各个元素 
Status ListDis_L(LinkList &L){
   LinkList p=L->next;
   if(!p){
	   printf("这是一个空目录！\n");
       return ERROR;
	}
   while(p){
     printf("%d ",p->data);
     p=p->next;
   }
   printf("\n");
   return OK;
}
//L是带头结点的单链表的头指针，本算法按递增顺序输出单链表中的数据元素 
void Min_Delete(LinkList &L){
	while(L->next!=NULL){  //循环到仅剩头结点 
		LNode *pre=L; //pre为元素最小值结点的前驱节点的指针 
		LNode *p=pre->next; //p为工作指针 
		while(p->next!=NULL){
			if(p->next->data<pre->next->data) pre=p; //记住当前最小值结点的前驱 
			p=p->next;
		}
		printf("%d\n",pre->next->data); //输出元素最小值结点的元素 
		ListDis_L(L); //删除最小值之后的单链表中的元素 
		LinkList u=pre->next; //删除元素值最小的结点 
		pre->next=u->next;
		free(u);
	}
	free(L); //释放头结点 
} 
int main(){
 	LinkList h;
 	ListInit_L(h);
 	ElemType e;
 	int k,i;
 	ListCreate_L(h,10);
 	ListDis_L(h);
 	printf("从小到大排序L\n");
 	Min_Delete(h);
 	ListClear_L(h);
 	printf("\n销毁后线性单链表L的元素为：\n",ListDestroy_L(h));	
 	system("pause");
 	return 0;
 }

在这里插入图片描述

6、假设有两个按元素值递增次序排列的线性表，均以单链表形式存储。请编写算法将这两个单链表归并为一个按元素值递减次序排列的单链表，并要求利用原来两个单链表的结点存放归并后的单链表。

算法实现：

//合并两个递增有序链表（带头结点），并使合并后的链表递减排列 
void MergeList(LinkList &La, LinkList &Lb){
	LNode *r,*pa = La->next,*pb = Lb->next; //分别是表La和Lb的工作指针 
	La->next = NULL; //La作为结果链表的头指针，先将结果链表初始化为空 
	while(pa && pb) //当两链表均不为空时，循环 
		if(pa->data <= pb->data){
			r=pa->next; //r暂存pa的后继结点指针
			pa->next=La->next;
			La->next=pa; //将pa结点链于结果表中，同时逆置（头插法） 
			pa=r; //恢复pa为当前待比较结点 
		}
		else{
			r=pb->next; //r暂存pb的后继结点指针
			pb->next=La->next;
			La->next=pb; //将pb结点链于结果表中，同时逆置（头插法） 
			pb=r; //恢复pb为当前待比较结点 
		}
		if(pa)
			pb = pa;
		while(pb){ //处理剩下的一个非空链表 
			r=pb->next; //依次插入到La中（头插法 
			pb->next=La->next; 
			La->next=pb;
			pb=r; 
		}
	free(La);
}

完整代码：
法一：

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <ctime>
using namespace std;
typedef char ElemType;
typedef struct LNode{
	ElemType data;
	struct LNode *next;
}LNode, *LinkList;
LinkList CreateList(){
	LinkList L;
	ElemType c;
	L = (LinkList)malloc(sizeof(LNode));
	L->next = NULL;
	LNode *p , *tail;
	tail = L;
	c = getchar();
	while(c != '#'){
		p = (LNode *)malloc(sizeof(LNode));
		p->data = c;
		tail->next = p;
		tail = p;
		c = getchar();
	}
	tail->next = NULL;
	return L;
}
void ShowList(LinkList L){
	LNode *p;
	p = L->next;
	while(p != NULL){
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}
//合并两个递增有序链表（带头结点），并使合并后的链表递减排列 
LinkList MergeList(LinkList &La, LinkList &Lb){
	LNode *r,*pa = La->next,*pb = Lb->next; //分别是表La和Lb的工作指针 
	La->next = NULL; //La作为结果链表的头指针，先将结果链表初始化为空 
	while(pa && pb) //当两链表均不为空时，循环 
		if(pa->data <= pb->data){
			r=pa->next; //r暂存pa的后继结点指针
			pa->next=La->next;
			La->next=pa; //将pa结点链于结果表中，同时逆置（头插法） 
			pa=r; //恢复pa为当前待比较结点 
		}
		else{
			r=pb->next; //r暂存pb的后继结点指针
			pb->next=La->next;
			La->next=pb; //将pb结点链于结果表中，同时逆置（头插法） 
			pb=r; //恢复pb为当前待比较结点 
		}
		if(pa)
			pb = pa;
		while(pb){ //处理剩下的一个非空链表 
			r=pb->next; //依次插入到La中（头插法 
			pb->next=La->next; 
			La->next=pb;
			pb=r; 
		}
	return La;
}
int main(){
	LinkList La,Lb,Lc;
	La = CreateList();
	getchar();
	Lb = CreateList();
	cout << "La:" << endl;
	ShowList(La); 
	cout << "Lb:" << endl;
	ShowList(Lb);
	Lc= MergeList(La, Lb);
	cout << "MergeList:" << endl;
	ShowList(Lc);
	return 0;
}

法二：

#include<stdio.h>
#include<stdlib.h>
#include <iostream>
using namespace std;
typedef char ElemType;
typedef int Status;
typedef struct LNode {
 	ElemType data;
 	struct LNode *next;
 }LNode,*LinkList; 
LinkList CreateList(){
	LinkList L;
	ElemType c;
	L = (LinkList)malloc(sizeof(LNode));
	L->next = NULL;
	LNode *p , *tail;
	tail = L;
	c = getchar();
	while(c != '#'){
		p = (LNode *)malloc(sizeof(LNode));
		p->data = c;
		tail->next = p;
		tail = p;
		c = getchar();
	}
	tail->next = NULL;
	return L;
}
//操作结果:将L重置为空表 
Status ListClear_L(LinkList &L){
	LinkList p=L->next;//p指向第一个结点 
	LinkList q;
	while(p){ //没到表尾 
		q=p->next;
        free(p);
        p=q;
	}
	L->next=NULL;//头结点指针域为空 
	return 1;
}
//操作结果:销毁线性单链表L 
Status ListDestroy_L(LinkList &L){
	LinkList p;
	while(L)
	{
		p=L;
		L=L->next;
		free(p);
	}
	return 1;
}
//操作结果:显示单链表各个元素 
Status ListDis_L(LinkList L){
    LNode *p;
	p = L->next;
	while(p != NULL){
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}
void ReverseList(LinkList L){
	LNode *p, *q;
	p = L->next;
	L->next = NULL;
	while(p != NULL){
		q = p->next;
		p->next = L->next;
		L->next = p;
		p = q;
	}
}
LinkList MergeList2(LinkList LA, LinkList LB){
	ReverseList(LA);
	ReverseList(LB);
	LinkList LC;
	LNode *pa, *pb, *r;
	pa = LA->next;
	pb = LB->next;
	LC = LA;
	LC->next = NULL;
	r = LC;
	while(pa != NULL && pb != NULL){
		if(pa->data <= pb->data){
			r->next = pb;
			r = pb;
			pb = pb->next;
		}
		else{
			r->next = pa;
			r = pa;
			pa = pa->next;
		}
		if(pa){
			r->next = pa;
		}
		else{
			r->next = pb;	
		}
	}
	return LC;
}
int main(){
 	LinkList LA,LB,LC;
	LA = CreateList();
	getchar();
	LB = CreateList();
	cout << "LA:" << endl;
	ListDis_L(LA); 
	cout << "LB:" << endl;
	ListDis_L(LB);
	LC = MergeList2(LA, LB);
	cout << "MergeList2:" << endl;
	ListDis_L(LC);
	return 0;
 }

在这里插入图片描述

向着太阳，向着光
关注
  • 12
    点赞
  • 踩
  • 100
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
数据结构试题大题编程及参考答案_数据结构经典编程习题
01-02
学习数据结构课程的一些经典编程题目，以及答案
数据结构经典代码题（从小白开始）
m0_58323186的博客
11-12 2182
2.对长度为n的顺序表L,编写一个时间复杂度为O（n）,空间复杂度为O(1)的算法，该算法删除线性表中所有值为x的元素。算法思想：遍历顺序表，用k记录顺序表中值为x的个数，让其中元素不等于x的向前移动k个单位量。解题思路：第一个元素不重复，依次遍历顺序表，如果值相同就保留下来，如果值不相同就删除。1.设计一个高效算法，将顺序表L的所有元素逆置，要求算法空间复杂度为常数级。算法思想：依次将顺序表L前半部分的元素与顺序表后半部分的元素进行交换。
【数据结构与算法】之8道顺序表与链表典型编程题心决！
最新发布
2301_80221228的博客
04-12 2326
例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0 1,3,0, 4。从编号为 1 的人开始报数，报到 m 的人离开。新链表是通过拼接给定的两个链表的所有节点组成的。元素的顺序可以改变。方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。,5,6] ，其中斜体加粗标注的为 nums1 中的元素。需要合并 [1,2,3] 和 [2,5,6]。
数据结构代码题-----Day03
brotherand的博客
10-07 4485
数据结构代码题目总结 题目01 试编写带头结点的单链表L中删除一个最小值节点的高效算法，（假设最小值是唯一的） 思路分析： 首先是需要找到最小值 删除最小值 如何找到最小值呢 根据上图图片，这里设置了p指针作为头节点后的指针，同时根据总结需要对其进行设计 所需的指针数量 扫描指针一个 minP最小值指针一个 前驱指针一个pre 最小值前驱一个preMinp 查找最小值节点实现思路 指针P遍历链表， 在遍历过程中若P->data 小于 MinP->data的数据，设置minp为当前的p
数据结构题目整理（编程）
paintShadow的博客
09-15 8772
0-1求链式表的表长 本题要求实现一个函数，求链式表的表长。 函数接口定义： int Length( List L ); 其中List结构定义如下： typedef struct LNode *PtrToLNode; struct LNode { ElementType Data; PtrToLNode Next; }; typedef PtrToLNode List; L是给...
数据结构编程题汇总
11-07
考研数据结构编程题汇总，计算机专业课数据结构考研编程题汇总
数据结构编程题答案
11-12
编程打印出列顺序。 4.按先序扩展序列建立二叉树 5.先序、中序、后序遍历的递归算法 6.中序遍历的非递归算法 7.先序遍历的非递归算法 8.后序遍历的非递归算法 9.层次的非递归算法 10.求二叉树的深度(后序遍历) 11.求...
数据结构编程题.doc
07-14
"数据结构编程题" 本资源总共包含五个编程题，涵盖了数据结构的多个方面，包括二叉树的遍历、重建、表达式树和堆结构的实现。 4-2:文本二叉树 本题要求实现一个文本二叉树的遍历，给定一个文本表示的二叉树，输出...
大连东软数据结构编程题.docx
07-11
大连东软数据结构编程题全文共8页，当前为第1页。大连东软数据结构编程题全文共8页，当前为第1页。数据结构编程题 大连东软数据结构编程题全文共8页，当前为第1页。 大连东软数据结构编程题全文共8页，当前为第1页。...
解题笔记（40）——第1-39篇合集
热门推荐
wuzhekai的专栏
10-07 2万+
2011年7月至今，解题笔记系列已有39篇文章，本文做一个归纳及索引，方便网友阅读参考。其中的题目多出自两个博客，一个是JULY的，另一个是何海涛的。上面有题目，也有解题思路及代码。       JULY的博客  http://blog.csdn.net/v_JULY_v/ar
数据结构代码题总结-------Day06
brotherand的博客
10-11 3956
数据结构代码题总结 题目01 已知两个链表A和B分别表示两个集合，其元素递增有序排列，编制函数求A和B的交集，并存放在A链表中 题目分析： 求A和B的交集，与求A和B的公共元素不同 并存在在A链表中，-----代表着不可以再申请一个链表的存储空间 与不破坏A和B的结构节点不相同，这里不可以再申请一个新的链表空间。 存放在A链表中表示只可以在A链表上修改 算法思路图解 结合以上的算法图解，对其算法思路进行概述： 设置两个扫描指针p和q，进行对A和B链表的扫描进行操作，同时对其进行p和q所指向节
数据结构：编程题
LYC_462857656的博客
05-29 913
持续更新..
给定一个含n(n≥1)个整数的数组，请设计一个在时间上尽可能高效的算法，找出数组中未出现的最小正整数。
陌意随影的博客
03-04 1万+
笔者初涉《算法设计与分析》这门专业课，在做一些算法设计题的过程中遇到一些小感悟，特此记录和大家分享。 下面直接给出算法题目： 给定一个含n(n≥1)个整数的数组，请设计一个在时间上尽可能高效的算法，找出数组中未出现的最小正整数。例如，数组{-5, 3, 2, 3}中未出现的最小正整数是1；数组{1, 2, 3}中未出现的最小正整数是4。 笔者在看完这道题目后，进行了如下分析： （1）题目要求算法时...
常用数据结构与算法总结（含例题和完整代码）
myjess’s blog
04-23 6193
一、位运算 ● ^ 可理解为不进位相加 ● a^a=0 ● a^0=a 题目一 一组数中，只有一个数出现的次数是奇数，其他数字出现的次数都为偶数，找出这个出现次数为奇数的数。 public static void printOddTimesNum1(int[] arr) { int eor = 0; for (int i : arr) { eor ^= i; } System.out.println(eor); } 题目二 一组数中，只有两个数出现的次数是奇
数据结构编程题（不断更新）
WangQYoho的博客
09-27 6631
记录一些数据结构的编程题好题： 1、计算二叉树深度 public class Solution { public int TreeDepth(TreeNode pRoot) { return pRoot == null ? 0 : Math.max(TreeDepth(pRoot.left), TreeDepth(pRoot.right)) + 1; } }递归
【数据结构应用题】线性表的链式表示（含统考真题）
Obliviate的博客
01-24 1665
【数据结构应用题】线性表的链式表示（含统考真题）
数据结构代码题（入土第34天）结束
Kunjpg的博客
09-14 2832
考研408数据结构代码题型记录
数据结构复习题——编程题
weixin_46448596的博客
01-14 934
7-1 求素数个数、7-2 数组循环左移、7-28 两个有序链表序列的合并、7-176 目录树、7-179 畅通工程之最低成本建设问题、7-207 寻找大富翁、7-209 最长连续递增子序列、7-3 迷你搜索引擎、7-233 排序、7-237 选择法排序、7-241 冒泡法排序、7-266 堆栈操作合法性
数据结构编程题二叉树
08-19
- *1* [王道数据结构编程题（二叉树）](https://blog.csdn.net/qq_43686863/article/details/123334790)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值