c++ 顺序表 (可以用数组来代替）

总结归纳

动态分配对内存有着更大的控制权，但也会花费相应的时间。
顺序表的查找时间复杂度为O(1)，这是单链表所不具备的。
顺序表的插入，要从后往前遍历，因为数据要后移；顺序表的删除，要从前往后遍历，因为数据要前移。

顺序表存储

原理：顺序表存储是将数据元素放到一块连续的内存存储空间，存取效率高，速度快。但是不可以动态增加长度

优点：存取速度高效，通过下标来直接存储

缺点：1.插入和删除比较慢，2.不可以增长长度

比如：插入或者删除一个元素时，整个表需要遍历移动元素来重新排一次顺序

链表存储

原理：链表存储是在程序运行过程中动态的分配空间，只要存储器还有空间，就不会发生存储溢出问题

优点：插入和删除速度快，保留原有的物理顺序，比如：插入或者删除一个元素时，只需要改变指针指向即可

缺点：查找速度慢，因为查找时，需要循环链表访问
从它们的存储优缺点来看，各自有各自的使用场景，比如：频繁的查找却很少的插入和删除操作可以用顺序表存储，如果频繁的插入和删除操作很少的查询就可以使用链表存储

线性顺序表的定义

一种方法是：在静态分配时，由于数组的大小和空间实现已经固定，一旦空间占满，再加入新的数据将产生溢出，就会导致程序崩溃

#define InitSize 5 // 顺序表初始长度, 注意，不能放分号
struct SqList {
   int* data; // 数组
   int MaxSize; // 顺序表的最大长度
   int length; // 顺序表的当前长度
};

另一种方法是：动态分配时，储存数组的空间实在程序执行过程中通过动态存储分配语句分配的，一旦数据空间占满，可以另外开辟一块更大的存储空间，用以替换原来的存储空间，从而达到扩充存储数组空间的目的，而不需要一次性地划分所有所需空间给线性表。

#define InitSize = 100 //表长度的初始定义
typedef struct {
int* data; //只是动态分配数组的指针
int MaxSize, length; //数组的最大容量和当前个数
}SqList;

具体操作

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define InitSize 5 // 顺序表初始长度

using namespace std;

struct SqList {
	int* data; // 数组
	int MaxSize; // 顺序表的最大长度
	int length; // 顺序表的当前长度
};

// 初始化顺序表
void InitList(SqList& L) {
	L.data = new int[InitSize];
	L.MaxSize = InitSize;
	L.length = 0;
}

// 为顺序表中的数据赋值
void AssginList(SqList& L) {
	for (int i = 0; i < InitSize; i++) {
		L.data[i] = i;
		L.length++;
	}
}

// 求表长
int Length(SqList& L) { return L.length; }

// 动态增加顺序表长度
void IncreaseSize(SqList& L, int len) {
	int* p = L.data;
	L.data = new int[L.MaxSize + len];
	for (int i = 0; i < L.length; i++) {
		L.data[i] = p[i]; // 将原数据赋值到新内存中
	}
	L.MaxSize = L.MaxSize + len;
	delete p;
}

// 按位查找：查找第i个位置的元素
int GetElem(SqList& L, int i) {
	return L.data[i - 1];
}

// 按值查找：查找值为i的元素位置
int LocateElem(SqList& L, int i) {
	for (int j = 0; j < L.length; j++) {
		if (L.data[j] == i) {
			return j + 1;
		}
	}
	return 0; // 没有查找到则返回0
}

// 插入：在第i个位置插入e
void ListInsert(SqList& L, int i, int e) {
	if (L.length = L.MaxSize) { // 内存已满需要扩充
		IncreaseSize(L, 1);
	}
	for (int j = L.length; j >= i; j--) {
		L.data[j] = L.data[j - 1]; // 插入位置之后的数据后移
	}
	L.data[i - 1] = e;
	L.length++;
}

// 删除：删除第i个位置的元素
bool ListDelete(SqList& L, int i, int& e) {
	if (i < 0 || i > L.length) { // 删除超出范围
		return false;
	}
	e = L.data[i - 1];
	for (int j = i; j < L.length; j++) {
		L.data[j - 1] = L.data[j]; // 数据前移
	}
	L.data[L.length] = 0; //最后一个元素初始化
	L.length--;
	return true;
}

// 按顺序输出
void PrintList(SqList& L) {
	for (int i = 0; i < L.length; i++) {
		cout << L.data[i] << " ";
	}
	cout << endl;
}

int main() 
{
	struct SqList L;
}

题目：

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

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

using namespace std;

//定义一个顺序表
struct SqlList {
	int* data; // 数组
	int MaxSize; // 顺序表的最大长度
	int length; // 顺序表的当前长度
};

//删除顺序表L中最小值元素结点，并通过引用性参数value返回其值
//如果删除成功，返回true；否则，返回false
bool Min_del(SqlList& L)
{
	if (L.length == 0) return false;//表空的话
	int value = L.data[0];
	int pos = 0;
	for (int i = 1; i < L.length; i++)
	{
		if (L.data[i] < value) value = L.data[i], pos = i;
	}
	L.data[pos] = L.data[L.length - 1]; //空出的位置由最后一个元素填补
		L.length--;//就相当于把最小的那个元素删除了
	return true;
}

void show(SqlList& L)
{
	cout << "lenght:" << L.length << endl;
	for (int i = 0; i < L.length; i++)//利用这个来做遍历
	{
		cout << L.data[i] << " ";
	}
	cout << endl;
}

int main()
{
	SqlList num;
	num.length = 5;
	int a[5] = { 2,5,15,25,65 };
	num.data = a;
	show(num);
	Min_del(num);
	show(num);
	return 0;
}

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

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

using namespace std;

//定义一个顺序表
struct SqlList {
	int* data; // 数组
	int MaxSize; // 顺序表的最大长度
	int length; // 顺序表的当前长度
};

//扫描顺序表L的前半部分元素，对于元素L.data[i](0 < i < L.length / 2), 
//将其与后半部分对应元素L.data[L.length - i - 1]进行交换
bool Reverse_Element(SqlList& L)
{
	int temp;
	for (int i = 0; i < L.length / 2; i++)
	{
		swap(L.data[i], L.data[L.length - 1 - i]);
	}
	return true;
}
void show(SqlList& L)
{
	cout << "lenght:" << L.length << endl;
	for (int i = 0; i < L.length; i++)//利用这个来做遍历
	{
		cout << L.data[i] << " ";
	}
	cout << endl;
}

int main()
{
	SqlList num;
	num.length = 5;
	int a[5] = { 2,5,15,25,65 };
	num.data = a;
	show(num);
	Reverse_Element(num);
	show(num);
	return 0;
}

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

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

using namespace std;

//定义一个顺序表
struct SqlList {
	int* data; // 数组
	int MaxSize; // 顺序表的最大长度
	int length; // 顺序表的当前长度
};

//方法一

//用k记录顺序表L中不等于x的元素个数(即需要保存的元素个数), 
//边扫描L边统计k, 并将不等于x的元素向前移动k个位置，
//最后修改L的长度
void Del_Element1(SqlList& L, int& x)
{
	int k = 0;
	for (int i = 0; i < L.length; i++)
	{
		if (L.data[i] != x)L.data[k] = L.data[i], k++;	
	}
	L.length = k;
}

//方法二
//算法思想2：用k记录顺序L中等于x的元素的个数，
//边扫描L边统计k, 并将不等于x的元素前移k个位置, 
//最后修改L的长度
void Del_Element2(SqlList& L, int& x)
{
	int k = 0;
	for (int i = 0; i < L.length; i++)
	{
		if (L.data[i] == x) k++;
		else L.data[i - k] = L.data[i];
	}
	L.length = L.length - k;
}
void show(SqlList& L)
{
	cout << "lenght:" << L.length << endl;
	for (int i = 0; i < L.length; i++)//利用这个来做遍历
	{
		cout << L.data[i] << " ";
	}
	cout << endl;
}

int main()
{
	SqlList num;
	int c,d;
	scanf("%d", &c);
	num.length = 5;
	int a[5] = { 2,5,15,25,65 };
	num.data = a;
	show(num);
	Del_Element2(num, c);
	show(num);
	scanf("%d", &d);
	Del_Element1(num, d);
	show(num);
	return 0;
}

4. 从有序顺序表中删除其值在给定值s和t之间（要求s < t）的所有元素，如果s或t不合理或者顺序表为空则显示出错信息并退出运行。

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

using namespace std;

#define InitialSize = 5;// 这是赋值
typedef struct SqlList
{
	int * data;
	int MaxSize, length;
};

void fun(SqlList&L, int &s, int &t)
{
	int i = 0, n1 = 0, n2 = 0;
	while (L.data[i++] <= s);
	n1 = i - 1;//第一个大于s的数的位置 
	while (L.data[i++] < t);
	n2 = i - 2;//最后一个小于t的数的位置 
	int len = n2 - n1 + 1;
	i--;
	while (i < L.length)
		L.data[i - len] = L.data[i++];
	L.length -= len;
}

void show(SqlList &L)
{
	cout << "lenght:" << L.length << endl;
	for (int i = 0; i < L.length; i++)//利用这个来做遍历
	{
		cout << L.data[i] << " ";
	}
	cout << endl;
}

int main() 
{
	SqlList Num;
	int s, t;
	scanf("%d %d", &s, &t);
	Num.length = 10;
	int a[10] = { 2,5,6,7,8,9,12,14,15,16 };//注意这两个地方的写法
	Num.data = a;//注意这两个地方的写法
	show(Num);
	fun(Num, s, t);
	show(Num);
	return 0;
}

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

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

using namespace std;

//定义一个顺序表
struct SqlList {
	int* data; // 数组
	int MaxSize; // 顺序表的最大长度
	int length; // 顺序表的当前长度
};

//因为已经是一个有序的顺序表了，所以相同的数值肯定都是挨着的，所以一次循环就能搞定 
//比如 3，4，5，5，7，8 
//不停的往前移动
bool Del_Duplication(SqlList& L)
{
	if (L.length == 0) return false;
	else
	{
		int i = 0;
		for (int j = 1; j < L.length; j++)
		{
			if (L.data[j] != L.data[i]) L.data[++i] = L.data[j];
		}
		L.length = i + 1;//把后面没用的元素通过这种方式就删掉了
	}
	return true;
}

void show(SqlList& L)
{
	cout << "lenght:" << L.length << endl;
	for (int i = 0; i < L.length; i++)//利用这个来做遍历
	{
		cout << L.data[i] << " ";
	}
	cout << endl;
}


int main()
{
	SqlList num;
	num.length = 7;
	int a[7] = { 2,5,15,15,25,25,65 };
	num.data = a;
	show(num);
	Del_Duplication(num);
	show(num);
	return 0;
}

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

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

using namespace std;

//定义一个顺序表
struct SqlList {
	int* data; // 数组
	int MaxSize; // 顺序表的最大长度
	int length; // 顺序表的当前长度
};

//不停的往前移动
//i++表示先返回再加1,++i表示先加1再返回
bool Merge_Sql(SqlList& A, SqlList& B, SqlList& C)
{
	if (A.length + B.length > C.MaxSize) return false;//保证有足够的空间
	else
	{
		int i = 0, j = 0, k = 0;
		while (i < A.length && j < B.length)
		{
			if (A.data[i] <= B.data[j]) C.data[k++] = A.data[i++];//先赋值，然后再去i+1;
			else C.data[k++] = B.data[j++];//i++表示先返回再加1,++i表示先加1再返回
		}
		//两个比较完以后，如果A还有剩余的元素
		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;
}

void show(SqlList& L)
{
	cout << "lenght:" << L.length << endl;
	for (int i = 0; i < L.length; i++)//利用这个来做遍历
	{
		cout << L.data[i] << " ";
	}
	cout << endl;
}


int main()
{
	SqlList num1, num2, num3;
	num1.length = 7, num2.length = 10;
	num3.MaxSize = 20;
	num3.length = 10;
	int a[7] = { 2,5,15,15,25,25,65 };
	int b[10] = { 1,3,4,6,7,8,9,10,11,12 };
	num1.data = a;
	num2.data = b;
	int c[20] = {};
	num3.data = c;//指针要指向一个地址
	Merge_Sql(num1, num2, num3);
	show(num3);
	return 0;
}

7. 已知在一维数组A[m+n]中一次存放着两个线性表（a1,a2,a3,…,am）和（b1,b2,b3,…,bn）。试编写一个函数，将数组中两个顺序表的位置互换，即将（b1,b2,b3,…,bn）放在（a1,a2,a3,…,am）的前面。

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

using namespace std;

//定义一个顺序表
struct SqlList {
	int* data; // 数组
	int MaxSize; // 顺序表的最大长度
	int length; // 顺序表的当前长度
};

bool Reverse(SqlList& L, int left, int right, int ArraySize)
{
	if (left >= right || right >= ArraySize) return false;
	else
	{
		int mid = (left + right) / 2;
		for (int i = 0; i <= mid - left; i++) {
			int temp = L.data[left + i];
			L.data[left + i] = L.data[right - i];
			L.data[right - i] = temp;
		}
		return true;
	}
}

//数组A[m+n]中，从0到m-1存放顺序表(a1,a2,a3,...,am)，
//从m到m + n - 1存放顺序表(b1, b2, b3, ..., bn)，算法将这两个表的位置互换
void exchange(SqlList& L, int n, int m, int ArraySize)
{
	Reverse(L, 0, m + n - 1, ArraySize);//(a1, a2, a3, …, am, b1, b2, b3, …, bn)逆置为(bn, …, b3, b2, b1, am, …, a3, a2, a1),
	Reverse(L, 0, n - 1, ArraySize);//再逆置(bn, …, b3, b2, b1)
	Reverse(L, n, m + n - 1, ArraySize); //再逆置(am, …, a3, a2, a1)
}

void show(SqlList& L)
{
	cout << "lenght:" << L.length << endl;
	for (int i = 0; i < L.length; i++)//利用这个来做遍历
	{
		cout << L.data[i] << " ";
	}
	cout << endl;
}


int main()
{
	SqlList num1;
	num1.length = 17;
	int a[17] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 15, 15, 25, 25, 65 };
	num1.data = a;
	exchange(num1, 5, 12, 17);
	show(num1);
	return 0;
}

8. 线性表（a1,a2,a3,…,an）中元素递增有序且按顺序存储于计算机内。要求设计一算法完成用最少时间在表中查找数值为x的元素，若找到将其与后继元素位置相交换，若找不到将其插入表中并使表中元素扔递增有序。

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

using namespace std;

//定义一个顺序表
struct SqlList {
	int* data; // 数组
	int MaxSize; // 顺序表的最大长度
	int length; // 顺序表的当前长度
};

void SearchExchangeInsert(SqlList& L, int& x , int& n) {
	int low = 0, high = n - 1, mid;                   //low和high指向顺序表下界和上界的下标 
	while (low <= high) {
		mid = (low + high) / 2;                     //找中间位置 
		if (L.data[mid] == x) break;                  //找到x，退出while循环 
		else if (L.data[mid] < x) low = mid + 1;          //到中点mid的右半部去查 
		else high = mid - 1;                      //到中点mid的左半部去查 
	}                                        //下面两个if语句只会执行一个
	if (L.data[mid] == x && mid != n - 1) {               //若最后一个元素与x相等，则不存在与其后继交换的操作 
		swap (L.data[mid], L.data[mid + 1]);
	}
	if (low > high) { 
		int i;//查找失败，插入数据元素x 
		for (i = n - 1; i > high; i--) L.data[i + 1] = L.data[i];   //后移元素 
		L.data[i + 1] = x;                            //插入x 
		L.length++;
	}
}

void show(SqlList& L)
{
	cout << "lenght:" << L.length << endl;
	for (int i = 0; i < L.length; i++)//利用这个来做遍历
	{
		cout << L.data[i] << " ";
	}
	cout << endl;
}

int main()
{
	SqlList num1;
	num1.length = 17;
	int a[20] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 25, 26,65,0,0,0 };
	num1.data = a;
	int x;
	scanf("%d", &x);
	SearchExchangeInsert(num1, x, num1.length);
	show(num1);
	return 0;
}

9. 设将n（n>1）个整数存放到一维数组R中，试设计一个在时间和空间两方面都尽可能高效的算法。将R中保存的序列循环左移p(0 < p < n)个位置，即将R中的数据由(X0,X1,…,Xn-1`)变换为(Xp,Xp+1,…,Xn-1,X0,X1,…,Xp-1)。要求：
1）给出算法的基本设计思想
2）根据设计思想，采用C或++或Java语言描述算法，关键之处给出注释。
3）说明你所设计算法的时间复杂度和空间复杂度

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

using namespace std;

//定义一个顺序表
struct SqlList {
	int* data; // 数组
	int MaxSize; // 顺序表的最大长度
	int length; // 顺序表的当前长度
};

void Reverse(SqlList& L, int left, int right)
{
	int mid = (left + right) / 2;
	for (int i = 0; i <= mid - left; i++) swap(L.data[left + i], L.data[right - i]);
}

void Resequence(SqlList& L, int p, int n)
{
	Reverse(L, 0, p - 1);
	Reverse(L, p, n - 1);
	Reverse(L, 0, n - 1);
}

//上诉算法中三个Reverse函数的时间复杂度分别为O(p/2)、O((n-p)/2)、O(n/2),
//故所设计的算法的时间复杂度为O(n),空间复杂度为O(1).
//Reverse(L, 0, p - 1);得到cbadefgh;
//Reverse(L, p, n - 1);得到cbahgfed;
//Reverse(L, 0, n - 1);得到defghabc;

void show(SqlList& L)
{
	cout << "lenght:" << L.length << endl;
	for (int i = 0; i < L.length; i++)//利用这个来做遍历
	{
		cout << L.data[i] << " ";
	}
	cout << endl;
}

int main()
{
	SqlList num1;
	num1.length = 17;
	int a[20] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 25, 26,65,0,0,0 };
	num1.data = a;
	Resequence(num1, 3, 17);
	show(num1);
	return 0;
}

10. 一个长度为L(L≥1)的升序序列S，处在第[L/2]个位置的数称为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或++或Java语言描述算法，关键之处给出注释。
3）说明你所设计算法的时间复杂度和空间复杂度

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

using namespace std;

//定义一个顺序表
struct SqlList {
	int* data; // 数组
	int MaxSize; // 顺序表的最大长度
	int length; // 顺序表的当前长度
};

int Find_middlenumber(int A[], int B[], int n) {
	int s1 = 0, d1 = n - 1, m1, s2 = 0, d2 = n - 1, m2;   //分别表示序列A和B首位数、末位数、中位数
	while (s1 != d1 || s2 != d2) {
		m1 = (s1 + d1) / 2;
		m2 = (s2 + d2) / 2;
		if (A[m1] == B[m2])
			return A[m1];                //满足条件1 
		if (A[m1] < B[m2]) {                 //满足条件2 
			if ((s1 + d1) % 2 == 0) {            //若元素个数为奇数 
				s1 = m1;                   //舍弃A中间点以前的部分且保留中间点 
				d2 = m2;					 //舍弃B中间点以后的部分且保留中间点 
			}
			else {            			 //元素个数为偶数 
				s1 = m1 + 1;                 //舍弃A中间点及中间点以前部分 
				d2 = m2;					 //舍弃B中间点以后的部分且保留中间点 
			}
		}
		else {                            //满足条件3 
			if ((s2 + d2) % 2 == 0) {            //若元素个数为奇数 
				d1 = m1;                   //舍弃A中间点以后的部分且保留中间点 
				s2 = m2; 				     //舍弃B中间点以前的部分且保留中间点 
			}
			else {            			 //元素个数为偶数 
				d1 = m1;					 //舍弃A中间点以后的部分且保留中间点 
				s2 = m2 + 1;				 //舍弃B中间点及中间点以前部分 
			}
		}
	}
	return A[s1] < B[s2] ? A[s1] : B[s2];
}

//就是逐渐往中间挤，直到筛选出最后一个数值
//算法的时间复杂度为O(log2n),空间复杂度为O(1)

void show(SqlList& L)
{
	cout << "lenght:" << L.length << endl;
	for (int i = 0; i < L.length; i++)//利用这个来做遍历
	{
		cout << L.data[i] << " ";
	}
	cout << endl;
}

int main()
{
	SqlList num1, num2;
	num1.length = 5;
	int a[5] = { 11,13,15,17,19 }, b[5] = { 2,4,6,8,20 };
	num1.data = a, num2.data = b;
	printf("%dn", Find_middlenumber(num1.data, num2.data, 5));
	return 0;
}

11.已知一个整数序列A=(a0,a1,…,an-1)，其中0≤ai≤n(0 ≤ i< n)。若存在ap1=ap2=…=apm=x且m > n / 2 ( 0 ≤ pk < n,1 ≤ k ≤ m),则称x为A的主元素。例如A=(0,5,5,3,5,7,5,5)，则5为主元素；又如A=(0,5,5,3,5,1,5,7)，则A中没有主元素。假设A中的n个元素保存在一个一维数组中，请设计一个尽可能高效的算法，找出A的主元素。若存在主元素，则输出该元素；否则输出-1。要求：
1）给出算法的基本设计思想
2）根据设计思想，采用C或++或Java语言描述算法，关键之处给出注释。
3）说明你所设计算法的时间复杂度和空间复杂度

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

using namespace std;

//定义一个顺序表
struct SqlList {
	int* data; // 数组
	int MaxSize; // 顺序表的最大长度
	int length; // 顺序表的当前长度
};

int Majority(SqlList& L, int n) {
    int i, c, count = 1;            //c用来保存候选主元素，count用来计数
    c = L.data[0];                   //设置A[0]位候选主元素
    for (i = 1; i < n; i++)            //查找候选主元素
        if (L.data[i] == c)
            count++;            //对A中的候选主元素计数
        else
            if (count > 0)         //处理不是候选主元素的情况
                count--;
            else {               //更换候选主元素，重新计数
                c = L.data[i];
                count = 1;
            }
    if (count > 0)
        for (i = count = 0; i < n; i++)  //统计候选主元素的实际出险次数
            if (L.data[i] == c)
                count++;
    if (count > n / 2) return c;     //确认候选主元素
    else return -1;             //不存在主元素
}

//就是逐渐往中间挤，直到筛选出最后一个数值
//算法的时间复杂度为O(log2n),空间复杂度为O(1)

void show(SqlList& L)
{
	cout << "lenght:" << L.length << endl;
	for (int i = 0; i < L.length; i++)//利用这个来做遍历
	{
		cout << L.data[i] << " ";
	}
	cout << endl;
}

int main()
{
	SqlList num1;
	num1.length = 8;
	int a[8] = { 0,5,5,3,5,7,5,5 };
    num1.data = a;
    printf("%dn",Majority(num1, num1.length));
	return 0;
}

c++ 顺序表 (可以用数组来代替）

C/C++/C#相关栏目本月热门文章