数据结构编程题

已于 2023-04-12 09:44:14 修改
阅读量5.8k 收藏 101
点赞数 13
分类专栏： 数据结构（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;
 }

在这里插入图片描述

数据结构程序题
04-21
本文档是数据结构经典的程序题目，适合初学者，以及大学期末考试
C语言数据结构编程题.txt
11-11
将一整数逆序后放入一数组中（要求递归实现） 求高于平均分的学生学号及成绩（学号和成绩人工输入）
数据结构代码合集
最新发布
张锦的博客
11-26 1146
不管是邻接表还是邻接矩阵在实现上都差不多主要是firstNeibor和nextNeibor有点不同。代码中可能存在一些不足之处，仅供您参考。如果不好想的话，可以中序遍历放到数组中，然后挨个比较。同样下面的DFS算法都适用于有向图和无向图的邻接矩阵。下面的BFS算法都适用于有向图和无向图的邻接矩阵。条件：无回路连通图或n-1边的连通图。非递归主要是判断当前是第几层。二叉树的先、中、后代码略。想不到的话还能用数组。想不到的话还有笨方法。
数据结构作业代码（c语言）
11-17
数据结构作业（c语言代码）： 先序建立二叉树、八皇后问题、编写DFS算法的非递归函数、层次非递归、二叉树的三种遍历、斐波那契数列、简单选择排序、冒泡排序、二叉树深度求解、顺序查找、先中后序递归算法、用普利姆算法生产最小生成树、约瑟夫环、折半查找、折半插入排序
数据结构编程题汇总
11-07
考研数据结构编程题汇总，计算机专业课数据结构考研编程题汇总
数据结构例题代码及其讲解-查找和排序
knighthood2001
10-30 1280
数据结构例题代码及其讲解-查找与排序
数据结构经典编程习题
03-23
学习数据结构课程的一些经典编程题目，以及答案
数据结构编程题目及答案
08-08
大学数据结构编程题目及答案 如下：1.写出在顺序存储结构下将线性表逆转的算法，要求使用最少的附加空间。 解：输入：长度为n的线性表数组A(1:n) 输出：逆转后的长度为n的线性表数组A(1:n)。 C语言描述如下（其中ET为数据元素的类型）......
数据结构题目整理（编程）
paintShadow的博客
09-15 9047
0-1求链式表的表长 本题要求实现一个函数，求链式表的表长。 函数接口定义： int Length( List L ); 其中List结构定义如下： typedef struct LNode *PtrToLNode; struct LNode { ElementType Data; PtrToLNode Next; }; typedef PtrToLNode List; L是给...
数据结构试题大题编程及参考答案_数据结构经典编程习题
01-02
学习数据结构课程的一些经典编程题目，以及答案
JAVA语言程序设计与数据结构课后 编程题解析
12-22
在“JAVA语言程序设计与数据结构课后 编程题解析”这个主题中，我们可以深入探讨Java编程语言和数据结构的基础知识，以及如何通过解决课后编程题来提高编程技能。Java是一种广泛使用的面向对象的编程语言，它以其...
大连东软数据结构编程题.doc
09-29
大连东软数据结构编程题.doc
java语言程序设计与数据结构(基础篇)原书第11版 编程题，偶数题目答案
03-01
在“编程题，偶数题目答案”部分，我们主要探讨的是书中编程练习的偶数编号问题的解答，这些题目旨在巩固和深化读者对Java编程及数据结构的理解。 数据结构是计算机科学中的核心概念，它涉及如何有效地存储和组织...
数据结构编程题（不断更新）
WangQYoho的博客
09-27 6706
记录一些数据结构的编程题好题： 1、计算二叉树深度 public class Solution { public int TreeDepth(TreeNode pRoot) { return pRoot == null ? 0 : Math.max(TreeDepth(pRoot.left), TreeDepth(pRoot.right)) + 1; } }递归
2024版王道《数据结构》编程题汇总_21年王道数据结构
2401_86950546的博客
09-04 1213
又如A=（0,5,5,3,5,1,5,7），则A中没有主元素。,bn)原地逆置为(bnbn-1, n2,",D1,m,m-1,am-2, a1),再对前n个元素和后m个元素分别使用逆置算法,即可得到(b,b2, b3,…算法思想:注意是有序顺序表,值相同的元素一定在连续的位置上,用类似于直接插入排序的思想,初始时将第一个元素视为非重复的有序表.之后依次判断后面的元素是否与前面非重复有序表的最后一个元素相同,若相同则继续向后判断,若不同则插入到前面的非重复有序表的最后,直至判断到表尾为止.
数据结构的编程题C语言,C语言数据结构编程题.docx
weixin_35919843的博客
05-18 306
void con vert(i nt *result, int n) {if(n>=10)con vert(result+1, n/10);*result = n %10;}int main (i nt argc, char* argv[]) {int n = 123456789, result[20]={};conv ert(result, n);prin tf("%d:", n);for...
数据结构编程题集锦（更新ing）
Marcus1231的博客
11-24 1316
数据结构编程题一、线性结构（一）线性表（二）栈与队列（三）广义表与多重链表二、数组与字符串三、树（一）二叉树（二） 一、线性结构 （一）线性表 （二）栈与队列 1.括号匹配 检查一段C语言代码的小括号( )、 中括号 [ ] 和大括号{ } 是否匹配。 2.双端队列（双向链表版）双端队列（顺序表版本） （三）广义表与多重链表 二、数组与字符串 三、树 （一）二叉树 （二） ...
数据结构编程序题（附赠一学年的资料）
qq_40016494的博客
07-01 1510
自己对着看吧
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值