DS数据结构_线性表_（1）基本操作

最新推荐文章于 2023-04-20 20:03:40 发布
最新推荐文章于 2023-04-20 20:03:40 发布
阅读量201 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/robotskly/article/details/107428288
版权 
#include <iostream>
#include<stdio.h>
#include <cstdlib>
#define MaxSize 50
#define InitSize 40
#define ElemType int
#define INPUT 1
#define DEFAULT 2
#define NULLLIST 0

/* run this program using the console pauser or add your own getch, system("pause") or input loop */
using namespace std;

//定义结构类型
//固定长度线性表
typedef struct {
	ElemType data[MaxSize];
	int lentgh;//从1开始
}SqListSta;
//可变长度线性表
typedef struct {
	ElemType *data;
	int length;//从1开始
}SqList;


/**
	接下来的基本操作全部使用可变长度线性表实现
**/

//初始化函数
bool initSqList(SqList &L , int initType);

//线性表中插入
bool ListInsert(SqList &L,int loc ,ElemType e);

//线性表删除
bool ListDelete(SqList &L,int loc ,ElemType &e);

//线性表查找
int LocateElem(SqList &L,ElemType e);

//输出线性表
bool ShowList(SqList L);

//question1 :从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删除的元素，空出的位置由最后一个元素填补
bool question1(SqList &L,ElemType &e);

//question2 :设计一个高效算法，将顺序表L的所有元素逆置，空间复杂度要求为O(1)
bool question2(SqList &L);

//question3 ：时间复杂度O(n)，空间复杂度O(1)，删除鄋值为x的元素
bool question3_1(SqList &L,ElemType e);
bool question3_2(SqList &L,ElemType e);

//question5 ：从顺序表中删除值在 s，t之间的所有元素,要求检查s，t正确性
bool question5(SqList &L,ElemType s,ElemType t);

//question6 : 删除所有重复元素
bool question6(SqList &L);

//question7 :两个有序表合并新的有序表
bool question7(SqList &L1 ,SqList &L2,SqList &L3);

//question8 :将顺序表中前后两部分互换
bool reverse(SqList &L,int left , int right);
bool question8(SqList &L, int left , int mid , int right);

//question9 :有序线性表重尽快的查找x位置,找到则与后面元素位置互换。
bool question9(SqList L , ElemType x , int left , int right);
 
//question10:  将线性表中的s到t位置的元素循环左移p个位置，尽可能高效
bool question10(SqList &L, int s ,int t ,int p);

/*question11:升序列表S长度为L，在L/2向上取整位置为中位数，两个序列的中位数是所有元素升序的中位数
	两个等长升序序列，高效算法找出两个序列的中位数
*/
bool question11(SqList &L1, SqList &L2, ElemType &e);

/*question12:序列中有大于L/2个元素等于x，则x为该序列主元素
	高效找出主元素。
*/
bool question12(SqList &L , ElemType &mainElem);


/*
	主函数
*/
int main(int argc, char** argv) {
	int selection;
	SqList L;
	initSqList(L,DEFAULT);


	while(true){
		cout<<"\n---------请输入功能---------\n"<<endl ;
		cout<<"0.退出\t"<<"1.查看线性表\t"<<"2.插入\t"<<"3.删除\t"<<"4.查找"<<endl;
		cout<<"5. question1 :从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删除的元素，空出的位置由最后一个元素填补\n";
		cout<<"6. question2 :设计一个高效算法，将顺序表L的所有元素逆置，空间复杂度要求为O(1)\n";
		cout<<"7. question3 ：时间复杂度O(n)，空间复杂度O(1)，删除鄋值为x的元素\n";
		cout<<"8. question5 ：从顺序表中删除值在 s，t之间的所有元素,要求检查s，t正确性\n"; 
		cout<<"9. question6 : 删除所有重复元素\n";
		cout<<"10. question7 :两个有序表合并新的有序表\n";
		cout<<"11. question8 :将顺序表中前后两部分互换\n";
		cout<<"12. question10:  将线性表中的s到t位置的元素循环左移p个位置，尽可能高效\n";
		cout<<"13. question11:升序列表S长度为L，在L/2向上取整位置为中位数，两个序列的中位数是所有元素升序的中位数两个等长升序序列，高效算法找出两个序列的中位数\n";
        cout<<"14. question12:序列中有大于L/2个元素等于x，则x为该序列主元素 高效找出主元素。\n\n";

		cin>>selection;

		switch(selection){
			case 0:{
				exit(1);
				break;
			}
			// 1.查看线性表
			case 1:{
				ShowList(L);
				break;
			}
			// 2.插入
			case 2:{
				cout<<"\n-------输入位置和插入值-------\n";
				int loc;
				ElemType elem;
				cin>>loc>>elem;
				if(!ListInsert(L,loc,elem))
					cout<<"  ERROR！";
				ShowList(L);
				break;
			}
			// 3.删除
			case 3:{
				cout<<"\n--------输入删除位置--------\n" ;
				int loc;
				int e;
				cin>>loc;
				if(!ListDelete(L,loc,e))
					cout<<"ERROR!";
				ShowList(L);
				break;
			}
			// 4.查找
			case 4:{
				cout<<"\n--------输入查找的值--------\n" ;
				int e;
				cin>>e;
				int loc = LocateElem(L,e);
				if(loc == -1)
					cout<<"ERROR!";
				else
					cout<<loc;
				ShowList(L);
				break;
			}
			//question1 :从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删除的元素，空出的位置由最后一个元素填补
			case 5:{
				ElemType e;
                question1(L,e);
                cout<<"删除最小元素为："<<e ;
				break;
			}
			//question2 :设计一个高效算法，将顺序表L的所有元素逆置，空间复杂度要求为O(1)\n
			case 6:{
				question2(L);
				break;
			}
			//question3 ：时间复杂度O(n)，空间复杂度O(1)，删除鄋值为x的元素\n
			case 7:{
				ElemType e;
				cout<<"输入要删除的元素\n";
				cin>>e; 
				question3_1(L,e);
				break;
			}
			//question5 ：从顺序表中删除值在 s，t之间的所有元素,要求检查s，t正确性\n
			case 8:{
				int s , t;
				cout<<"输入范围s,t\n";
				cin>>s>>t; 
				question5(L,s,t);
				break;
			}
			//question6 : 删除所有重复元素\n
			case 9:{
			
				question6(L);
				break;
			}
			//question7 :两个有序表合并新的有序表\n
			case 10:{
				//****??????
				SqList L1;
				SqList L2;
				SqList L3;
				initSqList(L3,NULLLIST);
				cout<<"输入第一个顺序表：\n";
				initSqList(L1,INPUT);
				cout<<"输入第二个顺序表：\n";
				initSqList(L2,INPUT); 
				ShowList(L1);
				ShowList(L2);
				question7(L1,L2,L3);
				ShowList(L3); 
				break;
			}
			// question8 :将顺序表中前后两部分互换\n
			case 11:{
				int left,right,mid; 
				cout<<"输入互换部分首位置\n";
				cin>>left;
				cout<<"输入互换位置中间位置\n";
				cin>>mid;
				cout<<"输入互换位置尾位置\n";
				cin>>right; 
				question8(L,left ,mid ,right);
				break;
			}
			//question10:  将线性表中的s到t位置的元素循环左移p个位置，尽可能高效\n
			case 12:{
				int left,right,p; 
				cout<<"输入互换部分首位置\n";
				cin>>left;
				cout<<"输入互换位置中间位置\n";
				cin>>p;
				cout<<"输入互换位置尾位置\n";
				cin>>right; 
				question10(L,left,right,p); 
				break;
			}
			// question11:升序列表S长度为L，在L/2向上取整位置为中位数，两个序列的中位数是所有元素升序的中位数两个等长升序序列，高效算法找出两个序列的中位数\n
			case 13:{
				SqList L1;
				SqList L2;
				ElemType e;
				cout<<"输入升序列表1：\n";
				initSqList(L1,INPUT);
				cout<<"输入升序列表2：\n";
				initSqList(L2,INPUT);
				question11(L1,L2,e);
				cout<<"中位数为："<<e <<endl;
				break;
			}
			//question12:序列中有大于L/2个元素等于x，则x为该序列主元素 高效找出主元素。
			case 14:{
				
				break;
			}
			//
			case 15:{

				break;
			}
			//
			case 16:{

				break;
			}
		}
	}



	return 0;
}
/**

**/



//初始化动态线性表空间
/**
	initType : 新建线性表的方式 
**/ 
bool initSqList(SqList &L,int initType){
	
	//控制台输入线性表内容 
	if(initType == 1){
		L.data = new ElemType[MaxSize];
		cout<<"\n新建顺序表，请输入长度，内容，空格隔开\n";
		int len;
		cin>>len; 
		L.length = len;
		for(int i=0;i<len;i++){
			cin>>L.data[i];
		}
		ShowList(L);
	}else if(initType == 2){
		//使用默认创建线性表 
		L.data = new ElemType[InitSize];
		L.length = 10;
		for(int i=0;i<10;i++){
  	    L.data[i] = i+1;
		}
		ShowList(L);
	} else if(initType == 0){
		L.data = new ElemType[MaxSize];
		L.length =0;
	
	}
	
	cout<<"---------新建完成---------\n"; 

}

//显示线性表全部内容
bool ShowList(SqList L){
	cout<<"\n----------showList----------"<<endl;
	for(int i=0;i< L.length;i++){
		cout<<L.data[i]<<" ";
	}
	cout<<"length: "<<L.length<<endl; 

}

//线性表中插入
/**
	loc :表中位置为 1 <= i <= length+1
	e : 插入的数据 
**/
bool ListInsert(SqList &L,int loc,ElemType e){
	//如果长度小于0或者大于最大长度则报错
	if(loc>L.length+1 || loc<1){
		return false;
	}else{
		// 从后往前扫描
		// 初始位置为 length 而不是length-1 ，为给新插入数据的空间，所有元素后移一位 
		for(int j=L.length ; j>=loc ; j--){
			L.data[j] = L.data[j-1];
		}
		L.data[loc-1] = e;
		L.length+=1; //长度+1
	}
	return true;
}


//线性表删除  将删除的数据通过e返回
//根据位置进行删除
/**
	loc : 删除值的位置
	e : 返回删除的值 
**/ 
bool ListDelete(SqList &L,int loc ,ElemType &e){
	 if(loc< 1 || loc > L.length+1){
	 	return false;
	 }else{
	 	// 保存该位置的值 
	 	e = L.data[loc-1];
		//所有元素前移 
		for(int j=loc-1 ; j<L.length ; j++){
			L.data[j] = L.data[j+1];
		}
		L.length-=1;//长度减一
	 }
	return true;
}


//线性表按值查找
int LocateElem(SqList &L,ElemType e){
	for(int i=0 ; i<L.length ; i++) {
		if(L.data[i] == e){
			return i+1; //返回该值的位置 ，下表+1
		}
	}

	return -1;//未找到元素，返回-1
}


//交换两元素位置
//下表为参数
/**
	loc1 : 第一个元素位置
	loc2 : 第二个元素位置 
**/ 
bool swap(SqList &L,int loc1,int loc2){
	if(loc1<0||loc2>L.length){
		return false;
	}
	ElemType e;
	e = L.data[loc1];
	L.data[loc1] = L.data[loc2];
	L.data[loc2] = e;
	return true;
}

//question1 :从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删除的元素，空出的位置由最后一个元素填补
bool question1(SqList &L,ElemType &e){
	int min = 999999;//放置线性表为空
	int flag = -1; //定位查找到的元素的位置 
	// 查找最小值的位置 
	for(int i=0;i<L.length;i++){
		if(min >= L.data[i]){
			min =  L.data[i];
			flag = i ;
		}
	}
	//根据flag确定是否找到最小值，（表是否为空） 
	if(flag!=-1){
		e = min;
		L.data[flag] = L.data[L.length-1];
		L.length-=1;
	}else{
		return false;
	}
	return true;

}

//question2 :设计一个高效算法，将顺序表L的所有元素逆置，空间复杂度要求为O(1)
bool question2(SqList &L){
	 
	for(int i=0;i<L.length/2;i++){
		swap(L,i,L.length-i-1);
	}
	return true;
}

//question3 ：时间复杂度O(n)，空间复杂度O(1)，删除所有值为x的元素
bool question3_1(SqList &L,ElemType e){
	//算法思路
	//计数记住该序列中有k个不为x的数字，将每一个不为x的数组放到序列的k个位置 
	int k =0;
	for(int i=0;i<L.length;i++){
		if(L.data[i] != e){
			L.data[k] = L.data[i];
			k++;
		}
	}
	L.length = k;
	return true;
}

bool question3_2(SqList &L,ElemType e){
	//算法思路
	//计数有k个为x的数字，遇到不为x的数字吧该数字放到length-k 位置上
	int k=0;
	for(int i=0;i<L.length;i++){
		if(L.data[i] == e){
			k ++;
		}
		else{
			//!!!!!易错 
			L.data[i-k] = L.data[i];
		}
	} 
	L.length = L.length -k;
	return true;
} 

//question5 ：从顺序表中删除值在 s，t之间的所有元素,要求检查s，t正确性
bool question5(SqList &L,ElemType s ,ElemType t){
	if(s > t){
		return false;
	} 
	int num = 0;//记录不是 s , t 范围之间只数字个数 
	
	for(int i=0 ; i < L.length;i++){
		//不是范围之内的全部放到对应位置上
		//范围之内的直接略过，不进行存储。 
		if(L.data[i] > t || L.data[i] < s){
			L.data[num] = L.data[i];
			num++;
		}
		
	}
}

//question6 : 删除所有重复元素
bool question6(SqList &L){
	ElemType e;
	for( int i=0 ; i<L.length ; i++){
		for(int j=i +1 ; j<L.length ; j++){
			if(L.data[i] == L.data[j]){
				ListDelete(L,i+1,e);
			}
		}
	} 
	
}

//question7 :两个有序表合并新的有序表
//这里新建一个顺序表用于存储新的有序表 
bool question7(SqList &L1 , SqList &L2,SqList &L3){
	int f1 = 0;
	int f2 = 0;
	int f3 = 0;
	while(f1<L1.length && f2 < L2.length){
		if(L1.data[f1]<L2.data[f2]){
			L3.data[f3++] = L1.data[f1++];
			L3.length++;
		//	f3++;
		//	f1++;
		}else if(L1.data[f1] > L2.data[f2]){
			L3.data[f3++] = L2.data[f2++];
			L3.length++;
		//	f3++;
		//	f2++;
		} else{
			L3.data[f3++] = L1.data[f1++];
			L3.length++;
		//	f3++;
		//	f1++;
			L3.data[f3++] = L2.data[f2++];
			L3.length++;
		//	f3++;
		//	f2++;
		} 
	}
	if(f1 == L1.length){
		for(int j = f2; j<L2.length ; j++){
			L3.data[f3++] = L2.data[j];
			L3.length++;
			
		}
	}else{
		for( int j = f1; j<L1.length ;j++){
			L3.data[f3++]  = L1.data[j];
			L3.length++;
		}
	}
	return true;
}

//question8 :将顺序表中前后两部分互换
//转置两段全部，转置前段， 转置后段 
bool reverse(SqList &L,int left , int right){
	for(int i=left - 1 ; i< (left+right)/2 ;i++){
		swap(L, i , right - 1);
	}
	return true;
} 
bool question8(SqList &L, int left , int mid , int right){
	reverse(L, left , right);
	reverse(L, left , mid);
	reverse(L, mid, right);
}

//question9 ：有序线性表重尽快的查找x位置,找到则与后面元素位置互换。
/**
	二分查找 
	left 为要查找段的左位置
	right 为右位置 
	
**/
bool question9(SqList L , ElemType x , int left , int right){
	
	int mid = (left + right) / 2 ;
	if(L.data[mid] == x){
		swap(L,mid,mid+1);
		return true; 
	}else if(L.data[mid] > x){
		question9(L , x , left , mid);
	}else if(L.data[mid] < x){
		question9(L , x ,mid ,right);
	}
}

//question10:  将线性表中的s到t位置的元素循环左移p个位置，尽可能高效
bool question10(SqList &L, int s ,int t ,int p){
	reverse(L,s , t);
	reverse(L, s , s+p);
	reverse(L, s+p , t);
}

/*question11:升序列表S长度为L，在L/2向上取整位置为中位数，两个序列的中位数是所有元素升序的中位数
	两个等长升序序列，高效算法找出两个序列的中位数
*/
bool question11(SqList &L1, SqList &L2, ElemType &e){
	/**
		A,B的中位数为a，b
		a = b 即a或者b为中位数
		a < b 舍弃A中较小的一版，同时舍弃B中较大的一半
		a > b 舍弃A中较大的一半，同时舍弃B中较小的一半
		重复此过程，直到只剩一个元素 
	**/
	int n = L1.length;
	int s1 = 0;
	int d1 = n - 1;
	int m1;
	int s2 = 0;
	int d2 = n-1;
	int m2;
	//分别表示序列A和序列B的首位数, 末尾数，中位数
	while(s1 != d1 || s2 != d2){
		m1 = ( s1 + d1 ) /2;
		m2 = ( s2 + d2 ) /2;
		if( L1.data[m1]  == L2.data[m2]){
			return L1.data[m1];
		} 
		if(L1.data[m1] < L2.data[m2]){
			if( ( s1 + d1) % 2  == 0 ){
				s1 = m1;
				d2 = m2;
			}
			else{
				s1 = m1 + 1;
				d2 = m2;
			}
		}
		else{
			if((s2 + d2)%2 == 0){
				d1 = m1;
				s2 = m2;
			}else{
				d1 = m1;
				s2 = m2+1;
			}
		}
	} 
	e = L1.data[s1] < L2.data[s2] ? L1.data[s1] : L2.data[s2];
}

/*question12:序列中有大于L/2个元素等于x，则x为该序列主元素
	高效找出主元素。
*/
bool question12(){
	
}

 

WendyPaulse
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
查看ds中的数据
天宇云韵的专栏
01-27 944
之前自己想查看ds中的数据，但是忘记了方法，后来去搜索了很多博客才找到有这个方法 方法一：选中DataSet或者DataTable实例，按下Ctrl+Alt_Q，就可以看到想到的结果 方法二：在里面还可以输入代码 如ds.Tables[0].Rows[0]["aa"],也可以计算出结果  有用的就拿过去用，我只是小小搬运工
DS数据结构
m0_63511215的博客
02-21 610
二叉树两个结点的距离是一个结点经过双亲结点，祖先结点等中间结点到达另一个结点经过的分支数。给定一颗二叉树的逻辑结构如下图，（先序遍历的结果，空树用字符‘#’表示，例如AB#C##D##），建立该二叉树的二叉链式存储结构，并输出该二叉树的先序遍历、中序遍历和后序遍历结果。输入图的顶点信息和边信息，完成邻接矩阵的设置，并计算各顶点的入度、出度和度，并输出图中的孤立点（度为0的顶点）每行输出一个要查找的数值在队列的位置和查找次数，数据之间用短划线隔开，如果查找不成功，输出字符串error。孤立点的度信息不输出。
在n个结点的顺序表中，算法的时间复杂度是O(1)的操作是（ ）。A．访问第i个结点（1≤i≤n）和求第i个结点的直接前驱（2≤i≤n） B．在第i个结点后插入一个新结点（1≤i≤n） C．删除
最新发布
集众人智慧，少走弯路，用对方法，事半功倍。祝考研成功，风里雨里，学长学姐，长理等你！
04-20 3445
解释：在顺序表中插入一个结点的时间复杂度都是O(n2)，排序的时间复杂度为O(n2)或O(nlog2n)。顺序表是一种随机存取结构，访问第i个结点和求第i个结点的直接前驱都可以直接通过数组的下标直接定位，时间复杂度是O(1)。A．访问第i个结点（1≤i≤n）和求第i个结点的直接前驱（2≤i≤n）809数据结构和908数据结构与算法_练习 第2章 线性表。B．在第i个结点后插入一个新结点（1≤i≤n）C．删除第i个结点（1≤i≤n）D．将n个结点从小到大排序。
JQuery Datatables Columns API 参数详细说明
liuwei890624的博客
06-28 2856
Data Tables: http://datatables.net/ Version: 1.10.0   Columns说明 虽然我们可以通过DOM直接获取DataTables元素的信息，但是DataTables提供了更方便的方法，可以自定义列的属性。下边就让我们一起来学习DataTables是怎么来定义列属性的。 DataTables提供了两个参数来定义列属性：columns ...
TPC-DS 生成数据
草原孤狼的专栏
07-07 6145
简介 其实，使用 TPC-DS 生成系统性能测试的数据，说简单也简单，说难，确实也不好做！ 关键是在每一步的操作中，如果遇到了问题，该怎么样处理，这个是个问题的关键。 下面就将生成的步骤简单描述一下，好记性不如烂笔头呀！ 生成步骤 1.在官网上(http://www.tpc.org/tpcds/ )去下载最新的：TPC-DS.  2.解压: 下载的 zip 文件放在
DS_1_线性表2
08-03
理解线性表及其基本操作对于学习数据结构至关重要，因为许多其他复杂数据结构（如栈、队列、树和图）都是基于线性表的概念扩展和演变而来的。同时，掌握如何有效地实现这些操作对于优化算法性能和内存管理也非常重要...
ds_list1.rar_数据结构
09-23
在本项目"ds_list1.rar_数据结构"中，重点是实现线性表这一基本数据结构的操作，包括节点的查询、插入和删除。线性表是一种最基础的数据结构，它的元素按照线性的顺序排列，每个元素都有一个前驱和一个后继（除了...
数据结构-线性表-单链表
zhh9426的博客
08-09 483
数据结构-线性表-单链表
数据结构线性表
南亭的博客
10-13 2423
​​​ 一、基本概念 1、线性表的定义 线性表是由n（n≥0）个相同类型的数据元素组成的有限序列。标记为： L = （al , a2, … , ai , … , an） 线性表中元素的个数n定义为线性表的长度，当n=0时为空表。 当n>0时，线性表的逻辑结构图如下所示。 2、线性表的基本运算 初始化InitList(L)。其作用是建立一个空表L（即 建立线性表的构架，但不含任何数据元素）。 销毁线性表DestroyList(L)。其作用是释放线性表...
数据结构之线性表（MyArrayList、MyLinkedList）
qq_43537865的博客
10-16 343
线性表概述 线性表是最基本、最简单、也是最常用的一种数据结构。在线性表中数据元素之间的关系是线性，数据元素可以看成是排列在一条线上或一个环上。 线性表分为静态线性表和动态线性表，常见的有顺序表(静态的)、单向链表(动态的)和双向链表(动态的)。 顺序表(ArrayList)的实现 在这里我们提供便于使用的ArrayList泛型类的实现。为了避免与类库中的类相混，这里将把我们的类叫做MyArrayL...
汇编初学——ds(数据段data segment)
orange_monkey的博客
05-09 5990
ds（数据段data segment) mov ax, XXX mov ds, ax //段地址，不可以直接赋值给ds mov bx, XXX//偏移地址
数据结构 线性表 输入一数插入到有序表中，是生成的线性表任然有序
朝歌
09-10 3572
有序线性表从大到小排列，西安插入一个数，插入后的线性表依然是有序线性表。 代码如下： #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define Max 100 // 定义数组的最大长度 typedef int Datatype; // 定义数组元素的数据类型 typedef struct { Datatype d...
基于SymmetricDS的多主一从数据库同步方案
热门推荐
seattle0564的专栏
03-28 1万+
团队最近有个数据同步的需求，大致是两台或以上的数据库(MariaDB)服务器走VPN通道与一台数据库进行数据同步，先不关心VPN通道通迅的问题，对于这种多主一从的数据同步需求，也曾尝试通过MySQL本身的复制功能配置实现，但貌似不管是MySQL还是MariaDB目前都还没有实现多主一从的复制方案(官方说MariaDB从10.0开始支持,等到花儿都谢了)。 初步确定两种方案：        1.
数据结构-线性表（一）概念及基本操作
北以晨光的博客
09-13 8373
数据结构 线性表（一）基本概念及基本操作 线性表的定义及基本操作以及顺序表示的实现代码
已知有两个按元素值递增有序的顺序表A和B，设计一个算法将表A和表B的全部元素归并为一个按元素值递增有序的顺序表C。
蓝多多的小仓库
04-17 1万+
已知有两个按元素值递增有序的顺序表A和B，设计一个算法将表A和表B的全部元素归并为一个按元素值递增有序的顺序表C。 要求： 从键盘输入顺序表A和B的各元素，编程实现上述算法，输出顺序表A、顺序表B和顺序表C 的所有元素值 。算法思路： 先设C为空表，然后比较A和B中的数据元素，将A或B中较小的元素插入到C中。当其中一个顺序表的数据元素均已插入到C中时，另一顺序表中的剩余元素依次插入即可。...
初学数据结构——顺序表的基本操作
薛铁钢的博客
04-09 345
#include <iostream> #include <cstdlib> #include <math.h> #define MAXSIZE 100 #define OK 1 #define ERROR 0 #define Status int using namespace std; //定义单链表的存储结构 typedef struct LNode { ...
第二章 线性表 顺序表的两种实现方法及9种基本操作的实现
亓官劼的博客
06-13 6383
**文末附完整测试程序代码** ## 2.2 线性表的顺序表示 ### 顺序表的定义 线性表的顺序存储又称为顺序表。它是用一组地址连续的存储空间来依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻。顺序表的特点为：表中元素的逻辑顺序与物理顺序相同。 我们顺序表的定义也可以根据数组的分配类型来分为动态分配和静态分配。
mysql创建ds分区表_PostgreSQL数据库分区表创建与测试
weixin_31021649的博客
01-19 519
目的：创建分区表并插入数据，验证数据存放效果。思路：PG的分区表和Oracle与MySQL有所不同，是基于子表实现的分区表，即创建一个父表，然后创建子表，插入的数据会存放在子表中，但是增删改操作的语句写父表即可，数据分放的规则通过触发器、存储过程实现。本次测试中共创建4个子表和1个父表，分别为rock、pop、jazz和classic4个子表和1个music父表，往里面插入歌曲信息，并验证是否自动...
数据结构复习----线性表
qq_53732836的博客
04-05 1121
1.线性表的基本操作 &表示C++语言中的引用调用 什么时候要传入参数的引用“&”--对参数的修改结果需要“带回来” （1）未使用&时的代码
线性表数据结构详解
"DS-数据结构线性表完美版资料.ppt" 线性表是数据结构中的基础概念，它是一个包含n（n≥0）个相同类型元素的有限序列，通常表示为(a1, a2, ..., ai-1, ai, ai+1, ..., an)。这种数据结构的特点是具有线性顺序，每个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值