数据结构实验报告 实验一 顺序表实验 【个人复盘】

最新推荐文章于 2023-10-18 17:34:28 发布
最新推荐文章于 2023-10-18 17:34:28 发布
阅读量384 收藏 2
点赞数 1
文章标签： 数据结构 软件工程 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73952999/article/details/129978895
版权
  1. 实验目标
  1. 熟练掌握线性表的顺序存储结构。
  2. 熟练掌握顺序表的有关算法设计和实现。
  3. 根据具体问题的需要，设计出合理的表示数据元素的顺序结构，并设计相关算法。

  1. 实验要求
  1. 顺序表结构和运算定义，算法的实现以库文件方式实现，不得在测试主程序中直接实现；比如存储、算法实现放入文件：seqList.h
  2. 程序有适当的注释，程序的书写要采用缩进格式。
  3. 实验程序有较好可读性，各运算和变量的命名直观易懂，符合软件工程要求；
  4. 程序要具有一定的健壮性，即当输入数据非法时，程序也能适当地做出反应，如插入删除时指定的位置不对等等。
  5. 程序要做到界面友好，在程序运行时用户可以根据相应的提示信息进行操作。
  6. 程序运行、测试正确；

根据实验报告模板详细书写实验报告。

  1. 实验内容

编写算法实现下列问题的求解。

  1. 在第i个结点位置插入值为x的结点。

实验测试数据基本要求：

第一组数据：顺序表长度n≥10，x=100,  i分别为5,n,n+1,0,1,n+2

第二组数据：顺序表长度n=0，x=100，i=5

  1. 删除顺序表中第i个元素结点。

实验测试数据基本要求：

第一组数据：顺序表长度n≥10，i分别为5,n,1,n+1,0

第二组数据：顺序表长度n=0， i=5

  1. 在一个递增有序的顺序表L中插入一个值为x的元素，并保持其递增有序特性。

实验测试数据基本要求：

顺序表元素为 （10,20,30,40,50,60,70,80,90,100）,

x分别为25，85，110和8

  1. 将顺序表Ｌ中的奇数项和偶数项结点分解开（元素值为奇数、偶数），分别放入新的顺序表中，然后原表和新表元素同时输出到屏幕上，以便对照求解结果。

实验测试数据基本要求：

第一组数据：顺序表元素为 （1,2,3,4,5,6,7,8,9,10,20,30,40,50,60）

第二组数据：顺序表元素为 （10,20,30,40,50,60,70,80,90,100）

  1. 求两个递增有序顺序表L1和L2中的公共元素，放入新的顺序表L3中。

实验测试数据基本要求：

第一组

第一个顺序表元素为 （1，3，6，10，15，16，17，18，19，20）

第二个顺序表元素为 （1，2，3，4，5，6，7，8，9，10，18，20，30）

第二组

第一个顺序表元素为 （1，3，6，10，15，16，17，18，19，20）

第二个顺序表元素为 （2，4，5，7，8，9，12，22）

第三组

第一个顺序表元素为 （）

第二个顺序表元素为 （1，2，3，4，5，6，7，8，9，10）

  1. 删除递增有序顺序表中的重复元素，并统计移动元素次数，要求时间性能最好。

实验测试数据基本要求：

第一组数据：顺序表元素为 （1,2,3,4,5,6,7,8,9）

第二组数据：顺序表元素为 （1,1,2,2,2,3,4,5,5,5,6,6,7,7,8,8,9）

第三组数据：顺序表元素为 （1,2,3,4,5,5,6,7,8,8,9,9,9,9,9）

1.4* 顺序表扩展实验

（非必做内容，有兴趣的同学选做）1.（递增有序）

#include<iostream>
#include"标头.h"//include"seqList.h"
using namespace std;

int main() {
    int i = 1;
    int nums = 0;
    seqList ll;
    seq l = &ll;
    seqList ss;
    seq s = &ss;
    initialList3(s);
    
    ss.data[0] = 1;
    ss.data[1] = 3;
    ss.data[2] = 6;
    ss.data[3] = 10;
    ss.data[4] = 15;
    ss.data[5] = 16;
    ss.data[6] = 17;
    ss.data[7] = 18;
    ss.data[8] = 19;
    ss.data[9] = 20;
    ss.len += 10;

    seqList ee;
    initialList(ee);

    while (i) {
        cout << "********************************************************************************************" << endl;
        cout << "*                 欢迎您来到测试页面，现在开始您的测试                                     *" << endl;
        cout << "*-----------------------------  功能页面 --------------------------------------------------*" << endl;
        cout << "*	          1.新建一个顺序表并进行初始化                                             *" << endl;
        cout << "*                 2.在第i个结点位置插入值为x的结点                                         *" << endl;
        cout << "*                 3.删除顺序表中第i个元素结点                                              *" << endl;
        cout << "*                 4.打印输出当前顺序表                                                     *" << endl;
        cout << "*                 5.往顺序表加入n个数                                                      *" << endl;
        cout << "*                 6.在一个递增有序的顺序表L中插入一个值为x的元素，并保持其递增有序特性     *" << endl;
        cout << "*                 7.将顺序表Ｌ中的奇数项和偶数项结点分解开                                 *" << endl;
        cout << "*                 8.两个递增有序顺序表L1和L2中的公共元素，放入新的顺序表L3中               *" << endl;
        cout << "*                 9.删除递增有序顺序表中的重复元素，并统计移动元素次数                     *" << endl;
        cout << "*                 10.附加题：1.1C=A∪B                                                     *" << endl;
        cout << "*                 11.附加题：1.2C=A∩B                                                     *" << endl;
        cout << "*                 12.附加题：1.3C=A-B                                                      *" << endl;
        cout << "*                 13.附加题：1.4A=A∩B                                                     *" << endl;
        cout << "*                 14.附加题：1.5A = A∪B                                                   *" << endl;
        cout << "*                 15.附加题：1.6A=A-B                                                      *" << endl;
        cout << "*                 16.附加题：2                                                             *" << endl;
        cout << "*                 17.附加题：3                                                             *" << endl;
        cout << "*                 0.退出功能页面                                                           *" << endl;
        cout << "********************************************************************************************" << endl;
        cout << "输入你要选择的功能序号:" << endl;
        int num;
        cin >> num;
        switch (num) {
        case 0:
            i = 0;
            break;
        case 1:
            initialList3(l);
            break;
        case 2:
            cout << "请输入你想加入的元素和位置" << endl;
            elementType x;
            cin >> x;
            int y;
            cin >> y;
            listInsert3( l, x, y);
            if (l->ifError == 1) {
                cout << "溢出无法插入" << endl;
            }
            else if (l->ifError == 2) {
                cout << "边界错误，无法插入" << endl;
            }  
            l->ifError = 0;
            break;
        case 3:
            cout << "请输入你要删除的元素的位置" << endl;
            int yy;
            cin >> yy;
            listDelete3(l, yy);
            if (l->ifError == 1) {
                cout << "溢出无法删除" << endl;
            }
            else if (l->ifError == 2) {
                cout << "边界错误，无法删除" << endl;
            }
            break;
        case 4:
            cout << "输出的元素为：" << "  ";
            for (int i = 0; i < l->len; i++) {

                cout << l->data[i] << " ";
               
            }
            cout << endl;
            break;
        case 5:
            cout << "想要加入的数：" << endl;
            int c;
            cin >> c;
            for (int g = 1; g <= c; g++) {
                listInsert3(l, g, g);
            }

            break;
        case 6:
            cout << "想要添加的值" << endl;
            elementType val;
            cin >> val;
            listInsertInTurn(l, val);
            break;
        case 7:
            cout << "原表输出的元素为：" << "  ";
            for (int i = 0; i < l->len; i++) {

                cout << l->data[i] << " ";

            }
            cout << endl;
            ss=listDepart(ll);
            cout << "单数表输出的元素为：" << "  ";
            for (int i = 0; i < l->len; i++) {
                cout << l->data[i] << " ";
            }
            cout << endl;
            cout << "双数表输出的元素为：" << "  ";
            for (int i = 0; i < s->len; i++) {
                cout << s->data[i] << " ";
            }
            break;
        case 8:
            cout << "原第一表输出的元素为：" << "  ";
            for (int i = 0; i < l->len; i++) {

                cout << l->data[i] << " ";

            }
            cout << endl;
            cout << "原第二表输出的元素为：" << "  ";
           
            for (int i = 0; i < s->len; i++) {

                cout << s->data[i] << " ";

            }
            cout << endl;
            ee=listThree(ll, ss);
            cout << "现在第一表输出的元素为：" << "  ";
            for (int i = 0; i < l->len; i++) {

                cout << l->data[i] << " ";

            }
            cout << endl;
            cout << "现在第二表输出的元素为：" << "  ";
            for (int i = 0; i < s->len; i++) {

                cout << s->data[i] << " ";

            }
            cout << endl;
            cout << "现在第三表输出的元素为：" << "  ";
            for (int i = 0; i < ee.len; i++) {

                cout << ee.data[i] << " ";

            }
            cout << endl;
            break;
        case 9:
            cout << "原表输出的元素为：" << "  ";
            for (int i = 0; i < l->len; i++) {

                cout << l->data[i] << " ";

            }
            cout << endl << "移动次数为：" << listDeleteTheSame( ll) << endl;
            cout << "现表输出的元素为：" << "  ";

            for (int i = 0; i < l->len; i++) {

                cout << l->data[i] << " ";

            }
            break;
        case 10:
            cout << "原第一表输出的元素为：" << "  ";
            for (int i = 0; i < l->len; i++) {

                cout << l->data[i] << " ";

            }
            cout << endl;
            cout << "原第二表输出的元素为：" << "  ";

            for (int i = 0; i < s->len; i++) {

                cout << s->data[i] << " ";

            }
            cout << endl;
            ee = unionSet(ll, ss);
            cout << "现在第三表输出的元素为：" << "  ";
            for (int i = 0; i < ee.len; i++) {

                cout << ee.data[i] << " ";

            }
            cout << endl;
            system("pause");
            break;
        case 11:
            cout << "原第一表输出的元素为：" << "  ";
            for (int i = 0; i < l->len; i++) {

                cout << l->data[i] << " ";

            }
            cout << endl;
            cout << "原第二表输出的元素为：" << "  ";

            for (int i = 0; i < s->len; i++) {

                cout << s->data[i] << " ";

            }
            cout << endl;
            ee = intersectSet(ll, ss);
            cout << "现在第三表输出的元素为：" << "  ";
            for (int i = 0; i < ee.len; i++) {

                cout << ee.data[i] << " ";

            }
            cout << endl;
            system("pause");
            break;
        case 12:
            cout << "原第一表输出的元素为：" << "  ";
            for (int i = 0; i < l->len; i++) {

                cout << l->data[i] << " ";

            }
            cout << endl;
            cout << "原第二表输出的元素为：" << "  ";

            for (int i = 0; i < s->len; i++) {

                cout << s->data[i] << " ";

            }
            cout << endl;
            ee = diffSet(ll, ss);
            cout << "现在第三表输出的元素为：" << "  ";
            for (int i = 0; i < ee.len; i++) {

                cout << ee.data[i] << " ";

            }
            cout << endl;
            system("pause");
            break;
        case 13:
            cout << "原第一表输出的元素为：" << "  ";
            for (int i = 0; i < l->len; i++) {

                cout << l->data[i] << " ";

            }
            cout << endl;
            cout << "原第二表输出的元素为：" << "  ";

            for (int i = 0; i < s->len; i++) {

                cout << s->data[i] << " ";

            }
            cout << endl;
            intersectSetTheFirst(ll, ss);
            cout << "现在第三表输出的元素为：" << "  ";
            for (int i = 0; i < ll.len; i++) {

                cout << ll.data[i] << " ";

            }
            cout << endl;
            system("pause");
            break;
        case 14:
            cout << "原第一表输出的元素为：" << "  ";
            for (int i = 0; i < l->len; i++) {

                cout << l->data[i] << " ";

            }
            cout << endl;
            cout << "原第二表输出的元素为：" << "  ";

            for (int i = 0; i < s->len; i++) {

                cout << s->data[i] << " ";

            }
            cout << endl;
            unionSetTheFirst(ll, ss);
            cout << "现在第三表输出的元素为：" << "  ";
            for (int i = 0; i < ll.len; i++) {

                cout << ll.data[i] << " ";

            }
            cout << endl;
            system("pause");
            break;
        case 15:
            cout << "原第一表输出的元素为：" << "  ";
            for (int i = 0; i < l->len; i++) {

                cout << l->data[i] << " ";

            }
            cout << endl;
            cout << "原第二表输出的元素为：" << "  ";

            for (int i = 0; i < s->len; i++) {

                cout << s->data[i] << " ";

            }
            cout << endl;
            DeleteSetTheFirst(ll, ss);
            cout << "现在第三表输出的元素为：" << "  ";
            for (int i = 0; i < ll.len; i++) {

                cout << ll.data[i] << " ";

            }
            cout << endl;
            system("pause");
            break;
        case 16:
            cout<<"A是B的子集吗："<<isSubset(ll, ss);
            cout << endl;
            system("pause");
            break;
        case 17: 
            cout << "两个顺序表的中位数为：" << listFindTheMiddel(ll, ss);
            cout << endl;
            system("pause");
            break;
        }
        
        
       // system("pause");
        //system("cls");

    }


	return 0;
}

#define MAXLEN 200
#define elementType int

typedef struct  seqList
{
	elementType data[MAXLEN];//顺序表
	int len;//记录表的长度
	int ifError = 0;//判断接下来的操作的错误种类

}se,*seq;//起别名并定义指针

void initialList(seqList&l) {
	l.len = 0;
}

void initialList3(seqList* l) {
	l->len = 0;
}

/*void listInsert(seqList& l, elementType x, int y) {
	int k;
	if (l.len == MAXLEN) {
		l.ifError = 1;//溢出无法插入
	}
	else if (y<1 || y>l.len + 1) {//边界错误，无法插入
		l.ifError = 2;
	}
	else {
		for (int k = l.len - 1; k >= y - 1; k--) {
			l.data[k + 1] = l.data[k];
			l.data[k] = x;
			l.len++;
		}
	}
}*/
void listInsert3(seq l, elementType x, int y) {
	int k;
	if (l->len == MAXLEN) {
		l->ifError = 1;//溢出无法插入
	}
	else if (y<1 || y>l->len + 1) {//边界错误，无法插入
		l->ifError = 2;
	}
	else {
		l->len++;
		for (int k = l->len - 1; k >= y - 1; k--) {
			l->data[k + 1] = l->data[k];
			l->data[k] = x;
			
		}
		
	}
}


/*void listInsert2(int a[], int& b, elementType x, int y, seqList l) {
	int k;
	if (b == MAXLEN) {
		l.ifError = 1;//溢出无法插入
	}
	else if (y<1 || y>b + 1) {//边界错误，无法插入
		l.ifError = 2;
	}
	else {
		for (int k = b - 1; k >= y - 1; k--) {
			a[k + 1] = a[k];
			a[k] = x;
			b++;
		}
	}
}*/

void listDelete(seqList& l,int y) {
	if (l.len <=0) {
		l.ifError = 1;//溢出无法删除
	}
	else if (y<1 || y>l.len + 1) {//边界错误，无法删除
		l.ifError = 2;
	}
	else {
		for (int i = y - 1; i <= l.len - 1; i++) {
			l.data[i - 1] = l.data[i]; 
			

		}
		l.len--;
	}
}

void listDelete3(seqList* l, int y) {
	if (l->len <= 0) {
		l->ifError = 1;//溢出无法删除
	}
	else if (y<1 || y>l->len) {//边界错误，无法删除
		l->ifError = 2;
	}
	else {
		for (int i = y - 1; i < l->len - 1; i++) {
			l->data[i] = l->data[i+1];
			
		}
		l->len--;
	}
}




/*void listInsertInTurn(seqList& l, elementType val) {
	if (l.len == 0) {
		l.data[0] = val;
	}
	else {


		int le = 0;
		int r = l.len - 1;
		int k;
		while (le < r) {
			int mid = le + r >>2;
			if (l.data[mid] > val) {
				r = mid-1;
			}
			else if (l.data[mid] < val) {
				le = mid+1;
			}
			else {
				k = mid;
				break;
			}
		}
		if (l.data[r] > val)k = r ;
		else {
			k = r ;
		}
		listInsert(l, val, k);
	}
}*/

void listInsertInTurn(seq l, elementType x) {
	for (int i = l->len - 1; i > 0; i--) {
		if (x <= l->data[i]) {
			if (x >= l->data[i - 1]) {
				listInsert3(l, x, i+1);  //插入元素
				break;
			}
		}

	}
	if (x > l->data[l->len - 1]) {
		listInsert3(l,  x, l->len + 1);
	}
	else if (x < l->data[0]) {
		listInsert3(l, x, 1);
	}
	

}


int listLength(seqList &l) {
	return  l.len;
}

seqList listDepart(seqList & l) {
	seqList thenew;
	seq t = &thenew;//创建一个新指针
	//int len = l.len;
	initialList(thenew);
	for (int j = 0; j < l.len; j++) {
		if (l.data[j] % 2 == 1) {//判断奇偶数
			continue;
		}
		else {
			listInsert3(t, l.data[j], thenew.len+1);//在新顺序表插入
			listDelete3(&l, j+1);//从原顺序表删除
			j--;
			
		}
	}
	return thenew;
}

seqList listThree(seqList&l,seqList&dou) {
	seqList thenew;
	seq t = &thenew;//构建指针指向结构体
	initialList(thenew);//初始化
	int up = 0;
	int down = 0;
	while (up != l.len && down != dou.len) {//采用双指针
		if (l.data[up] > dou.data[down]) {
			down++;
		}
		else if (l.data[up] < dou.data[down]) {
			up++;
		}
		else {
			listInsert3(t, l.data[up], thenew.len+1);//插入到新顺序表中
			up++;
			down++;
		}
		
	}
	return thenew;//返回一个新顺序表
}

/*int listDeleteTheSame(seqList& l) {
	int r = 0;
	int ll = 0;
	int count = 0;
	int temp = l.len;
	if (l.len = 0 || l.len == 1) {
		return count;
	}
	else {

		while (r != l.len) {
			if (l.data[ll] == l.data[r]) {
				r++;
			}
			else {
				l.data[ll + 1] = l.data[r];
				ll++;
				r++;
				count++;
			}
		}
		
			l.len = r-1;
		
	}
	return count;
}*/

int listDeleteTheSame(seqList &list) {
	int count = 0;//统计移动次数
	
		if (list.len == 0||list.len==1) {
		return 0;		
	}
    int pre = 0, last = 1;//pre为位于前面的下标，last为位于后面的下标
	int temp = list.len;//temp用于统计删除重复元素后的顺序表长度
	while (last < list.len) {
	//如果pre和last指代元素相同时,temp减一,last向后移动一位
	if (list.data[last] == list.data[pre]) {
	temp--;
	last++;
		}
	//如果pre和last不相邻时，证明中间含有重复元素，且该重复元素值与pre指代元素相同
	else if (pre + 1 != last) {
	//pre后移一位后，并用last指代元素覆盖pre指代元素，然后last后移一位
	list.data[++pre] = list.data[last++];
	count++;//元素移动次数加一
		}
	else
	 {  //pre和last相邻时，二者均后移一位
			pre++;
			last++;
		}
	}
	list.len = temp;
	return count;//返回计数值
}



seqList unionSet(seqList&a,seqList&b) {//C=A∪B
	int i=0, j=0;  
	seqList thenew;
	initialList(thenew);//初始化新顺序表
	/*for (i = 0; i < lenB; i++) {
		for (j = 0; j < lenA; j++) { 
			if (B[i] == A[j]) { 
				thenew.data[thenew.len++] = B[i];
				break; 
			} 
		}       
		if (j == lenA) { 
			thenew.data[thenew.len++] = B[i];//储存数据
		} 
	}
	for (i = 0; i < lenA; i++) {
		for (j = 0; j < lenB; j++) {
			if (B[i] == A[j]) {
				break;//之前已经存过一回数据，现在不用再存了
			}
		}
		if (j == lenB) {
			thenew.data[thenew.len++] = B[i];//储存数据
		}
	}
	listDeleteTheSame(thenew);//删除相同元素
	thenew.len--;*/
	while (i != a.len && j != b.len) {
		if (a.data[i] < b.data[j]) {//将较小元素加入表中
			thenew.data[thenew.len++] = a.data[i];
			i++;
			break;
		}
		else if (a.data[i] > b.data[j]) {
			thenew.data[thenew.len++] = b.data[i];
			j++;

		}
		else {
			thenew.data[thenew.len++] = b.data[i];
			i++; j++;
		}
	}
	if (i != a.len) {//判断双指针不同时结束时，剩下的元素接到新表尾
		for (int q = i; q < a.len; q++) {
			thenew.data[thenew.len++] = a.data[q];
		}
	}
	else if (i != b.len) {
		for (int q = i; q < b.len; q++) {
			thenew.data[thenew.len++] = b.data[q];
		}
	}
	return thenew;
}

seqList intersectSet(seqList&a,seqList&b) {//C=A∩B
	int i=0, j = 0;
	seqList thenew;
	initialList(thenew);
	while (i != a.len && j != b.len) {
		if (a.data[i] < b.data[j]) {
			i++;
			
		}
		else if (a.data[i] > b.data[j]) {
			j++;
			
		}
		else {
			thenew.data[thenew.len++] = b.data[j];//两个元素相同时，将该值赋给新顺序表
			i++; j++;
		}
	}
	
	return thenew;
}

seqList diffSet(seqList& a, seqList& b) {//C=A-B
	int i=0, j = 0;
	seqList thenew;
	initialList(thenew);//初始化新表
	while (i != a.len && j != b.len) {
		if (a.data[i] < b.data[j]) {
			thenew.data[thenew.len++] = a.data[i];//只有a的值小于b的值时，才将值赋给新顺序表
			i++;
		}
		else if (a.data[i] > b.data[j]) {
			j++;
			
		}
		else {
			
			i++; j++;
		}
	}
	return thenew;
}

void intersectSetTheFirst(seqList& a,seqList b) {//A∩B
	int i = 0;//双指针
	int j = 0;
	while (i != a.len) {
		if (a.data[i] < b.data[j]) {
			listDelete3(&a, i+1);//从A中删除该元素

		}
		else if (a.data[i] > b.data[j]) {
			j++;

		}
		else {
			i++; j++;//同时移动指针
		}
	}

}

void unionSetTheFirst(seqList&a,seqList b) {
	//A = A∪B
	int i = 0;//双指针
	int j=0;
	while (i != a.len && j != b.len) {
		if (a.data[i] < b.data[j]) {
			i++;

		}
		else if (a.data[i] > b.data[j]) {
			listInsert3(&a, b.data[j], i + 1);//从A中插入该元素
			j++;

		}
		else {
			i++; j++;//同时移动指针
		}
	}
	listDeleteTheSame(a);
}

void DeleteSetTheFirst(seqList& a, seqList b) {
	//A=A-B
	int i = 0;//双指针
	int j = 0;
	while (i != a.len && j != b.len) {
		if (a.data[i] < b.data[j]) {
			i++;

		}
		else if (a.data[i] > b.data[j]) {
			
			j++;

		}
		else {
			listDelete3(&a, i+1);//从A中删除该元素
			j++;//同时移动指针
		}
	}
	
}


bool isSubset(seqList A, seqList B) {
	int i, j;
	for (i = 0; i < A.len; i++) {
		for (j = 0; j < B.len; j++) {
			if (A.data[i] == B.data[j]) {//当两者值相同时，结束循环
				break;
			}
		}
		if (j == B.len) {
			return 0;//循环结束时，j=B.len则未搜索到，返回false
		}
	}
	return 1;
}

/*一个长度为L（L≥1）的升序序列S，处在第          个位置的数称为S 的中位数。例如，若序列S1 = (11, 13, 15, 17, 19)，则S1 的中位数是15。两个序列的中位数是含它们所有元素的升序序列的中位数。例如，若S2 = (2, 4, 6, 8, 20)，则S1 和S2 的中位数是11。
现有两个等长升序序列A 和B，试设计一个在时间和空间两方面都尽可能高效的算法，找出两个序列A 和B 的中位数。要求：
（1）给出算法的基本设计思想。
（2）根据设计思想，采用C 或C++语言描述算法，关键之处给出注释。
（3）说明你所设计算法的时间复杂度和空间复杂度。*/

elementType listFindTheMiddel(seqList a,seqList b) {
	int i = 0, j = 0;
	int L1 = a.len;
	int L2 = b.len;
	int res = (L1 + L2) % 2 == 0 ? (L1 + L2)/2: (L1 + L2) / 2+1 ;//返回中间值
	int count = 0;
	int kind =0;
	while (i != a.len && j != b.len) {//从小到大搜索到对应下标的值
		if (a.data[i] <= b.data[j]) {
			count++;
			i++;
			kind = 1;


		}
		else if (a.data[i] > b.data[j]) {
			count++;
			j++;
			kind = 2;

		}
		if (count == res) {
			return kind == 1 ? a.data[i - 1] : b.data[j - 1];
		}
		
	}
	if (i != a.len && count != res) {//对一个顺序表到头，但是另一个顺序表，且未搜索到对应值未到头的情况进行查找
		i++;
		count++;
		if (count == res) {
			return a.data[i - 1] ;
		}
	}
	else if (j != b.len && count != res) {
		j++;
		count++;
		if (count == res) {
			return b.data[j - 1];
		}
	}
	return -1;
}

2.（递增有序）顺序表表示集合A、B，判定A是否B的子集。

3. (2011)（15 分）一个长度为L（L≥1）的升序序列S，处在第          个位置的数称为S 的中位数。例如，若序列S1=(11, 13, 15, 17, 19)，则S1 的中位数是15。两个序列的中位数是含它们所有元素的升序序列的中位数。例如，若S2=(2, 4, 6, 8, 20)，则S1 和S2 的中位数是11。

    现有两个等长升序序列A 和B，试设计一个在时间和空间两方面都尽可能高效的算法，找出两个序列A 和B 的中位数。要求：

（1）给出算法的基本设计思想。

（2）根据设计思想，采用C 或C++语言描述算法，关键之处给出注释。

（3）说明你所设计算法的时间复杂度和空间复杂度。

吾日吾身三摆烂
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构顺序表实验报告优质资料.doc
12-01
数据结构顺序表实验报告优质资料.doc
数据结构--顺序表的c语言实现（超详细注释/实验报告）
池塘春草梦的博客
09-25 1万+
线性表是一种最基本、最常用的数据结构，它有两种存储结构——顺序表和链表。顺序表是由地址连续的的向量实现的，便于实现随机访问。顺序表进行插入和删除运算时，平均需要移动表中大约一半的数据元素，容量难以扩充。
《数据结构》实验报告二：顺序表 链表
Amentos的博客
10-03 1万+
《数据结构》实验报告：线性表的顺序存储和链式存储 相关概念 + 插入/删除/查找 算法实现 + 优缺点分析
数据结构与算法实验一——顺序表操作实验报告
m0_51393229的博客
11-07 1万+
第一章 实验目的 1．掌握线性表的顺序存储结构的表示和实现方法。 2．掌握顺序表基本操作的算法实现。 3．了解顺序表的应用。 第二章 实验环境 硬件环境要求： PC机（单机） 使用的软件名称、版本号以及模块： DEV C++、VS2010等。 第三章 实验内容 编写一个程序，实现顺序表的各种基本运算（假设顺序表的元素类型为char），并在此基础上设计一个主程序完成如下功能： （1）初始化顺序表L； （2）依次采用尾插法插入a、b、c、d、e元素； （3）输出顺序表L； （4）输出顺序表L的长度； （5）判断
c语言顺序表操作实验报告
m0_73558214的博客
09-28 969
数据结构顺序表实验，c语言实现顺序表增删改查操作
数据结构教程实验一顺序表基本操作的实现
Annzz123的博客
06-16 6567
实现顺序表各种基本运算的基础上，设计主程序，完成如下功能：（1）初始化顺序表L。（2）依次插入2，5，7，9，10共5个元素。（3）输出顺序表L。4）输出顺序表L的长度。（5）判断顺序表L是否为空。6）输出顺序表L第4个元素。（7）输出元素5的位置。（8）在第4个元素的位置上插入元素100。（9）输出顺序表L。（10）删除顺序表L的第3个元素。（11）输出顺序表L。（12）释放顺序表L。
《数据结构》实验报告（一）——顺序表存储结构及实现
热门推荐
weixin_44197749的博客
11-17 2万+
顺序表存储结构及实现——学生信息管理 一、实验目的 (1) 掌握顺序表的概念及实现方式。 (2) 掌握顺序表的存储结构及主要运算：建立、查找、插入、删除等。 二、实验环境 Windows 10，Microsoft Visual C++ 2010 Express 三、实验内容 1、内容描述 定义一个包含学生信息（学号，姓名，成绩）的顺序表，使其具有如下功能： (1) 逐个输入学生信息，建立信息表； (2) 显示信息表中所有学生的相关信息； (3) 根据姓名进行查找，返回此学生的学号和成绩； (4) 给定一个学
数据结构实验报告—顺序表的基本操作—学生管理系统
VLOKL的博客
03-31 6786
数据结构实验报告，顺序表的基本操作，学生管理系统
数据结构实验报告：顺序表基本操作的实现
beautifulxiaodu的博客
09-13 6584
（1）领会线性表顺序存储结构的特点。（2）掌握线性表顺序存储结构的常见算法。（1）建立顺序表存储数据序列（10，20，30，40，50，60，70，80，90,100）（2）输出顺序表中的所有元素；（3）输出顺序表中的最大值和最小值；（4）键盘输入一个数x，如x在表中返回其在表中的位序，不在返回相应提示信息。（5）删除顺序表中的第8个元素，并输出顺序表中的所有元素；（6）在第5个元素后面插入新元素55，并输出顺序表中的所有元素；（7）输出顺序表的长度。（1）输入线性表的元素个数，然后构建一个新的线性表； （
《数据结构》实验报告（一）顺序表基本操作
qq_52765554的博客
04-04 1万+
#include <stdio.h> #include <stdlib.h> #define MAXSIZE 100 //顺序表的最大长度； int k=0;//全局变量，用于循环； typedef int elemtype;//元素类型； typedef struct{ elemtype data[MAXSIZE];//用数组存储线性表的元素； int length;//顺序表的长度，元素个数； }SqList; void InitList(SqList *L)//初始化顺序表
数据结构实验线性表实验报告（代码是java编写的）
05-10
（1）创建一个顺序表，存放在数组 A[N]中，元素的类型为整型，设计算法调整 A，使其左边的所有元素小于 0，右边的所有元素大于 0（要求算法的时间复杂度和空间复杂度均为 O(n)）。 （2）建立一个循环单链表，其节点...
数据结构实验报告顺序表的创建遍历及有序合并操作优质资料.doc
12-03
数据结构实验报告顺序表的创建遍历及有序合并操作优质资料.doc
数据结构与算法 -李春葆 实验报告-顺序表
12-20
大学生期末作业救命稻草 包含实验源代码，算法描述，代码运行结果截图，实验总结以及算法流程图。
合工大数据结构顺序表实验
04-14
18级合工大数据结构实验
数据结构实验课：实验一、顺序表的实现及应用
listboy的博客
05-19 1万+
一、实验目的 了解和掌握线性表的顺序存储结构；掌握用C语言上机调试线性表的基本方法；掌握线性表的基本操作：插入、删除、查找以及线性表合并等运算在顺序存储结构和链接存储结构上的运算，以及对相应算法的性能分析。 二、实验要求 给定一段程序代码，程序代码所完成的功能为：（1）建立一个线性表；（2）依次输入数据元素1,2,3,4,5,6,7,8,9,10；（3）删除数据元素5；（4）依次显示当前线性表中的数据元素。假设该线性表的数据元素个数在最坏情况下不会超过100个，要求使用顺序表。 程序中有3处错误的地方，有标
桂电七院数据结构实验报告一
qq_55810765的博客
03-08 2431
顺序表的基本操作 实验内容与步骤 实现顺序表上的插入、删除等操作。调试程序并对相应的输出作出分析；修改输入数据，预期输出并验证输出的结果。加深对有关算法的理解。 步骤： 第一步:定义顺序表的存储结构。 第二步：编写顺序表操作的具体函数定义。 第三步：使用定义的顺序表并调用顺序表的一些操作，实现具体运算。 具体函数的定义有： 1） insert(L,i,x)在顺序表的第i个元素之前插入一个新元素x. 2） delete (L,i) 删除顺序表的第i个元素。 3） listprint(L) 输出顺序表。 在DE
顺序表的基本操作实验报告_数据结构——线性结构（3）——顺序表实例
weixin_39799825的博客
11-23 1550
前两篇文章介绍了基于数组的栈跟队列的实现。数组是一种顺序表的结构，所谓顺序表，就是线性表的顺序存储，它用一组地址连续的存储单元，一次存储线性表中的数据，使得逻辑上相邻的两个元素在物理上也相邻。主要特点是表中元素的逻辑顺序跟物理顺序相同。由于物理顺序相同，通过首地址跟元素序号就可以直接在O（1）的时间内找到元素，这种访问方式称为随机访问方式。但是这种存储方式，在插入和删除元素方面又显得复杂很多了，...
数据结构：顺序表和链表学习小结
qq_67931344的博客
09-21 2363
数据结构，顺序表与链表学习小结。单链表的例题和双链表，循环链表之间的区别。
数据结构实验1
最新发布
weixin_74384251的博客
10-18 153
数据结构
7-1 数据结构实验一 顺序表的插入 C语言
03-23
可以使用如下代码实现顺序表的插入： ```c #include #define MAXSIZE 100 // 定义顺序表的最大长度 typedef struct { int data[MAXSIZE]; // 存储数据的数组 int length; // 当前顺序表的长度 } SqList; // ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值