线性表-课后习题01-08

于 2022-07-15 19:45:59 发布
阅读量228 收藏 3
点赞数
文章标签： 数据结构 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58181187/article/details/125772697
版权

0301 从顺序表中删除具有最小值的元素(假设唯一)并由函数返回被删元素的值,空出的位置由最后一个元素填补。若顺序表为空，则显示出出错信息并退出运行。

思路：函数中用引用型参数key返回删除的最小值的元素值。首先判断顺序表是否为空，为空直接返回。若不为空，首先赋值key为顺序表第一个元素值 ，定义新变量pos，记录删除的元素值的位置。for循环遍历顺序表，若元素值小于等于key，就将元素值赋给key，最后，key中保存了删除的最小元素值。在循环外面，用最后的元素值填补删除的元素值位置，顺序表长度减1。

算法代码：

bool deletemin(SqList &L,ElemType &key) {
    if(L.length==0) {
        return false;
    }
    key=L.data[0];
    int pos=0;
    for(int i=0; i<L.length; i++) {
        if(L.data[i]<=k)
            k=L.data[i];
        pos=i;
    }
    L.data[pos]=L.data[L.length-1];
    L.length--;
    return true;
}

运行代码：

#include<iostream>
#include<string>
#define Max 50    //表长度的初始定义 
using namespace std;
//定义一个 顺序表
struct SqList {
	int data[Max]= {1,2,3,4,5,6,7,8};
	int length=8;
};
bool deletemin(SqList &L,int &k) {
	if(L.length==0) {
		return false;
	}
	int min=L.data[0];
	int pos=0;
	for(int i=0; i<L.length; i++) {
		if(L.data[i]<=min){
			min=L.data[i];
			pos=i;
		}
	}
	k=min; 
	L.data[pos]=L.data[L.length-1];
//	L.length--;
	return true;
}
int main() {
	SqList s;	//定义顺序表s
	int value=0;
	cout<<"删除最小值前的顺序表为:"<<endl;
	for(int i=0; i<s.length; i++) {
		cout<<s.data[i]<<" ";
	}
	cout<<endl;
	if(deletemin(s,value)) {
		cout<<"删除的元素为:"<<value<<endl;
		cout<<"删除最小值后的顺序表为:"<<endl;
		for(int j=0; j<s.length; j++) {
			cout<<s.data[j]<<" ";
		}
	} else
		cout<<"错误"<<endl;
	return 0;
}

运行结果

 02 设计一个高效算法，将顺序表的所有元素逆置，要求算法的空间复杂度为O（1）。

思路：算法的空间复杂度为O（1），即在当前存储空间上操作。for循环遍历顺序表，L.Length/2为中间点，首先，key存储左侧的元素值，右侧的元素值搬到左侧，右侧的位置存放之前存储在key的元素值。

算法代码：

bool reverse(SqList &L) {
    int key=L.data[0]; 
    for(int i=0; i<L.length/2; i++) {
        key=L.data[i];
        L.data[i]=L.data[L.length-(i+1)];
        L.data[L.length-(i+1)]=key;
    }
}

运行代码：

#include<iostream>
#include<string>
#define Max 50    //表长度的初始定义 
using namespace std;
//定义一个 顺序表
struct SqList {
	int data[Max]= {1,2,3,4,5,6,7,8};
	int length=8;
};
bool reverse(SqList &L) {
	int key=L.data[0]; 
	for(int i=0; i<L.length/2; i++) {
		key=L.data[i];
		L.data[i]=L.data[L.length-(i+1)];
		L.data[L.length-(i+1)]=key;
	}
}
int main() {
	SqList s;	//定义顺序表s
	int value=0;
	cout<<"逆置前的顺序表为:"<<endl;
	for(int i=0; i<s.length; i++) {
		cout<<s.data[i]<<" ";
	}
	cout<<endl;
	reverse(s) ;
	for(int i=0; i<s.length; i++) {
		cout<<s.data[i]<<" ";
	}
	return 0;
}

 运行结果

03 对长度为n的顺序表L,编写一个时间复杂度为O(n),空间复杂度为O(1)的算法,该算法删除线性中所有值为x的数据元素。

思路1：循环遍历顺序表，顺序表中的元素分为与x相等、与x不相等两种。可以挑选出不相等数据元素放在一个新数组中，但是因为空间复杂度为O(1）,只能选择在原数组中操作。对于不等于x的元素，依次放在数组中，并且用k记录数量，同时k也是对应元素的位置下标。

算法代码：

void deletex(SqList &L,ElemType x) {
    int k=0,i;
    for(int i=0; i<L.length; i++) {
        if(L.data[i]!=x) {
            L.data[k]=L.data[i];
            k++;
        } 
    }
    L.length=k;
}

运行代码： 

#include<iostream>
#include<string>
#define Max 50    //表长度的初始定义 
using namespace std;
//定义一个 顺序表
struct SqList {
	int data[Max]= {1,2,3,4,5,6,7,8};
	int length=8;
};
void deletex(SqList &L,int x) {
	int k=0,i;
	for(int i=0; i<L.length; i++) {
		if(L.data[i]!=x) {
			L.data[k]=L.data[i];
			k++;
		} 
	}
	L.length=k;
}
int main() {
	SqList s;	//定义顺序表s
	int value=0;
	cout<<"删除前的顺序表为:"<<endl;
	for(int i=0; i<s.length; i++) {
		cout<<s.data[i]<<" ";
	}
	cout<<endl;
	deletex(s,2) ;
	cout<<"删除后的顺序表为:"<<endl;
	for(int i=0; i<s.length; i++) {
		cout<<s.data[i]<<" ";
	}
	return 0;
}

 运行结果

思路2：循环遍历顺序表，并且用k记录与x相等的元素个数。在相等元素之后遇到的不相等元素前移动k个元素的位置。比如a[2]==x;a[3]!=x; a[4]==x;a[5]!=x; 遇到a[2]后把它删除，a[3]移动一个位置填补到a[2]的位置。遇到a[4]删除，k变成2，此时，a[3]a[4]的位置都是空的，a[5]移动两个位置填补到原来a[3]的位置。

算法代码：

void deletex(SqList &L,int x) {
    int k=0;
    while(i<L.length) 
        if(L.data[i]==x) {
            k++;
        } 
        else{
            L.data[i-k]=L.data[i];
        } 
        i++; 
    }
    L.length=L,length-k;
} 

04 从有序顺序表中删除其值在给定值s与t 之间(要求s<t)的所有元素,若s或T不合理活顺序表为空,则显示出错误信息并退出运行。

思路：有序顺序表说明数据元素是有序排列的，属于s-t范围的数据元素在一片区域内，可以先找到小于s的元素个数i，再找到小于等于t元素个数j，依次移动，将位置j的元素赋给i位置j的元素。

算法代码：

bool deletescope(SqList &L,ElemType s,ElemType t) {
    int i=0;
    int j=0; 
    if(s>t||L.length==0) 
        return false; 
    while(L.data[i]<s) 
        i++;
    while(L.data[j]<=t) 
        j++ ;
    for(;j<L.length;i++,j++) {
        L.data[i]=L.data[j] ;
    }
    L.length=i;
    return true; 
}

 运行代码：

#include<iostream>
#include<string>
#define Max 50    //表长度的初始定义 
using namespace std;
//定义一个 顺序表
struct SqList {
	int data[Max]= {1,2,3,4,5,6,7,8};
	int length=8;
};
bool deletescope(SqList &L,int s,int t) {
	int i=0;
	int j=0; 
	if(s>t||L.length==0) 
		return false; 
	while(L.data[i]<s) 
		i++;
	while(L.data[j]<=t) 
		j++ ;
	for(;j<L.length;i++,j++) {
		L.data[i]=L.data[j] ;
	}
	L.length=i;
	return true; 
}
int main() {
	SqList s;	//定义顺序表s
	int value=0;
	cout<<"删除前的顺序表为:"<<endl;
	for(int i=0; i<s.length; i++) {
		cout<<s.data[i]<<" ";
	}
	cout<<endl;
	deletescope(s,2,5) ;
	cout<<"删除后的顺序表为:"<<endl;
	for(int i=0; i<s.length; i++) {
		cout<<s.data[i]<<" ";
	}
	return 0;
}

运行结果：

05 从顺序表中删除其值在给定值s与t 之间(包含s和t，要求s<t)的所有元素,若s或t不合理活顺序表为空,则显示出错误信息并退出运行。

思路：循环遍历顺序表，用k计数在s到t范围的元素的数据元素个数，若属于范围内，则k+1，若不属于该范围内，则向前移动k个位置。最后顺序表的长度减少k。

算法代码：

bool deletescope2(SqList &L,ElemType s,ElemType t) {

    int k=0; 
    if(s>=t||L.length==0) 
        return false; 
    for(int i=0;i<L.length;i++) {
        if(L.data[i]>=s&&L.data[i]<=t) 
            k++; 
        else
            L.data[i-k]=L.data[i]; 
    }
    L.length=L.length-k;
    return true; 
}

运行代码：

#include<iostream>
#include<string>
#define Max 50    //表长度的初始定义 
using namespace std;
//定义一个 顺序表
struct SqList {
	int data[Max]= {1,2,3,4,5,6,7,8};
	int length=8;
};
bool deletescope2(SqList &L,int s,int t) {
	if(s>t||L.length==0) 
		return false; 
	int k=0; 
	for(int i=0;i<L.length;i++) {
		if(L.data[i]>=s&&L.data[i]<=t) 
			k++; 
		else
			L.data[i-k]=L.data[i]; 
	}
	L.length=L.length-k;
	return true; 
}
int main() {
	SqList s;	//定义顺序表s
	int value=0;
	cout<<"删除前的顺序表为:"<<endl;
	for(int i=0; i<s.length; i++) {
		cout<<s.data[i]<<" ";
	}
	cout<<endl;
	deletescope2(s,2,5) ;
	cout<<"删除后的顺序表为:"<<endl;
	for(int i=0; i<s.length; i++) {
		cout<<s.data[i]<<" ";
	}
	return 0;
}

 运行结果：

06 从有序顺序表中删除所有其值重复的元素，使表中所有元素的值不同。

思路1：循环遍历顺序表，若当前元素与下一元素相等，则计数k+1，若不相等，则向前移动k个元素，最后k记录了重复元素的重复次数，顺序表长度减去k。

算法代码：

bool deletesame(SqList &L) {
    int k=0;

    if(L.length==0)

        return false;
    for(int i=0; i<L.length; i++) {
        if(L.data[i]==L.data[i+1])
            k++;
        else
            L.data[i-k]=L.data[i];
    }
    L.length=L.length-k;

    return true;
}

运行代码：

 

#include<iostream>
#include<string>
#define Max 50    //表长度的初始定义 
using namespace std;
//定义一个 顺序表
struct SqList {
	int data[Max]= {1,2,2,3,3,3,4,4};
	int length=8;
};
void deletesame(SqList &L) {
	int k=0;
	for(int i=0; i<L.length; i++) {
		if(L.data[i]==L.data[i+1])
			k++;
		else
			L.data[i-k]=L.data[i];
	}
	L.length=L.length-k;
}
int main() {
	SqList s;	//定义顺序表s
	int value=0;
	cout<<"删除前的顺序表为:"<<endl;
	for(int i=0; i<s.length; i++) {
		cout<<s.data[i]<<" ";
	}
	cout<<endl;
	deletesame(s) ;
	cout<<"删除后的顺序表为:"<<endl;
	for(int i=0; i<s.length; i++) {
		cout<<s.data[i]<<" ";
	}
	return 0;
}

运行结果：

 

 思路2：第一个元素无论与后面元素是否重复，都不会被删除。比较后面的元素与第一个元素是否相等，若相等，继续判断，若不想等，将其插入第一个元素后面。一直向后判断，比较后面的元素与前面不重复的最后一个元素是否相等。

算法代码：

bool deletesame(SqList &L) {
    int i,j;

    if(L.length==0)

        return false;
    for(i=0,j=1; j<L.length; j++) {
        if(L.data[i]!=L.data[j])
            L.data[++i]=L.data[j];
    }
    L.length=i+1;

    return true;
}

07 将两个有序顺序表合并为一个新的有序顺序表，并由函数返回结果顺序表。

思路：比较A,B两个顺序表中的元素，将较小的头结点放入新的顺序表C中。当其中一个全部放入时，另外一个可将剩余部分全部放入C的后面。

算法代码：

bool merge(SqList A,SqList B,SqList &C) {
    if(A.length+B.length>C.maxSize)
        return false;
    int i=0;
    int j=0;
    int k=0;
    while(i<A.length&&j<B.length) { //当其中一个表先遍历结束,就跳出循环
        if(A.data[i]<=B.data[j]) 
            C.data[k++]=A.data[i++];  //输入的时候,直接就是0,不用看后面循环+1的,先执行一遍,再加1

         else 
            C.data[k++]=B.data[j++];
    }
    while(i<A.length)
        C.data[k++]=A.data[i++];
    while(j<B.length)
        C.data[k++]=B.data[j++];
    C.length=k;
    return true;
}

  运行代码：

#include<iostream>
#include<string>
#define Max 50    //表长度的初始定义 
using namespace std;
//定义一个 顺序表
struct SqList {
	int data[Max];
	int length;
};
bool merge(SqList A,SqList B,SqList &C) {
	if(A.length+B.length>C.length)
		return false;
	int i=0;
	int j=0;
	int k=0;
	while(i<A.length&&j<B.length) { //当其中一个表先遍历结束,就跳出循环
		if(A.data[i]<=B.data[j]) 
			C.data[k++]=A.data[i++];
		 else 
			C.data[k++]=B.data[j++];
	}
	while(i<A.length)
		C.data[k++]=A.data[i++];
	while(j<B.length)
		C.data[k++]=B.data[j++];
	C.length=k;
	return true;
}

int main() {
	SqList A= {{2,3,4,6,7},5};
	SqList B= {{3,4,4},3};;	//定义顺序表s
	SqList C;
	C.length=8;
	cout<<"合并前的顺序表为:"<<endl;
	for(int i=0; i<A.length; i++) {
		cout<<A.data[i]<<" ";
	}
	cout<<endl;
	for(int i=0; i<B.length; i++) {
		cout<<B.data[i]<<" ";
	}
	cout<<endl;
	merge(A,B,C);
	cout<<"合并后的顺序表为:"<<endl;
	for(int i=0; i<C.length; i++) {
		cout<<C.data[i]<<" ";
	}
	return 0;
}

运行结果：

 08 已知在一维数组A[m+n]中依次存放两个线性表(a1,a2,......am)和(b1,b2,......bn)。编写一个函数，将数组中两个顺序表的位置互换，即将(b1,b2,......bn)放在(a1,a2,......am)前面。

思路:首先将整个顺序表逆置，然后分别对0-n-1和n-m+n-1分别逆置。

算法代码：

void reverse(SqList &L,ElemType left,ElemType right) {
    int key=0;
    int mid=(left+right)/2;
    for(int i=0; i<=mid-left; i++) {
        key=L.data[left+i];
        L.data[left+i]=L.data[right-i];
        L.data[right-i]=key;
    }
}
void exchange(SqList &L,ElemType m,ElemType n){
    reverse(L,0,m+n-1);
    reverse(L,0,m-1);
    reverse(L,n,m+n-1);
}

运行代码：

#include<iostream>
#include<string>
#define Max 50    //表长度的初始定义 
using namespace std;
//定义一个 顺序表
struct SqList {
	int data[Max]={1,2,3,4,5,6,7,8};
	int length=8;
};
void reverse(SqList &L,int left,int right) {
	int key=0;
	int mid=(left+right)/2;
	for(int i=0; i<=mid-left; i++) {
		key=L.data[left+i];
		L.data[left+i]=L.data[right-i];
		L.data[right-i]=key;
	}
}
void exchange(SqList &L,int m,int n){
	reverse(L,0,m+n-1);
	reverse(L,0,m-1);
	reverse(L,n,m+n-1);
}
int main() {
	SqList s;
	cout<<"逆置前的顺序表为:"<<endl;
	for(int i=0; i<s.length; i++) {
		cout<<s.data[i]<<" ";
	}
	cout<<endl;
	exchange(s,4,4);
	cout<<"逆置后的顺序表为:"<<endl;
	for(int i=0; i<s.length; i++) {
		cout<<s.data[i]<<" ";
	}
	return 0;
}

运行结果：

 

m0_58181187
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构：顺序表的基本用法
study_jiang_up的博客
11-16 1050
线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表（存储层次上属于链式存储，但是把最后一个数据元素的尾指针指向了首位结点）。
顺序表习题2.6
LH_1999的博客
07-22 457
第二章：顺序表P19 6.从有序顺序表中删除所有其值重复的元素，使表中所有的元素值不同。 思想：初始时将第一个元素视为非重复的有序表。之后依次判断后面的元素是否与前面非重复有序表的最后一个元素相同，若相同则继续往后判断找不同的，若不同则插再新的非重复有序表的后面，直至判断到表尾为止。 #include<iostream> using namespace std; #define MaxSize 100 #define N 11 typedef struct{ int *data;
408数据结构学习笔记——顺序表
JiangNan_1002的博客
03-16 2032
1.线性表的定义 2.线性表的基本操作 3.线性表的顺序存储表示 4.顺序表 5.王道课后题
顺序表的删除
qq_54725361的博客
07-29 453
顺序表删除第 i 位元素 //注意Length是从1 开始 //而数组下标即data 是从0 开始 #include<iostream> using namespace std; #define MaxSize 10 //默认最大长度 typedef struct { int data[MaxSize]; int Length; //当前表长 }SeqList; void InitList(SeqList& L) { L.Length = 6; for (int i =.
顺序表删除相关题(一)-----考研数据结构题笔记
王先生的蒋小姐的博客
03-03 458
记录自己备考数据结构与算法考研真题中的算法题例！！！
数据结构 第2章 线性表（课后习题程序实现）.rar
09-28
数据结构 第2章 线性表（课后习题程序实现）.rar 数据结构 第2章 线性表（课后习题程序实现）.rar 数据结构 第2章 线性表（课后习题程序实现）.rar 数据结构 第2章 线性表（课后习题程序实现）.rar 数据结构 第2章 ...
第2章++线性表+课后习题答案.pdf
09-30
第2章++线性表+课后习题答案.pdf
【数据结构王道2023课后练习题】线性表
07-31
【数据结构王道2023课后练习题】线性表C源码
数据结构---C语言描述-(耿国华)-高等教育出版社出版-课后习题答案
04-21
数据结构---C语言描述-(耿国华)-高等教育出版社出版-课后习题答案 数据结构是计算机科学中一个基础课题，涉及到数据的存储、操作和管理。数据结构可以分为线性结构、树形结构、图状结构等多种类型，每种结构都有其...
第二章线性表课后习题.pptx
05-25
线性表知识点总结 本资源总结了线性表的相关知识点，涵盖了顺序表和链表的概念、特点、优缺点、操作等方面。 顺序表 顺序表是一种线性表结构，元素在物理存储器中的存储是连续的，每个元素占用固定长度的存储空间...
我的线性表笔记
gong_zc的博客
05-15 212
我的个人笔记关于线性表的部分应用心得
数据结构--线性表
知足且上进，温柔而坚定
08-22 381
1 . 顺序表 2 . 单链表（不带头结点） 3 . 单链表（带头结点） 4 . 双链表 5 . 循环单链表（L指向表头结点） 6 . 循环单链表（L指向表尾结点） 7 . 循环双链表 8 . 静态链表
数据结构——线性表顺序存储
qq_43718691的博客
05-06 697
线性表（Linear List）:由同类型数据元素构成有序序列的线性结构 表中元素个数称为线性表的长度，线性表没有元素时称为空表，表起始位置称为表头，表结束位置称表尾 线性表的抽象数据类型描述 类型名称：线性表（list） 数据 对象集：线性表时n（>=0）个元素构成的有序序列（a1,a2,....an） 操作集：线性表L属于LIST，整数i表示位置，元素X属于ElemetTYpe,线性表基本炒作主要有：、 1、List MakeEmpty():初始化一个空线性表L； 2、Ele...
指针与数组（4.29）
安静的美男子
04-30 690
一 C语言一级指针变量与一维数组   int data[5]; int *p;   p = data;   p[i] data[i] *(p + i) *(data + i)   注意:指针变量在保存了数组的首地址后，可以当作数组名来使用，不同的地方在于指针变量是一个变量， 可以改变它的值，而数组名是一个地址常量，不能更改它的值。     更深的理解: dat
数据结构——顺序表概念和操作
qq_48811361的博客
06-26 359
数据结构--顺序表
2.2线性表的顺序表示（知识点）
S123KO的博客
06-16 708
2.2.1顺序表的定义 2.2.2顺序表的基本操作 思维导图： 顺序表的定义 静态分配 #define MaxSize 50 //宏定义线性表最大长度为50 typedef struct{ //定义一个结构体 ElemType data{maxSize}; //顺序表的元素，数组 int length; //顺序表当前长度 }SqList; //结构体名 动态分配 #define
从顺序表中删除具有最小值的元素，并由函数返回被删元素的值，空出的位置由最后一个元素填补，若顺序表为空则显示出错信息并退出运行
byuvyh的博客
03-28 1075
//首先定义一个结构体 typedef struct{ int data; //顺序表的元素 int length; //当前顺序表的长度 }Sqlist;顺序表的类型定义又叫重名命 bool delMin(Sqlist &l,int &Min){ if(l.length==0) return false; //设置顺序表的第一个元素为最小 min=l.data[0]; //给他设置一个记录当前最小的值的下标 intpos=0.
数据结构-王道课后题-线性表（1）
Dr.sen的博客
06-30 1198
顺序表 1. 从顺序表中是删除最小元素，并返回该元素的值空出位置由最后一位填充。 bool Delete_min(sqList &L, ElemType &value){ if(L.length<=0){ //表为空，直接返回 return false ; } value=L.data[0]; int...
数据结构_1：线性表： C语言练习题
LandscapeMi
12-25 1861
顺序表删除最小元素，返回被删元素的值，空出来的位置由最后一个一个元素填补。 bool Del_min(SqList *L, ElemType *value) { if(L->length==0) return ERROR; value=L.data[0]; int pos=0; //假定零号最小 for(int i=1;i//循环寻找最小值 if
线性表-顺序存储-删除重复元素
最新发布
03-31
思路：遍历线性表，将不重复的元素依次存放在前面的位置上，记录不重复元素的个数，最后将多余的元素删除。 具体实现： 1. 初始化一个变量count表示不重复元素的个数，初始值为1，因为第一个元素一定不重复。 2. 从下标为1的元素开始遍历线性表，判断当前元素是否与前一个元素相同，如果不同，则将该元素存放在下标为count的位置上，并将count加1。 3. 如果相同，则继续遍历下一个元素。 4. 遍历完整个线性表后，将下标为count及其后面的元素删除，即将线性表的长度设为count。 代码实现： ``` void deleteDuplicate(ElemType A[], int& n) { int count = 1; // 不重复元素的个数 for (int i = 1; i < n; i++) { if (A[i] != A[i-1]) { // 当前元素不重复 A[count++] = A[i]; // 存放在下标为count的位置上，并将count加1 } } n = count; // 将线性表的长度设为count } ``` 时间复杂度：O(n)，其中n为线性表的长度。 空间复杂度：O(1)。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值