精华内容
下载资源
问答
  • 顺序表的实现

    千次阅读 多人点赞 2019-03-23 21:56:13
    要求编写一个程序,实现顺序表的建立,插入,删除,查找,操作。 效果: 代码: #include<iostream> #define MAXSIZE 10 using namespace std; typedef struct {//顺序表存储结构 int *elem; int ...
    	
    要求编写一个程序,实现顺序表的建立,插入,删除,查找,操作。
    
    效果:
    

    在这里插入图片描述
    代码:

    #include<iostream>
    #include<memory.h>
    
    #define MAXSIZE 10
    using namespace std;
    
    typedef struct {//顺序表存储结构
    	int *elem;
    	int length;
    }SqList;
    
    bool List_Init(SqList &L)
    {//(1)构造一个空线性表
    	L.elem = new int[MAXSIZE];
    	memset(L.elem, 0, sizeof(L));
    	if (!L.elem)
    	{
    		return false;
    	}
    	L.length = 0;//空表长度设置为0
    	return true;
    }
    
    bool List_Insert(SqList &L, int i, int e)
    {//(2)线性表的插入
    	if (i<1 || i>L.length + 1)
    	{//插入位置不合法
    		return false;
    	}
    	if (L.length >= MAXSIZE)
    	{//顺序表空间已满
    		return false;
    	}
    	for (int j = L.length-1;j >= i-1;j--)
    	{
    		L.elem[j+1] = L.elem[j];
    	}
    	L.elem[i - 1] = e;
    	L.length++;
    	return true;
    }
    
    bool GetElem(SqList L, int i, int &e)
    {//(3)取元素
    	if (i<1 || i>L.length)
    	{
    		cout << "访问位置不合法"<<endl;
    		return false;
    	}
    	e = L.elem[i - 1];
    	return true;
    }
    
    bool Delete_List(SqList &L, int i)
    {//(4)删除(根据下标删除)
    	if (i<1 || i>L.length)
    	{
    		cout<<"输入下标不合法"<<endl;
    		return false;
    	}
    	else
    	{
    		for (int j = i;j < L.length;j++)
    		{
    			L.elem[j - 1] = L.elem[j];
    		}
    		L.length--;
    		cout << "删除成功!" << endl;
    	}
    	return true;
    }
    
    int LocateElem(SqList L, int e)
    {//(5)查找
    	for (int i = 0;i < L.length;i++)
    	{
    		if (L.elem[i] == e)
    		{
    			return i + 1;
    		}
    	}
    	return 0;
    }
    
    int main()
    {
    	cout << "====================" << endl << "(1).构造一个空线性表:" << endl<<endl;
    	SqList L;
    	if (!List_Init(L))
    	{
    		cout << "(Failure)空链表创建失败!" << endl<<endl;
    	}
    	else
    	{
    	cout << "(Success)空链表创建成功!" <<endl<<endl;;
    
    
    	cout << "====================" << endl << "(2).自定义一个顺序表:" << endl << endl;
    	int n, e1;
    	cout << "输入顺序表长度n:";cin >> n;
    	cout << "请依次输入n个值(以空格分隔):";
    	for (int i = 1;i <= n;i++)
    	{
    		cin >> e1;
    		List_Insert(L, i, e1);
    	}
    	cout << "当前顺序表为:";
    	for (int i = 1;i <= L.length;i++)
    	{
    		int tem;
    		GetElem(L, i, tem);
    		cout << tem << " ";
    	}
    	cout << endl;
    
    
    	cout << "====================" << endl << "(3).插入:" << endl << endl;
    	int i, e2, temp;
    	cout << "请输入插入位置:";
    	cin >> i;
    	cout << "请输入插入值:";
    	cin >> e2;
    	temp = List_Insert(L, i, e2);
    	if (temp)
    	{
    		cout << "插入成功!" << endl;
    	}
    	else if (!temp)
    	{
    		cout << "插入失败!\n";
    		if (temp == false)
    		{
    
    			cout << "顺序表空间已满" << endl;
    		}
    		else
    		{
    			cout << "插入位置不合法" << endl;
    		}
    	 }
    	cout << "当前顺序表为:";
    	for (int i = 1;i <= L.length;i++)
    	{
    		int e;
    		GetElem(L, i, e);
    		cout << e << " ";
    	}
    	cout << endl;
    
    	cout << "====================" << endl << "(4).删除:" << endl << endl;
    	int l;
    	cout << "请输入要删除元素的位置:";cin >> l;
    	Delete_List(L, l);
    	
    	cout << "当前顺序表为:";
    	for(int i=1;i<=L.length;i++)
    	{
    		int e;
    		GetElem(L, i, e);
    		cout << e << " ";
    	 }
    	cout << endl;
    
    	cout << "====================" << endl << "(5).查找:" << endl << endl;
    	cout << "请输入要查找的值:";
    	int e3;
    	cin >> e3;
    	temp = LocateElem(L, e3);
    	if (!temp)
    	{
    		cout << "(Sorry)顺序表中没有这个值"<<endl;
    	}
    	else
    	{
    		cout << "查找成功,元素位置为:"<<temp << endl<<endl;
    	}
    
    	delete[]L.elem;
    	cout << "====================" << endl<<"(Over)链表已释放!" << endl << endl;
    	}
    	system("pause");
    	return 0;
    }
    
    展开全文
  • 顺序链表的实现

    千次阅读 2018-09-09 21:55:33
    顺序表相当于一个结构体,一个结构体就是一张表,结构体里面两个成员,一个成员是数组,一个是表示数组实际长度int型变量
    #pragma once
    #include<stdio.h>
    #include<stdlib.h>
    #include<assert.h>
    typedef int datetype;
    #define MAX_SIZE (100)
    typedef struct Sequlist {
    	datetype arry[MAX_SIZE];
    	//顺序表相当于一个结构体,一个结构体就是一张表,结构体里面两个成员,一个成员是数组,一个是表示数组实际长度的int型变量
    	int SIZE;
    }Sequlist;
    typedef struct Sequlist Sequlist;
    //接口函数
    //初始化.销毁
    //增删查改
    
    //初始化函数设置
    void SequlistInit(Sequlist *pT)
    {
    	assert(pT != NULL);
    	pT->SIZE = 0;
    
    }
    
    //销毁
    void Sequlistdestroy(Sequlist *pT)
    {
    	assert(pT);
    	pT->SIZE = 0;
    }
    //尾插
    void Sequlistpushback(Sequlist *pT, datetype date)
    {
    	assert(pT);
    	//如果存储满了
    	if (pT->SIZE >= MAX_SIZE)
    
    	{
    		printf("存储满了");
    		assert(0);
    		return;
    	}
    	//通常情况
    	pT->arry[pT->SIZE] = date;
    	pT->SIZE++;
    }
    // 头插
    void SeqListPushFront(Sequlist *pT, datetype data)
    {
    	assert(pT);
    
    	// 特殊情况(满了)
    	if (pT->SIZE >= MAX_SIZE) {
    		printf("满了\n");
    		assert(0);
    		return;
    	}
    
    	// 现有数据整体往后搬移一格
    	// i 代表的是位置
    	for (int i = pT->SIZE; i > 0; i--) {
    		// 前面是位置  后面是数据
    		pT->arry[i] = pT->arry[i - 1];
    	}
    
    	// i 代表的是数据
    	/*
    	for (int i = pSeq->size - 1; i >= 0; i--) {
    	pSeq->array[i + 1] = pSeq->array[i];
    	}
    	*/
    
    	// 插入
    	pT->arry[0] = data;
    	pT->SIZE++;
    }
    
    void SeqListInsert(Sequlist *pT, int pos, datetype data)
    {
    	assert(pT);
    	assert(pos >= 0 && pos <= pT->SIZE);
    
    	// 特殊情况(满了)
    	if (pT->SIZE >= MAX_SIZE) {
    		printf("满了\n");
    		assert(0);
    		return;
    	}
    
    	// 1. 数据搬移
    	// 1) 从后往前 2) i 取 数据 [size - 1, pos]
    	for (int i = pT->SIZE - 1; i >= pos; i--) {
    		// 位置 数据
    		pT->arry[i + 1] = pT->arry[i];
    	}
    
    
    	// 2. 插入
    	pT->arry[pos] = data;
    	pT->SIZE++;
    }
    
    // 删
    // 尾删
    void SeqListPopBack(Sequlist *pSeq)
    {
    	assert(pSeq);
    
    	// 特殊情况(空了)
    	if (pSeq->SIZE <= 0) {
    		printf("空了\n");
    		assert(0);
    		return;
    	}
    
    	// 通常情况
    	pSeq->SIZE--;
    }
    
    // 头删
    void SeqListPopFront(Sequlist *pT)
    {
    	assert(pT);
    
    	// 特殊情况(空了)
    	if (pT->SIZE <= 0) {
    		printf("空了\n");
    		assert(0);
    		return;
    	}
    
    	// i 代表的是位置
    	for (int i = 0; i < pT->SIZE - 1; i++) {
    		// 前位置 后数据
    		pT->arry[i] = pT->arry[i + 1];
    	}
    
    	pT->SIZE--;
    }
    
    void SeqListErase(Sequlist *pT, int pos)
    {
    	assert(pT);
    	assert(pos >= 0 && pos < pT->SIZE);
    	// 特殊情况(空了)
    	if (pT->SIZE <= 0) {
    		printf("空了\n");
    		assert(0);
    		return;
    	}
    
    	// 数据搬移
    	// 1) 从前往后 2) i 取位置 
    	for (int i = pos; i <= pT->SIZE - 2; i++) {
    		pT->arry[i] = pT->arry[i + 1];
    	}
    
    	pT->SIZE--;
    }
    
    // 传指针减少空间,不改变值
    void SeqListPrint(const Sequlist *pSeq)
    {
    	assert(pSeq != NULL);
    
    	for (int i = 0; i < pSeq->SIZE; i++) {
    		printf("%d ", pSeq->arry[i]);
    	}
    	printf("\n");
    }
    
    // 使用场景
    void Test()
    {
    	// 1.
    	Sequlist seqList;
    	SequlistInit(&seqList);	// 1. seqList, 2. &seqList	// 1). 指针空间更小 2).改变值 
    
    							// 2.
    							//SeqList *pSeqList;
    							//pSeqList = SeqListInit();
    
    	Sequlistpushback(&seqList, 1);
    	Sequlistpushback(&seqList, 2);
    	Sequlistpushback(&seqList, 3);
    	Sequlistpushback(&seqList, 4);
    
    	SeqListPrint(&seqList);
    
    	SeqListPopBack(&seqList);
    
    	SeqListPrint(&seqList);
    
    
    	SeqListPushFront(&seqList, 10);
    	SeqListPushFront(&seqList, 20);
    	SeqListPushFront(&seqList, 30);
    	SeqListPushFront(&seqList, 40);
    
    	SeqListPrint(&seqList);
    
    	SeqListPopFront(&seqList);
    
    	SeqListPrint(&seqList);
    
    	SeqListInsert(&seqList, 4, 100);
    	SeqListPrint(&seqList);
    	SeqListErase(&seqList, 4);
    	SeqListPrint(&seqList);
    }
    
    // 查找
    // 找到第一个遇到的数的下标,没找到返回 -1 (更理想返回类型 ssize_t)
    int SeqListFind(Sequlist *pSeq, datetype data)
    {
    	// 二分查找(前提是有序)
    	// 顺序遍历查找
    	for (int i = 0; i < pSeq->SIZE; i++) {
    		if (data == pSeq->arry[i]) {
    			// 找到返回下标
    			return i;
    		}
    	}
    
    	// 没找到
    	return -1;
    }
    
    // 删除第二种形态 (根据数据删除)
    // 1. 删遇到的第一个数据
    void SeqListRemove(Sequlist *pSeq, datetype data)
    {
    	int pos = SeqListFind(pSeq, data);
    	if (pos == -1) {
    		// 没找到
    		return;
    	}
    
    	SeqListErase(pSeq, pos);
    }
    
    // 2. 删遇到的所有数据
    void SeqListRemoveAll(Sequlist *pSeq, datetype data)
    {
    	// 第一种方式	1	1	1	1	...	1		1
    	// 慢 N^N
    	/*while ((pos = SeqListFind(pSeq, data)) != -1) {
    	SeqListErase(pSeq, pos);
    	}*/
    
    
    #if 0
    	// 2. 一次遍历删除
    	// 好处: 一次遍历,时间比较快
    	// 坏处: 开了新空间,空间大小和 size 有关系
    	// 1) 开新数组
    	datatype *newArray = (datatype *)malloc(sizeof(datatype)* pT->SIZE);
    	int i, j;
    	for (i = 0, j = 0; i < pT->SIZE; i++) {
    		if (data != pT->arry[i]) {
    			newArray[j] = pT->arry[i];
    			j++;
    		}
    	}
    
    	// 把数据搬回来
    	for (i = 0; i < j; i++) {
    		pT->arry[i] = newArray[i];
    	}
    	pT->SIZE = j;
    
    	// 释放
    	free(newArray);
    #endif
    //
    //	// 第三种方式
    //	int i, j;
    //	for (i = 0, j = 0; i < pT->SIZE; i++) {
    //		if (data !=pT->arry[i]) {
    //			pT->arry[j] = pT->arry[i];
    //			j++;
    //		}
    //	}
    //	pT->SIZE = j;
    //}

     

    展开全文
  • 采用Java实现数据结构中的顺序表/***Apr 15, 2013*Copyright(c)JackWang*All rights reserve*@Author JackWang*/.../*** 顺序表的实现* @author Administrator**/public class MySeqList {private Object[] obj; ...

    采用Java实现数据结构中的顺序表

    /**

    *Apr 15, 2013

    *Copyright(c)JackWang

    *All rights reserve

    *@Author JackWang

    */

    package com.example.list;

    /**

    * 顺序表的实现

    * @author Administrator

    *

    */

    public class MySeqList {

    private Object[] obj; //存储元素,初始长度为10

    private int len; //记录顺序表的长度

    private final int maxSize = 10;

    /**

    * 初始化线性表

    */

    public MySeqList() {

    this.obj = new Object[10];

    this.len = 0;

    this.clear();

    }

    /**

    * 判断线性表是否为空

    * @return 空返回true

    */

    public boolean isEmpty(){

    if (len == 0) {

    return true;

    }

    return false;

    }

    /**

    * 判断线性表是否已满

    * @return 满返回 true

    */

    public boolean isFull(){

    if (len == maxSize) {

    return true;

    }

    return false;

    }

    /**

    * 返回线性表的长度

    * @return 线性表的长度

    */

    public int length(){

    return len;

    }

    /**

    * 清空线性表

    */

    public void clear() {

    for (int i = 0; i < obj.length; i++) {

    obj[i] = null;

    }

    }

    /**

    * 添加元素

    * @param i 要添加元素的脚标

    * @param o 要添加的元素

    */

    public void insert(int i,Object o){

    if (i <1) {

    throw new RuntimeException("脚标不规范!");

    }

    if (obj[i-1] != null) {

    for(int j = len-1;j>i;j--){

    obj[j+1] = obj[j];

    }

    obj[i] = o;

    len++;

    return;

    }else {

    obj[i-1] = o;

    len++;

    return;

    }

    }

    /**

    * 删除元素

    * @param i 要删除的元素索引

    */

    public void delete(int i){

    if (i > len || i <1) {

    throw new RuntimeException("脚标不规范!");

    }

    for(int j = i;j

    obj[i-1]=obj[i];

    }

    obj[len-1] = null;

    len--;

    }

    /**

    * 修改元素

    * @param i 要修改元素的脚标

    * @param newObj 要修改的值

    */

    public void update(int i,Object newObj){

    if (i > len || i <1) {

    throw new RuntimeException("脚标不规范!");

    }

    obj[i-1] = newObj;

    }

    /**

    * 查找元素

    * @param o 要查找的元素

    * @return 查到元素的索引

    */

    public int find(Object o){

    for (int i = 0; i < obj.length; i++) {

    if(o.equals(obj[i])){

    return i+1;

    }

    }

    return -1;

    }

    /**

    * 当前元素的前一个元素的索引

    */

    public int previous(int i){

    if (i > len || i <1) {

    throw new RuntimeException("脚标不规范!");

    }

    if( i== 1){

    return len;

    }

    return i-1;

    }

    /**

    * 当前元素的后一个元素的索引

    */

    public int next(int i){

    if (i > len || i <1) {

    throw new RuntimeException("脚标不规范!");

    }

    if( i == len){

    return 1;

    }

    return i+1;

    }

    /**

    * 遍历输出线性表

    * @return

    */

    public void print(){

    for (int i = 0; i < obj.length; i++) {

    System.out.println(obj[i]+" ");

    }

    System.out.println();

    }

    /**

    * 得到特定脚标的元素

    * @param i

    * @return

    */

    public Object get(int i){

    if (i > len || i <1) {

    throw new RuntimeException("脚标不规范!");

    }

    return obj[i-1];

    }

    }

    展开全文
  • 实验一:顺序表的实现

    千次阅读 2017-09-23 10:28:19
    顺序表的实现 (1) 实验目的  熟练掌握线性表的结构特点,掌握顺序表的基本操作,巩固c++相关的程序设计方法与技术 (2) 实验内容  建立若干个元素的顺序表 实现相关的操作,输出、插入、删除、查找等...

    实验一

    顺序表的实现

    (1)    实验目的

      熟练掌握线性表的结构特点,掌握顺序表的基本操作,巩固c++相关的程序设计方法与技术

    (2)    实验内容

      建立若干个元素的顺序表

    实现相关的操作,输出、插入、删除、查找等功能,编写完整程序实现

    (3)    实验步骤

    实验程序中用到的数据类型的定义:int、char

    相关操作的算法表达:

    输入输出,线性表的长度为length,将数据存放在头文件中建立的数组data[maxsize]中,输入时出现length大于maxsize出现上溢,为零则出现下溢。

    插入,用j标记元素所在的数组.将第j个元素存在数组下标为j-1的位置

    查找,用循环语句,在数组中寻找该元素,直到相等,停止循环

    删除,先利用查找功能找出元素位置,利用j位置替换j-1位置

    完整程序:

    #ifndef SeqList_H                               //头文件

    #define SeqList_H

    const int Maxsize=12;

    class SeqList

    {

    public:

          SeqList(){length=0;}

          SeqList(inta[],int n);

          ~SeqList(){}

          voidInsert(int i,int x);

          intDelete(int i);

          intLocate(int x);

          voidPrintList();

    private:

          intdata[Maxsize];

          intlength;

    };

    #endif

     

    #include<iostream> //引入输入输出流

    using namespace std;

    #include"SeqList.h"   

    //以下是类seqlist的声明

    SeqList::SeqList(int a[],int n)

    {

          if(n>Maxsize)throw"参数非法";

          for(inti=0;i<n;i++)

               data[i]=a[i];

          length=n;

    }

    void SeqList::Insert(int i,int x)     //插入功能

    {

          if(length>=Maxsize)throw"上溢";

          if(i<1||i>length+1)throw"位置非法";

          for(intj=length;j>=i;j--)

               data[j]=data[j-1];

          data[i-1]=x;

          length++;

    }

    int SeqList::Delete(int i)        //删除功能

    {

          if(length==0)throw"下溢";

          if(i<1||i>length)throw"位置非法";

          intx=data[i-1];

          for(intj=i;j<length;j++)

               data[j-1]=data[j];

          length--;

          returnx;

    }

    int SeqList::Locate(int x)         //查找功能

    {

          for(inti=0;i<length;i++)

               if(data[i]==x)return i+1;

               return0;

    }

    void SeqList::PrintList()           //输出功能

    {

          for(inti=0;i<length;i++)

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

          cout<<endl;

    }

     

    #include<iostream>                  //主函数

    using namespace std;

    #include"SeqList.h"

    void main()

    {

          intr[8]={1,2,3,4,5,6,7,8};

          SeqListL(r,8);

          cout<<"执行插入操作前数据为:"<<endl;

          L.PrintList();

          try

          {

               L.Insert(4,8);

          }

          catch(char*s)

          {

               cout<<s<<endl;

          }

          cout<<"执行插入操作后数据为:"<<endl;

          L.PrintList();

          cout<<"值为4的元素位置为:";

          cout<<L.Locate(4)<<endl;

          cout<<"执行删除第四个元素操作,删除前数据为:"<<endl;

          L.PrintList();

          try

          {

               L.Delete(4);

          }

          catch(char*s)

          {

               cout<<s<<endl;

          }

          cout<<"删除后数据为:"<<endl;

          L.PrintList();

    }

    (4)运行结果

     

    (5)实验心得

    这是数据结构的第一节实验课,顺序表既线性表的顺序存储结构,在理论课上对顺序表的概念还有点模糊,在实验课上可以得到进一步的理解。在实验过程中,我只实现了基本的功能,所以我需要向同学多参考多学习。数据结构的学习需要结合c++,所以我要不断回顾之前的c++知识。


    展开全文
  • 顺序表的实现C++封装

    千次阅读 2015-10-03 10:35:53
    数据结构内容中,用C++封装顺序表的实现
  • 顺序表的实现  (1) 初始化顺序表  (2) 建立顺序表  (3) 销毁顺序表 //顺序表静态分配内存,在顺序表退出作用域时自动释放该变量所占内存单元,无需销毁  (4) 判空操作  (5) 求顺序表的长度  ...
  • 动态顺序表的实现

    2019-05-25 11:16:28
    顺序表是用一组连输地址实现的线性表,其优点是可以随机访问表中元素和修改指定位置元素比较简单,但插入和删除元素需要移动元素,表长扩展也比较麻烦. 顺序表基本数据结构 用数组表示 typedef struct{ ElenType...
  • 数据结构 顺序表的实现(C语言)

    千次阅读 2016-09-20 00:12:17
    数据结构 顺序表的实现(C语言)
  • 顺序链表的实现和链表查询的实现

    千次阅读 2015-03-25 11:59:59
    顺序链表创建和顺序链表查询
  • 顺序表ADT实现 对表的操作( 所有操作前提是顺序表存在) 对表中元素的操作(操作的前提是顺序表不为空) 顺序表的存储结构 顺序表插入操作实现 如何判断顺序表是否存在 顺序表中指针传递问题 全部代码
  • C++顺序表的实现

    千次阅读 2019-09-29 15:57:46
    // 顺序表的存储结构及基本操作实现 #include "stdlib.h" #include "iostream.h" //cin cout #define MAXSIZE 100 #define OK 0 #define OVERFLOW -2 #define ERROR -1 typedef int Status; typedef char...
  • 转:C++顺序表的实现(采用模板)
  • JAVA顺序表的实现

    2019-10-31 12:11:17
    顺序表和列表学习 数据结构+算法 算法效率: 算法效率分析分为两种:第一种是时间效率,第二种是空间效率。时间效率被称为时间复杂度,而空间效率被 称作空间复杂度。 时间复杂度主要衡量是一个算法运行速度,...
  • 顺序表的实现插入删除

    千次阅读 2018-03-28 15:43:47
    实现基于静态数组的顺序表的以下基本操作: 1. 初始化 2. 尾插 3. 尾删 4. 头插 5. 头删 6. 读任意位置元素 7. 修改任意位置元素 8. 查找指定元素值的下标 9. 在任意位置插入元素 10.删除顺序表中指定的值,...
  • Java顺序表的实现

    2017-12-30 20:16:11
    顺序表的主要操作有清空、判断是否为空、求当前长度、获取某个位置元素、插入、删除、查找元素位置等。其中几项很简单,只有插入、删除可能要思考一下,但也是容易解决的。代码如下: public cla
  • C语言顺序表的实现

    2017-01-17 21:33:48
    顺序表的操作有初始化、插入元素、取值、查找元素、删除元素这五种操作。
  • 动态顺序表是在静态顺序表的基础上优化更改的 1.其中将静态顺序表中的数组数据类型改成了指针类型方便内存的开辟 2.多增加了一个容量的变量来表示顺序表的容量 3.初始化的时候需要给*data动态开辟空间 4.多增加的...
  • )数据结构实验1-顺序表的实现和应用 1. 实验目的: ⑴熟悉线性表的定义和基本操作; ⑵掌握线性表的顺序存储结构设计与基本操作的实现。 2.实验内容与要求: ⑴定义线性表的顺序存储表示; ⑵基于所设计的存储...
  • 线性表的顺序存储又称为顺序表,它是用一组地址连续的存储单元,依次存储线性表中的数据元素,从而... 顺序表的特点是表中元素的逻辑顺序与其物理顺序相同。 参考文章https://blog.csdn.net/flueky/article/deta...
  • 顺序表的实现(python)

    千次阅读 2018-12-11 20:29:17
    利用python内置list来实现顺序表 class SequenceList(object): &amp;quot;&amp;quot;&amp;quot;顺序表&amp;quot;&amp;quot;&amp;quot; def __init__(self, size=6): # 初始化顺序...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,902
精华内容 11,160
关键字:

顺序表的实现