顺序表以a1为界的划分，连接两个顺序表(王浩)

最新推荐文章于 2022-09-14 13:06:37 发布
原创 最新推荐文章于 2022-09-14 13:06:37 发布 · 2.1k 阅读 · 10 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了一种基于顺序表的数据结构操作算法，包括以首个元素为基准的划分及两个已排序顺序表的合并，后者生成一个新的按升序排列的顺序表。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

 1.将顺序表（a1,a2..an）重新排列以a1为界限，a1前面小于a1,a1后面小于a1

/*
将顺序表(a1,a2,…,an)重新排列以a1为界的两部分：a1前面的值均比a1小，
a1后面的值均比a1大（这里假设数据元素的类型具有可比性，不妨设为整型）。
这里我自己定义的数据结构的课程分数 
*/ 

#include "stdio.h"
#include "stdlib.h"
#include "string.h"

/***************************************/
/* 顺序表的头文件,文件名：数据结构.cpp */
/***************************************/

#define MAXSIZE 100
typedef int datatype;
typedef struct{
	datatype a[MAXSIZE];  //学号
	char *name[MAXSIZE];  // 姓名
	datatype score[MAXSIZE]; //数据结构成绩;
	int size;
}sequence_list;


//顺序表的初始化——置空表
void init(sequence_list *slt);
//在顺序表后部进行插入操作
void append(sequence_list *slt,datatype x,char *name,int score);
//打印顺序表各节点的值
void display(sequence_list slt);
//判断顺序表是否为空
int empty(sequence_list slt);
//查找顺序表中值为x的节点位置
int find(sequence_list slt,datatype x);
//取得顺序表当中第i个节点的值
datatype get(sequence_list slt,int i);
//在顺序表的 position 位置插入值为x的节点 
void insert(sequence_list *slt,datatype x,int position,char *name,int score);
//删除顺序表的 position 位置的节点
void dele(sequence_list *slt,int position);

//将a1作为界限进行划分
void compare(sequence_list *slt);

int main()
{
	sequence_list Stu;
	init(&Stu);
	append(&Stu,1707004711,"小明",73);
	append(&Stu,1707004712,"小华",56);
	append(&Stu,1707004713,"小花",82);
	append(&Stu,1707004714,"小草",78);
	append(&Stu,1707004715,"杨旭",74);
	append(&Stu,1707004716,"王浩",67);
	append(&Stu,1707004717,"丁逸群",95);
	append(&Stu,1707004718,"武智鹏",87);
	insert(&Stu,1707004710,3,"蜘蛛侠",34);
	//首先展示所添加的数据
	display(Stu);
	//以a1为分界线划分数据
	compare(&Stu);
	//再次展示顺序表的数据
	display(Stu);
	return 0;
}



/**************************************/
/* 函数功能：顺序表的初始化——置空表 */
/**************************************/
void init(sequence_list *slt)
{
	slt->size = 0;
}

/**************************************/
/* 函数功能：在顺序表后部进行插入操作 */
/**************************************/

void append(sequence_list *slt,datatype x,char *name,int score)
{
	if(slt->size == MAXSIZE)
	{
		printf("顺序表是满的");
	}
	slt->a[slt->size] = x;
	slt->score[slt->size] = score;
	slt->name[slt->size] = name;
	slt->size = slt->size + 1;
}

/**************************************/
/* 函数功能：打印顺序表各节点的值     */
/**************************************/
void display(sequence_list slt)
{
	int i;
	if(!slt.size)
		printf("\n顺序表是空的！");
	else
		printf("\t学号\t\t姓名\t数据结构成绩\n");
		for(i = 0;i < slt.size;i ++)
			printf("%15d\t\t%s\t%7d\n",slt.a[i],slt.name[i],slt.score[i]);
	printf("\n");
}



/**************************************/
/* 函数功能：判断顺序表是否为空       */
/**************************************/
int empty(sequence_list slt)
{
	return(slt.size == 0 ? 1 : 0);
}

/******************************************/
/* 函数功能：查找顺序表中值为x的节点位置  */
/******************************************/
int find(sequence_list slt,datatype x)
{
	int i = 0;
	while(i < slt.size && slt.a[i] != x)
		i ++;
	return(i < slt.size ? i : -1);
}

/******************************************/
/* 函数功能：取得顺序表当中第i个节点的学号  */
/******************************************/
datatype get(sequence_list slt,int i)
{
	if(i < 0 || i >= slt.size)
	{
		printf("\n指定位置的节点不存在！");
		exit(1);
	}
	else
		return slt.a[i];
}

/******************************************************/
/* 函数功能：在顺序表的 position 位置插入值为x的节点  */
/******************************************************/
void insert(sequence_list *slt,datatype x,int position,char *name,int score)
{
	int i;
	if(slt->size == MAXSIZE)
	{
		printf("\n顺序表是满的!没法插入!");
		exit(1);
	}
	if(position < 0 || position > slt->size)
	{
		printf("\n指定的插入位置不存在!");
		exit(1);
	}
	for(i = slt->size;i > position;i --)
	{
		slt->a[i] = slt->a[i - 1];
		slt->name[i] = slt->name[i - 1];
		slt->score[i] = slt->score[i - 1];
	}
	slt->a[position] = x;
	slt->name[position] = name;
	slt->score[position] = score;
	slt->size ++;
}

/***********************************************/
/* 函数功能：删除顺序表的 position 位置的节点  */
/***********************************************/

void dele(sequence_list *slt,int position)
{
	int i;
	if(slt->size == 0)
	{
		printf("顺序表是空的!");
		exit(1);
	}
	if(position < 0 || position >= slt->size)
	{
		printf("\n指定的删除位置不存在");
		exit(1);
	}
	for(i = position;i < slt->size - 1;i ++)
	{
		slt->a[i] = slt->a[i + 1];
		slt->name[i] = slt->name[i + 1];
		slt->score[i] = slt->score[i + 1];
	}
	slt->size --;
}

/***********************************************/
/* 函数功能：将顺序表重新排列,a1位置为界
分为两部分，position前面的值均比slt->a[position]的数值小
position后面的值均比slt->a[position]的数值大  */
/***********************************************/
void compare(sequence_list *slt)
{
	if(!slt->size)
		printf("\n顺序表是空的！\n");
	else
	{
		//首先保存第一个学生的成绩
		int score = slt->score[0];
		for(int i = 1;i < slt->size;i ++)
		{
			if(slt->score[i] < score)
			{
				//如果遍历学生的成绩大于排头，将该数据插入到第一位
				insert(slt,slt->a[i],0,slt->name[i],slt->score[i]);
				//删除刚刚移动的那个原数据
				dele(slt,i + 1);
			}
		}
	}
}

2.有顺序表A和B，其元素均按从小到大的升序排列，编写一个算法，将它们合并成一个顺序表C，要求C的元素也按从小到大的升序排列。

/*
有顺序表A和B，其元素均按从小到大的升序排列，编写一个算法，将它们合并成一个顺序表C，
要求C的元素也按从小到大的升序排列。
*/ 






#include "stdio.h"
#include "stdlib.h"
#include "string.h"

/***************************************/
/* 顺序表的头文件,文件名：数据结构.cpp */
/***************************************/

#define MAXSIZE 100
typedef int datatype;
typedef struct{
	datatype a[MAXSIZE];  //学号
	char *name[MAXSIZE];  // 姓名
	datatype score[MAXSIZE]; //数据结构成绩;
	int size;
}sequence_list;


//顺序表的初始化——置空表
void init(sequence_list *slt);
//在顺序表后部进行插入操作
void append(sequence_list *slt,datatype x,char *name,int score);
//打印顺序表各节点的值
void display(sequence_list slt);
//判断顺序表是否为空
int empty(sequence_list slt);
//查找顺序表中值为x的节点位置
int find(sequence_list slt,datatype x);
//取得顺序表当中第i个节点的值
datatype get(sequence_list slt,int i);
//在顺序表的 position 位置插入值为x的节点 
void insert(sequence_list *slt,datatype x,int position,char *name,int score);
//删除顺序表的 position 位置的节点
void dele(sequence_list *slt,int position);
//顺序表成绩排序
void sort(sequence_list *slt);
//交换节点
void exchange(sequence_list *slt,int position1,int position2);
//交换int类型的数据
void exchange_num(datatype *x,int *y);
//交换字符串的数据
void exchange_string(char a[],char b[]);
//顺序表的合成
void sort_insert(sequence_list *slt1,sequence_list *slt2,sequence_list *slt3);
void sort_insert2(sequence_list *slt1,sequence_list *slt2);

int main()
{
	sequence_list Stu1,Stu2,Stu3;
	init(&Stu1);
	init(&Stu2);
	init(&Stu3);
	append(&Stu1,1707004711,"小明",56);
	append(&Stu1,1707004712,"小华",62);
	append(&Stu1,1707004713,"小花",73);
	append(&Stu1,1707004714,"钢铁侠",78);
	append(&Stu2,1707004715,"王也",43);
	append(&Stu2,1707004716,"小浩",56);
	append(&Stu2,1707004717,"小逸群",65);
	append(&Stu2,1707004718,"小智鹏",72);
	append(&Stu2,1707004719,"蜘蛛侠",83);
	printf("原始的数据：\n");
	printf("数据表1：\n");
	display(Stu1);
	printf("数据表2：\n");
	display(Stu2);
	printf("\n-------------------------------------\n");
	printf("\n利用slt1跟slt2加到slt3当中的方法:\n\n");
	sort_insert(&Stu1,&Stu2,&Stu3);
	display(Stu3);
	printf("\n利用slt1插入到slt2的方法:\n\n");
	sort_insert2(&Stu1,&Stu2);
	display(Stu2);
	return 0;
}



/**************************************/
/* 函数功能：顺序表的初始化——置空表 */
/**************************************/
void init(sequence_list *slt)
{
	slt->size = 0;
}

/**************************************/
/* 函数功能：在顺序表后部进行插入操作 */
/**************************************/

void append(sequence_list *slt,datatype x,char *name,int score)
{
	if(slt->size == MAXSIZE)
	{
		printf("顺序表是满的");
	}
	slt->a[slt->size] = x;
	slt->score[slt->size] = score;
	slt->name[slt->size] = name;
	slt->size = slt->size + 1;
}

/**************************************/
/* 函数功能：打印顺序表各节点的值     */
/**************************************/
void display(sequence_list slt)
{
	int i;
	if(!slt.size)
		printf("\n顺序表是空的！");
	else
		printf("\t学号\t\t姓名\t数据结构成绩\n");
		for(i = 0;i < slt.size;i ++)
			printf("%15d\t\t%s\t%7d\n",slt.a[i],slt.name[i],slt.score[i]);
	printf("\n");
}



/**************************************/
/* 函数功能：判断顺序表是否为空       */
/**************************************/
int empty(sequence_list slt)
{
	return(slt.size == 0 ? 1 : 0);
}

/******************************************/
/* 函数功能：查找顺序表中值为x的节点位置  */
/******************************************/
int find(sequence_list slt,datatype x)
{
	int i = 0;
	while(i < slt.size && slt.a[i] != x)
		i ++;
	return(i < slt.size ? i : -1);
}

/******************************************/
/* 函数功能：取得顺序表当中第i个节点的学号  */
/******************************************/
datatype get(sequence_list slt,int i)
{
	if(i < 0 || i >= slt.size)
	{
		printf("\n指定位置的节点不存在！");
		exit(1);
	}
	else
		return slt.a[i];
}

/******************************************************/
/* 函数功能：在顺序表的 position 位置插入值为x的节点  */
/******************************************************/
void insert(sequence_list *slt,datatype x,int position,char *name,int score)
{
	int i;
	if(slt->size == MAXSIZE)
	{
		printf("\n顺序表是满的!没法插入!");
		exit(1);
	}
	if(position < 0 || position > slt->size)
	{
		printf("\n指定的插入位置不存在!");
		exit(1);
	}
	for(i = slt->size;i > position;i --)
	{
		slt->a[i] = slt->a[i - 1];
		slt->name[i] = slt->name[i - 1];
		slt->score[i] = slt->score[i - 1];
	}
	slt->a[position] = x;
	slt->name[position] = name;
	slt->score[position] = score;
	slt->size ++;
}

/***********************************************/
/* 函数功能：删除顺序表的 position 位置的节点  */
/***********************************************/

void dele(sequence_list *slt,int position)
{
	int i;
	if(slt->size == 0)
	{
		printf("顺序表是空的!");
		exit(1);
	}
	if(position < 0 || position >= slt->size)
	{
		printf("\n指定的删除位置不存在");
		exit(1);
	}
	for(i = position;i < slt->size - 1;i ++)
	{
		slt->a[i] = slt->a[i + 1];
		slt->name[i] = slt->name[i + 1];
		slt->score[i] = slt->score[i + 1];
	}
	slt->size --;
}

/********************************************************/
/* 函数功能：将顺序表slt1跟顺序表slt2顺序连接到stl3当中*/        
/******************************************************/
void sort_insert(sequence_list *slt1,sequence_list *slt2,sequence_list *slt3)
{
	int i = 0,j = 0; //i用于扫描顺序表slt1,j用于扫描顺序表slt2
	if(slt1->size == 0 || slt2->size == 0)
		printf("有空的顺序表!\n");
	while(i < slt1->size && j < slt2->size)
	{
		if(slt1->score[i] < slt2->score[j])
		{
			//在slt3的后面添加slt1的数据
			append(slt3,slt1->a[i],slt1->name[i],slt1->score[i]);
			//
			i ++;
		}
		else
		{
			//在slt3的后面添加slt2的数据
			append(slt3,slt2->a[j],slt2->name[j],slt2->score[j]);
			j ++;
		}
	}

	while(i < slt1->size)//若slt1未扫描完，则将slt1剩余的元素加到slt3中
	{
		append(slt3,slt1->a[i],slt1->name[i],slt1->score[i]);
		i ++;
	}

	while(j < slt2->size)//若slt2未扫描完，则将slt2剩余的元素加到slt3中
	{
		append(slt3,slt2->a[j],slt2->name[j],slt2->score[j]);
		j ++;
	}
}

/********************************************************/
/* 函数功能：将顺序表slt1跟顺序表顺序的插到slt2当中*****/        
/******************************************************/
void sort_insert2(sequence_list *slt1,sequence_list *slt2)
{
	int i = 0,j = 0;
	while(i < slt1->size)
	{
		//如果顺序表slt1的数据比slt2最大的都大，直接将slt1的数据加到slt2后面 
		if(slt1->score[i] > slt2->score[slt2->size - 1])
		{
			append(slt2,slt1->a[i],slt1->name[i],slt1->score[i]);
			i ++;
		}else if(slt1->score[i] < slt2->score[j])  //如果序表slt1的数据比slt2位置j上的的要小 
		{
			// 将slt1的数据插入到slt2的 j 的位置 
			insert(slt2,slt1->a[i],j,slt1->name[i],slt1->score[i]); 
			//两个顺序表都向后扫描 
			i ++;
			j ++;
		}else
			//向后扫描slt2 
			j ++;
	}
}

 

qq_42095415
关注
数据结构之顺序表
NUC__xjx的博客
09-26 1219
写出相应的子函数解决问题 问题一： 1.将顺序表(a1,a2,…,an)重新排列以a1为界的两部分：a1前面的值均比a1小，a1后面的值均比a1大（这里假设数据元素的类型具有可比性，不妨设为整型）。 先说一下自己的想法 看到题目的第一想法就是直接把顺序表从小到大排列一下，然后最先想到的就是用冒泡排序直接排序。但是其实题目并没有要求我们要全部排列，实际上是让我们分类。这样的话，我们就可以直接把a1存...
顺序表练习
nuanxin_520的专栏
02-21 1925
昨天的还没总结，不复制粘贴了，把要改的步骤放在这 例1 将顺序表(a1，a2，... ，an) 重新排列为以a1 为界的两部分：a1 前面的值均比a1 小，a1 后面的值都比a1 大(这里假设数据元素的类型具有可比性, 不妨设为整型)，操作前后如图2.5所示。这一操作称为划分。a1 也称为基准。 基本思路：比基准小的移动到最前面，大的不动。 算法实现时，不需要写一个删除函数，一个
将顺序表重新排列成以第一个元素为界的两部分，前一部分元素的值都小于它，后一部分元素的值都大于或等于它。
12-31
设计并实现算法，将顺序表重新排列成以第一个元素为界的两部分，前一部分元素的值都小于它，后一部分元素的值都大于或等于它。估算所设计算法的时间复杂度和空间复杂度。
数据结构 顺序表 将顺序表以a1为界重新排列 前面比a1小，后面比a大
朝歌
09-14 4556
    题目：          将顺序表(a1,a2,…,an)重新排列以a1为界的两部分：a1前面的值均比a1小，a1后面的值均比a1大（这里假设数据元素的类型具有可比性，不妨设为整型） 代码： #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define MAXSIZE 100 typedef int datatype; typ...
顺序表的划分
weixin_30950887的博客
08-11 292
void Swap(int& x,int& y){int temp = x;x = y;y = temp;}void quicksort(int array[], int left, int right) {//快速排序的函数(以中间的数为标准) int i, j, s; if(left < right) { s = array[(left+righ...
2020王道课后习题P18，综合应用题7：将两个有序的顺序表合并为一个新的有序的顺序表。
weixin_42426690的博客
06-27 2204
2020王道课后习题P18，综合应用题7：将两个有序的顺序表合并为一个新的有序的顺序表。算是一个经典算法了，我辈这种就没法改写了，就是直接套下来的，毕竟是抱着各位大佬的大腿，那就看代码，还是VS2013中实现的： // ConsoleApplication2.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include<stdio.h>...
【数据结构入门】顺序表（SeqList）详解（初始化、增、删、查、改）
热门推荐
codewinter的博客
08-18 8万+
文章目录（1）线性表（2）顺序表1）什么是顺序表2）顺序表的定义2）顺序表的接口实现1、初始化顺序表2、销毁（释放）顺序表3、检查顺序表容量是否满了，好进行增容3、顺序表尾插4、顺序表尾删5、顺序表头插6、顺序表头删7、打印顺序表8、在顺序表中查找指定值9、在顺序表指定下标位置插入数据10、在顺序表中删除指定下标位置的数据11、查看顺序表中有效数据个数12、修改指定下标位置的数据 （1）线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结
将两个升序的顺序表A和B合并为一个升序表C
qq_43717119的博客
06-13 2304
将两个升序的顺序表A和B合并为一个升序表C 有顺序表A和B，其表中的元素均按照由小到大排序，将A和B两个升序的顺序表A和B合并为一个升序表C ，C中的元素也按照由大到小排序 #include<stdio.h> #include<stdlib.h> #define MAXSIZE 1024 typedef struct { int data[MAXSIZE];//存储顺序表中的元素 int len;//顺序表长度 }SeqList;//顺序表类型 SeqList *Init_S
实现两个顺序表的合并（顺序表已递增）
kjrhk的博客
04-03 3169
实现两个顺序表的合并（顺序表已递增） 在学校自己做的实验报告，仅供参考，可能有误。 现在忘了··等考研复习时补充吧 （1）建立结构体 typedef struct { int* elem; int length; int listsize; }sqlist; （2）初始化化线性表 void Initlist(sqlist& L) { L.elem = (int*)malloc(L...
C语言 线性表的顺序存储结构（顺序表实现）以及删除顺序表中值为e的全部元素
qq_43519310的博客
12-27 4239
#include&amp;amp;quot;bits/stdc++.h&amp;amp;quot;; #define max 100 #define zengliang 20 /** 顺序表 */ typedef struct orderList{ int a; int length; int capacity; }List; void initiaList(List &amp;amp;amp;amp;list){ list.a=(int)malloc(sizeof(i...
Java栈的代码实现
weixin_46379561的博客
06-09 409
什么是栈 栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。（摘自百度百科） 栈： 先进后出，只在栈顶进行操作 栈的基本操作 push()：将数据压入栈中 pop()：将栈顶元素弹出 peek()：不弹出获取栈顶元素 isEmpty(
a1
qq_41704154的博客
02-02 226
1
数据结构（c语言版）（2.2.1顺序表的其他操作）
cornerlin的博客
04-13 1606
【例2.1】 将顺序表（a1, a2, …, an）重新排列为以a1为界的两部分：a1前面的值均比a1小、a1后面的值均比a1大（这里假设数据元素的类型具有可比性，不妨设为整型），操作前后如图所示。这一操作称为划分，a1称为基准。 划分的方法有多种，下面介绍的划分算法思路简单，但性能较差。 基本思路：从第二个元素开始到最后一个元素，逐一向后扫描。 （1）当前数据元素ai比a1大时，表明它已经在a1...
顺序表的练习
学习笔记
04-24 818
#include #include #define ERROR 0 #define OVERFLOW -2 //在这里申明的时候不用加上;号 #define OK 1 #define LISTINCREMENT 10 //线性表存储空间的分配增量 #define LIST_INIT_SIZE 100 //线性表的存储空间的初始分配量 typedef int Ele
数据结构两个课后题，以顺序表储存
qq_42095415的博客
09-17 910
1.将顺序表（a1,a2,..an）重新排列以a1为界的两部分，a1前面的值均比a1小，a1后面的值均比a1大。 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define MAXSIZE 100 typedef struct//定义结构体 { int a[MAXSIZE]; int size; }sequence; void in...
2.2.3 顺序表应用举例
qq_59183443的博客
09-14 606
由于只需要分成两部分，不需要整体排序，所以一次快排就可以了。双指针，左指针遇到比a1大的值停止，右指针遇到比a1小的停止，如果左指针比右指针小就交换，时间复杂度O(n)。
2.6
南京师范大学中北学院
02-17 598
2.6 试编写算法，将元素为整数的顺序表(a1,a2,…,an)重新排列为以a1为界的两部分：a1前面的值均比a1小，a1后面的值都比a1大，要求算法的时间复杂度为O(n)。 #include<iostream> #define MaxSize 100 using namespace std; struct SqList { int a[MaxSize]; int len; }; void ReOrder(SqList *L){ int j=L->len;//记录存
SWUST OJ1102顺序表数据划分问题
weixin_45733897的博客
04-09 1121
题目描述 建立一个顺序表L，然后以第一个为分界，将所有小于等于它的元素移到该元素的前面，将所有大于它的元素移到该元素的后面。 输入 顺序表长度n； 顺序表中的数据元素。 输出 移动后的数据元素。 样例输入 10 32 5 22 43 23 56 54 57 11 25 样例输出 25 11 23 22 5 32 43 56 54 57 #include<stdio.h>//oj 110...
顺序表的应用举例
逐波与逆流
11-18 4170
例2．1 将顺序表(a1，a2，... ，an) 重新排列为以a1 为界的两部分：a1 前面的值均比a1 小，a1 后面的值都比a1 大(这里假设数据元素的类型具有可比性, 不妨设为整型)，操作前后如图2.5所示。这一操作称为划分。a1 也称为基准。 划分的方法有多种，下面介绍的划分算法其思路简单，性能较差。基本思路： 从第二个元素开始到最后一个元素，逐一向后扫描： （1）当前数
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值