王道数据结构顺序表大题练习

顺序表

#include<iostream>
#include<string>
#include<iomanip>
#include<stdlib.h>
using namespace std;

typedef struct LNode {
	int data; //结点的数据域
	struct LNode *next; //结点的指针域
}LNode, *LinkList; //LinkList为指向结构体LNode的指针类型

bool InitList_L(LinkList &L)//构造一个空的单链表L
{
    L=new LNode;     //生成新结点作为头结点，用头指针L指向头结点
	if(!L)
      return false;  //生成结点失败
	L->next=NULL;   //头结点的指针域置空
	return true;
}

void CreateList_H(LinkList &L)//前插法创建单链表
{
	//输入n个元素的值，建立到头结点的单链表L
	int n;
	LinkList s; //定义一个指针变量
	L=new LNode;
	L->next=NULL; //先建立一个带头结点的空链表
	cout <<"请输入元素个数n：" <<endl;
	cin>>n;
	cout <<"请依次输入n个元素：" <<endl;
	cout <<"前插法创建单链表..." <<endl;
	while(n--)
    {
		s=new LNode; //生成新结点s
		cin>>s->data; //输入元素值赋给新结点的数据域
		s->next=L->next;
		L->next=s; //将新结点s插入到头结点之后
	}
}

void CreateList_R(LinkList &L)//尾插法创建单链表
{
	//输入n个元素的值，建立带表头结点的单链表L
	int n;
	LinkList s, r;
	L=new LNode;
	L->next=NULL; //先建立一个带头结点的空链表
	r=L; //尾指针r指向头结点
	cout <<"请输入元素个数n：" <<endl;
	cin>>n;
	cout <<"请依次输入n个元素：" <<endl;
	cout <<"尾插法创建单链表..." <<endl;
	while(n--)
    {
		s=new LNode;//生成新结点
		cin>>s->data; //输入元素值赋给新结点的数据域
		s->next=NULL;
		r->next=s;//将新结点s插入尾结点*r之后
		r=s;//r指向新的尾结点s
	}
}

bool GetElem_L(LinkList L, int i, int &e)//单链表的取值
{
	//在带头结点的单链表L中查找第i个元素
	//用e记录L中第i个数据元素的值
	int j;
	LinkList p;
	p=L->next;//p指向第一个结点，
	j=1; //j为计数器
	while (j<i && p) //顺链域向后扫描，直到p指向第i个元素或p为空
    {
		p=p->next; //p指向下一个结点
		j++; //计数器j相应加1
	}
	if (!p || j>i)
		return false; //i值不合法i＞n或i<=0
	e=p->data; //取第i个结点的数据域
	return true;
}

bool LocateElem_L(LinkList L, int e) //按值查找
{
	//在带头结点的单链表L中查找值为e的元素
	LinkList p;
	p=L->next;
	while (p && p->data!=e)//顺链域向后扫描，直到p为空或p所指结点的数据域等于e
		p=p->next; //p指向下一个结点
	if(!p)
        return false; //查找失败p为NULL
    return true;
}

bool ListInsert_L(LinkList &L, int i, int e)//单链表的插入
{
	//在带头结点的单链表L中第i个位置插入值为e的新结点
	int j;
	LinkList p, s;
	p=L;
	j=0;
	while (p&&j<i-1) //查找第i-1个结点，p指向该结点
    {
		p=p->next;
		j++;
	}
	if (!p || j>i-1)//i＞n+1或者i＜1
		return false;
	s=new LNode;     //生成新结点
	s->data=e;       //将新结点的数据域置为e
	s->next=p->next; //将新结点的指针域指向结点ai
	p->next=s;       //将结点p的指针域指向结点s
	return true;
}

bool ListDelete_L(LinkList &L, int i) //单链表的删除
{
	//在带头结点的单链表L中，删除第i个位置
	LinkList p, q;
	int j;
	p=L;
	j=0;
	while((p->next)&&(j<i-1)) //查找第i-1个结点，p指向该结点
	{
		p=p->next;
		j++;
	}
	if (!(p->next)||(j>i-1))//当i>n或i<1时，删除位置不合理
		return false;
	q=p->next;        //临时保存被删结点的地址以备释放空间
	p->next=q->next; //改变删除结点前驱结点的指针域
	delete q;        //释放被删除结点的空间
	return true;
}

void Listprint_L(LinkList L) //单链表的输出
{
    LinkList p;
    p=L->next;
    while (p)
    {
        cout<<p->data<<"\t";
		p=p->next;
    }
    cout<<endl;
}

int main()
{
	int i,x,e,choose;
	LinkList L;
	cout << "1. 初始化\n";
	cout << "2. 创建单链表（前插法）\n";
	cout << "3. 创建单链表（尾插法）\n";
	cout << "4. 取值\n";
	cout << "5. 查找\n";
	cout << "6. 插入\n";
	cout << "7. 删除\n";
	cout << "8. 输出\n";
	cout << "0. 退出\n";
	choose=-1;
	while (choose!=0)
    {
		cout<<"请输入数字选择:";
		cin>>choose;
		switch (choose)
		{
		case 1: //初始化一个空的单链表
			if (InitList_L(L))
				cout << "初始化一个空的单链表!\n";
			break;
		case 2: //创建单链表（前插法）
			CreateList_H(L);
            cout << "前插法创建单链表输出结果:\n";
            Listprint_L(L);
			break;
        case 3: //创建单链表（尾插法）
			CreateList_R(L);
            cout << "尾插法创建单链表输出结果:\n";
            Listprint_L(L);
			break;
		case 4: //单链表的按序号取值
			cout << "请输入一个位置i用来取值:";
			cin >> i;
			if (GetElem_L(L,i,e))
            {
				cout << "查找成功\n";
				cout << "第" << i << "个元素是："<<e<< endl;
			}
			else
				cout << "查找失败\n\n";
			break;
		case 5: //单链表的按值查找
			cout<<"请输入所要查找元素x:";
			cin>>x;
			if (LocateElem_L(L,x))
				cout << "查找成功\n";
			else
				cout << "查找失败! " <<endl;
			break;
		case 6: //单链表的插入
			cout << "请输入插入的位置和元素（用空格隔开）:";
			cin >> i;
			cin >> x;
			if (ListInsert_L(L, i, x))
				cout << "插入成功.\n\n";
			else
				cout << "插入失败!\n\n";
			break;
		case 7: //单链表的删除
			cout<<"请输入所要删除的元素位置i:";
			cin>>i;
			if (ListDelete_L(L, i))
				cout<<"删除成功!\n";
			else
				cout<<"删除失败!\n";
			break;
		case 8: //单链表的输出
			cout << "当前单链表的数据元素分别为:\n";
			Listprint_L(L);
			cout << endl;
			break;
		}
	}
	return 0;
}

顺序表大题1

#include<iostream> 
#include<stdlib.h>
using namespace std;
//顺序表可能达到的最大长度 
#define MAXSIZE 100 
#define Error 0
#define Ok 1
typedef int ElemType;
typedef int Status;

//顺序表的存储结构 
typedef struct {
	//存储空间的基址 
	ElemType *elem;
	//当前长度 
	int length;
}SqList; 

//顺序表初始化
Status InitList(SqList &L){
	//构造一个空的顺序表L 
	//为顺序表分配一个大小为MAXSIZE的数组空间 
	L.elem = new ElemType[MAXSIZE];
	//存储分配失败返回Error 
	if(!L.elem) return Error;
	//空表长度为0 
	L.length=0;
	return Ok;
} 


//顺序表输入
Status inListValue(SqList &L,int n){
	if(n<0||n>MAXSIZE) return Error;
	if(L.length==MAXSIZE) return Error;
	for(int i =0;i<n;i++){
		L.elem[i]=rand();
		L.length++;
	}
	return Ok;
} 

//顺序表输出
void printList(SqList L){
	for(int i=0;i<L.length;i++){
		cout<<L.elem[i]<<" "; 
	}
	cout<<endl;
} 

//删除具有最小值的元素,空的位置由最后一个元素填补 
bool DelMin(SqList &L,int &value){
	if(L.length==0){
		return Error;
	}
	value=L.elem[0];
	int j=0; 
	for(int i=0;i<L.length;i++){
		if(L.elem[i]<value){
			value=L.elem[i];
			j=i; 
		} 
	}
	L.elem[j]=L.elem[L.length-1];
	L.length--;
	return Ok; 	
} 

int main(){
	int n,value;
	cout<<"正在初始化顺序表......"<<endl;
	SqList L;
	InitList(L);
	cout<<"-------顺序表初始化成功--------"<<endl;
	cout<<"-------顺序表随机赋值多少个元素:";
	cin>>n;
	inListValue(L,n);
	cout<<"-------顺序表随机赋值完成--------"<<endl;	
	printList(L);
	cout<<"-------删除具有最小值的元素--------"<<endl; 
	DelMin(L,value);
	cout<<value<<endl; 
	printList(L);

}

顺序表大题2

#include<iostream> 
#include<stdlib.h>
using namespace std;
//顺序表可能达到的最大长度 
#define MAXSIZE 100 
#define Error 0
#define Ok 1
typedef int ElemType;
typedef int Status;

//顺序表的存储结构 
typedef struct {
	//存储空间的基址 
	ElemType *elem;
	//当前长度 
	int length;
}SqList; 

//顺序表初始化
Status InitList(SqList &L){
	//构造一个空的顺序表L 
	//为顺序表分配一个大小为MAXSIZE的数组空间 
	L.elem = new ElemType[MAXSIZE];
	//存储分配失败返回Error 
	if(!L.elem) return Error;
	//空表长度为0 
	L.length=0;
	return Ok;
} 


//顺序表输入
Status inListValue(SqList &L,int n){
	if(n<0||n>MAXSIZE) return Error;
	if(L.length==MAXSIZE) return Error;
	for(int i =0;i<n;i++){
		L.elem[i]=rand();
		L.length++;
	}
	return Ok;
} 

//顺序表输出
void printList(SqList L){
	for(int i=0;i<L.length;i++){
		cout<<L.elem[i]<<" "; 
	}
	cout<<endl;
} 

//顺序表逆置 
void  Reverse(SqList &L){
	for(int i=0;i<L.length/2;i++){
		int temp=L.elem[i];
		L.elem[i]=L.elem[L.length-1-i]; 
		L.elem[L.length-1-i]=temp;
	} 

} 





int main(){
	int n,value;
	cout<<"正在初始化顺序表......"<<endl;
	SqList L;
	InitList(L);
	cout<<"-------顺序表初始化成功--------"<<endl;
	cout<<"-------顺序表随机赋值多少个元素:";
	cin>>n;
	inListValue(L,n);
	cout<<"-------顺序表随机赋值完成--------"<<endl;	
	printList(L);
	Reverse(L);
	cout<<"-------顺序表逆置--------"<<endl;
	printList(L); 


}

顺序表大题3

#include<iostream> 
#include<stdlib.h>
using namespace std;
//顺序表可能达到的最大长度 
#define MAXSIZE 100 
#define Error 0
#define Ok 1
typedef int ElemType;
typedef int Status;

//顺序表的存储结构 
typedef struct {
	//存储空间的基址 
	ElemType *elem;
	//当前长度 
	int length;
}SqList; 

//顺序表初始化
Status InitList(SqList &L){
	//构造一个空的顺序表L 
	//为顺序表分配一个大小为MAXSIZE的数组空间 
	L.elem = new ElemType[MAXSIZE];
	//存储分配失败返回Error 
	if(!L.elem) return Error;
	//空表长度为0 
	L.length=0;
	return Ok;
} 


//顺序表输入
Status inListValue(SqList &L,int n){
	if(n<0||n>MAXSIZE) return Error;
	if(L.length==MAXSIZE) return Error;
	for(int i =0;i<n;i++){
		cin>>L.elem[i]; 
		L.length++;
	}
	return Ok;
} 

//顺序表输出
void printList(SqList L){
	for(int i=0;i<L.length;i++){
		cout<<L.elem[i]<<" "; 
	}
	cout<<endl;
} 
//删除所有值为x的数据元素 
//void DeleValue(SqList &L,int x){
//	for(int i=0;i<L.length;i++){
//		if(L.elem[i]==x){
//			for(int j=i+1;j<L.length;j++){
//				L.elem[j-1]=L.elem[j];
//			}
//			L.length--; 
//			i--;
//		}	
//	}
//}  
void DeleValue(SqList &L,int x){
	int k=0;
	for(int i=0;i<L.length;i++){
		if(L.elem[i]!=x){
			L.elem[k]=L.elem[i]; 
			k++;
		} 
	}
	L.length=k; 
}



 


int main(){
	int n,x;
	cout<<"正在初始化顺序表......"<<endl;
	SqList L;
	InitList(L);
	cout<<"-------顺序表初始化成功--------"<<endl;
	cout<<"-------顺序表随机赋值多少个元素:";
	cin>>n;
	inListValue(L,n);
	cout<<"-------顺序表随机赋值完成--------"<<endl;	
	printList(L);
	cout<<"-------要删除元素的值是:";
	cin>>x;
	DeleValue(L,x);
	cout<<"-------删除结束-------"<<endl;
	printList(L); 
	
} 

顺序表大题4

#include<iostream> 
#include<stdlib.h>
using namespace std;
//顺序表可能达到的最大长度 
#define MAXSIZE 100 
#define Error 0
#define Ok 1
typedef int ElemType;
typedef int Status;

//顺序表的存储结构 
typedef struct {
	//存储空间的基址 
	ElemType *elem;
	//当前长度 
	int length;
}SqList; 

//顺序表初始化
Status InitList(SqList &L){
	//构造一个空的顺序表L 
	//为顺序表分配一个大小为MAXSIZE的数组空间 
	L.elem = new ElemType[MAXSIZE];
	//存储分配失败返回Error 
	if(!L.elem) return Error;
	//空表长度为0 
	L.length=0;
	return Ok;
} 


//顺序表输入
Status inListValue(SqList &L,int n){
	if(n<0||n>MAXSIZE) return Error;
	if(L.length==MAXSIZE) return Error;
	for(int i =0;i<n;i++){
		cin>>L.elem[i]; 
		L.length++;
	}
	return Ok;
} 

//顺序表输出
void printList(SqList L){
	for(int i=0;i<L.length;i++){
		cout<<L.elem[i]<<" "; 
	}
	cout<<endl;
} 
//有序表删除指定范围的值 
bool DeleRange(SqList &L,int s,int t){
	if(s>=t||L.length==0){
		return Error; 
	}
	int i,j; 
	for(i=0;i<L.length&&L.elem[i]<s;i++);
	if(i>=L.length){
		return Error; 
	} 
	for(j=i;j<L.length&&L.elem[j]<=t;j++); 
	for(;j<L.length;i++,j++){
		L.elem[i]=L.elem[j]; 
	}
	L.length=i; 
	return Ok; 
} 

int main(){
	int n;
	cout<<"正在初始化有序顺序表......"<<endl;
	SqList L;
	InitList(L);
	cout<<"-------顺序表初始化成功--------"<<endl;
	cout<<"-------顺序表随机赋值多少个元素:";
	cin>>n;
	inListValue(L,n);
	cout<<"-------顺序表随机赋值完成--------"<<endl;	
	printList(L);
	int s,t;
	cout<<"-------删除指定的范围为:";
	cin>>s; 
	cin>>t; 
	DeleRange(L,s,t);
	cout<<"-------删除完成-------"<<endl; 
	printList(L);
	
	
}

顺序表大题5

#include<iostream> 
#include<stdlib.h>
using namespace std;
//顺序表可能达到的最大长度 
#define MAXSIZE 100 
#define Error 0
#define Ok 1
typedef int ElemType;
typedef int Status;

//顺序表的存储结构 
typedef struct {
	//存储空间的基址 
	ElemType *elem;
	//当前长度 
	int length;
}SqList; 

//顺序表初始化
Status InitList(SqList &L){
	//构造一个空的顺序表L 
	//为顺序表分配一个大小为MAXSIZE的数组空间 
	L.elem = new ElemType[MAXSIZE];
	//存储分配失败返回Error 
	if(!L.elem) return Error;
	//空表长度为0 
	L.length=0;
	return Ok;
} 


//顺序表输入
Status inListValue(SqList &L,int n){
	if(n<0||n>MAXSIZE) return Error;
	if(L.length==MAXSIZE) return Error;
	for(int i =0;i<n;i++){
		cin>>L.elem[i]; 
		L.length++;
	}
	return Ok;
} 

//顺序表输出
void printList(SqList L){
	for(int i=0;i<L.length;i++){
		cout<<L.elem[i]<<" "; 
	}
	cout<<endl;
} 
//顺序表删除指定范围的值 
bool DeleRange(SqList &L,int s,int t){
	if(s>=t||L.length==0){
		return Error; 
	}
	int k=0;
	for(int i=0;i<L.length;i++){
		if(L.elem[i]<s||L.elem[i]>t){
			L.elem[k]=L.elem[i]; 
			k++;
		} 
	} 
	L.length=k; 
	return Ok; 
} 
//bool DeleRange(SqList &L,int s,int t){
//	if(s>=t||L.length==0){
//		return Error; 
//	}
//	int k,i;
//	while(i<L.length){
//		if(L.elem[i]>=s&&L.elem[i]<=t){
//			k++; 
//		}else{
//			L.elem[i-k]=L.elem[i]; 
//		}
//		 
//		i++; 
//	} 
//	L.length=L.length-k; 
//		return Ok; 
//}


int main(){
	int n;
	cout<<"正在初始化顺序表......"<<endl;
	SqList L;
	InitList(L);
	cout<<"-------顺序表初始化成功--------"<<endl;
	cout<<"-------顺序表随机赋值多少个元素:";
	cin>>n;
	inListValue(L,n);
	cout<<"-------顺序表随机赋值完成--------"<<endl;	
	printList(L);
	int s,t;
	cout<<"-------删除指定的范围为:";
	cin>>s; 
	cin>>t; 
	DeleRange(L,s,t);
	cout<<"-------删除完成-------"<<endl; 
	printList(L);
	
}

顺序表大题6

#include<iostream> 
#include<stdlib.h>
using namespace std;
//顺序表可能达到的最大长度 
#define MAXSIZE 100 
#define Error 0
#define Ok 1
typedef int ElemType;
typedef int Status;

//顺序表的存储结构 
typedef struct {
	//存储空间的基址 
	ElemType *elem;
	//当前长度 
	int length;
}SqList; 

//顺序表初始化
Status InitList(SqList &L){
	//构造一个空的顺序表L 
	//为顺序表分配一个大小为MAXSIZE的数组空间 
	L.elem = new ElemType[MAXSIZE];
	//存储分配失败返回Error 
	if(!L.elem) return Error;
	//空表长度为0 
	L.length=0;
	return Ok;
} 


//顺序表输入
Status inListValue(SqList &L,int n){
	if(n<0||n>MAXSIZE) return Error;
	if(L.length==MAXSIZE) return Error;
	for(int i =0;i<n;i++){
		cin>>L.elem[i]; 
		L.length++;
	}
	return Ok;
} 

//顺序表输出
void printList(SqList L){
	for(int i=0;i<L.length;i++){
		cout<<L.elem[i]<<" "; 
	}
	cout<<endl;
} 

//有序顺序表删除值重复的元素
void DeleSame(SqList &L){
	for(int i=0;i<L.length;i++){
		for(int j=i+1;j<L.length;j++){
			if(L.elem[i]==L.elem[j]){
				while(j<L.length){
					L.elem[j-1]=L.elem[j];
					j++; 
				}
				L.length--;
				j--; 
			}
		}
	} 
} 

int main(){
	int n;
	cout<<"正在初始化有序顺序表......"<<endl;
	SqList L;
	InitList(L);
	cout<<"-------顺序表初始化成功--------"<<endl;
	cout<<"-------顺序表随机赋值多少个元素:";
	cin>>n;
	inListValue(L,n);
	cout<<"-------顺序表随机赋值完成--------"<<endl;	
	printList(L);
	cout<<"-------删除值相同的元素-------"<<endl; 
	DeleSame(L);
	printList(L);
	
}
 

顺序表大题7

#include<iostream> 
#include<stdlib.h>
using namespace std;
//顺序表可能达到的最大长度 
#define MAXSIZE 100 
#define Error 0
#define Ok 1
typedef int ElemType;
typedef int Status;

//顺序表的存储结构 
typedef struct {
	//存储空间的基址 
	ElemType *elem;
	//当前长度 
	int length;
}SqList; 

//顺序表初始化
Status InitList(SqList &L){
	//构造一个空的顺序表L 
	//为顺序表分配一个大小为MAXSIZE的数组空间 
	L.elem = new ElemType[MAXSIZE];
	//存储分配失败返回Error 
	if(!L.elem) return Error;
	//空表长度为0 
	L.length=0;
	return Ok;
} 


//顺序表输入
Status inListValue(SqList &L,int n){
	if(n<0||n>MAXSIZE) return Error;
	if(L.length==MAXSIZE) return Error;
	for(int i =0;i<n;i++){
		cin>>L.elem[i]; 
		L.length++;
	}
	return Ok;
} 

//顺序表输出
void printList(SqList L){
	for(int i=0;i<L.length;i++){
		cout<<L.elem[i]<<" "; 
	}
	cout<<endl;
} 

//将两个有序顺序表合并 
void Merge(SqList A,SqList B,SqList &C){
	int i=0,j=0,k=0; 
	while(i<A.length&&j<B.length){
		if(A.elem[i]<=B.elem[j]){
			C.elem[k++]=A.elem[i++];
		}else{
			C.elem[k++]=B.elem[j++];
		}
	}
	while(i<A.length){
		C.elem[k++]=A.elem[i++];
	}
	while(j<B.length){
		C.elem[k++]=B.elem[j++];
	}
	C.length=k;
} 

int main(){
	int a,b;
	cout<<"正在初始化有序顺序表......"<<endl;
	SqList A,B;
	InitList(A);
	InitList(B);
	cout<<"-------顺序表A,B初始化成功--------"<<endl;
	cout<<"-------顺序表A随机赋值多少个元素:";
	cin>>a;
	inListValue(A,a);
	printList(A);
	cout<<"-------顺序表B随机赋值多少个元素:";
	cin>>b;
	inListValue(B,b);
	printList(B);
	SqList C;
	InitList(C);
	cout<<"-------合并两个有序表-------"<<endl; 
	Merge(A,B,C);
	printList(C);
}

顺序表大题8

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define InitSize 100
#include<iostream> 
typedef int ElemType;
using namespace std;

//将数组中的两个顺序表的位置交换 
void Reserve(ElemType A[],int left,int right,int arraySize){
	if(left>=right||right>=arraySize)
		return;
	int mid=(left+right)/2;
	for(int i=0;i<=mid-left;i++){
		ElemType temp=A[left+i];
		A[left+i]=A[right-i];
		A[right-i]=temp;
	}
}
 
void Exchange(ElemType A[],int m,int n,int arraySize){
	Reserve(A,0,m+n-1,arraySize);
	Reserve(A,0,n-1,arraySize);
	Reserve(A,n,m+n-1,arraySize);
}
 
int main(){
	int A[10]={1,2,3,4,5,6,7,8,9,10};
	cout<<"生成前顺序表:";
	for(int m=0;m<10;m++){
		cout<<A[m]<<" ";	
	}
	cout<<endl; 
	Exchange(A,6,4,10);
	cout<<"改变后顺序表:";
	for(int m=0;m<10;m++){
		cout<<A[m]<<" ";	
	}
} 

顺序表大题9

#include<iostream> 
#include<stdlib.h>
using namespace std;
//顺序表可能达到的最大长度 
#define MAXSIZE 100 
#define Error 0
#define Ok 1
typedef int ElemType;
typedef int Status;

//顺序表的存储结构 
typedef struct {
	//存储空间的基址 
	ElemType *elem;
	//当前长度 
	int length;
}SqList; 

//顺序表初始化
Status InitList(SqList &L){
	//构造一个空的顺序表L 
	//为顺序表分配一个大小为MAXSIZE的数组空间 
	L.elem = new ElemType[MAXSIZE];
	//存储分配失败返回Error 
	if(!L.elem) return Error;
	//空表长度为0 
	L.length=0;
	return Ok;
} 


//顺序表输入
Status inListValue(SqList &L,int n){
	if(n<0||n>MAXSIZE) return Error;
	if(L.length==MAXSIZE) return Error;
	for(int i =0;i<n;i++){
		cin>>L.elem[i]; 
		L.length++;
	}
	return Ok;
} 


void SearchExchangeInsert(int A[],int x,int n){
	int low=0; int high=n-1;int mid; 
	while(low<=high){
		mid=(low+high)/2;
		if(A[mid]==x) 
			{
				break;
			}
		else if(A[mid]<x) 
		{
			low=mid+1; 
		}
		else {
			high=mid-1;
		} 
		
	}
	if(A[mid]==x&&mid!=n-1){
		int t=A[mid];
		A[mid]=A[mid+1];
		A[mid+1]=t;
	}
	int i; 
	if(low>high){
		for(i=n-1;i>high;i--){
			A[i+1]=A[i];
		}
		A[i+1]=x; 
		n++;
	}
	for(int m=0;m<n;m++){
		cout<<A[m]<<" ";	
		}
	
} 


int main(){
		int A[10]={1,2,3,6,8,9};
		cout<<"查找之前的数组:";
		for(int m=0;m<6;m++){
		cout<<A[m]<<" ";	
		}
		cout<<endl; 
		cout<<"查找之后的数组:";
		SearchExchangeInsert(A,5,6);
		
		
	}

顺序表大题10

在这里插入代码片

顺序表大题11

在这里插入代码片

顺序表大题12

#include<iostream> 
#include<stdlib.h>
using namespace std;
 
int findMainNum(int A[],int n){
	//c用来保存候选主元素,count用来计数 
	int i,c,count=1; 
	c=A[0];
	for(i=1;i<n;i++){
		if(A[i]==c){
			count++;
		}else{
			if(count>0){
				count--;
			}else{
				c=A[i];
				count=1;
			}
		}
	}
	if(count>0){
		for(i=count=0;i<n;i++){
			if(A[i]==c){
				count++; 
			} 
		}
	}
	if(count>n/2){
		return c; 
	}else{
		return -1; 
	} 
	
} 

int main(){
	int A[8]={0,5,5,3,5,7,5,5};
	int num=findMainNum(A,8);
	cout<<num; 
} 

顺序表大题13

#include<iostream> 
#include<stdlib.h>
using namespace std;

//查找数组中未出现的最小正整数 
int findNum(int A[],int n){
	int B[n+1]={0};
	int i=0,j=0;
	for(i=0;i<n;i++){
		if(A[i]<0){
			B[0]=A[i];	
		}else{
			B[A[i]]=A[i];
		}	 
	}
	//遍历辅助数组B 
	 for(int m=0;m<n+1;m++){
		cout<<B[m]<<" ";	
	}
	cout<<endl; 
	
	for(j=1;j<n+1;j++){
		if(B[j]==0&&j!=n){
			return j;
			}
		}
		return j;
	}	
 

int main(){
	int A[4]={-5,3,2,3};
	int num=findNum(A,3);
	cout<<num; 
} 

顺序表大题14

#include<iostream> 
#include<stdlib.h>
using namespace std;
#define Error 0
#define Ok 1
#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){
	if(a<=b&&a<=c){
		return true; 
	} else{
		return false; 
	} 
} 

int findMinofTrip(int A[],int n,int B[],int m,int C[],int p){
	int i=0,j=0,k=0,D=0,D_min= INT_MAX;
	while(i<n&&j<m&&k<p&&D_min>0){
		D=abs_(A[i]-B[j])+abs_(B[j]-C[k])+abs_(A[i]-C[k]);
		if(D<D_min){
			D_min=D; 
		}
		if(xls_min(A[i],B[j],C[k])){
			i++; 
		}else if(xls_min(B[j],A[i],C[k])){
			j++; 
		}else{
			k++; 
		} 
	}
	return D_min; 
} 

int main(){
	int A[3]={-1,0,9};
	int B[4]={-25,-10,10,11};
	int C[5]={2,9,17,30,41};
	int D_min=findMinofTrip(A,3,B,4,C,5);
	cout<<D_min; 
}