关键词：
目录
线性表
线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串等等
线性表在逻辑上是线性结构的，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
顺序表
顺序表使用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数据存储。在数组上完成数据的增删查改。
顺序表一般分为：
1.静态顺序表：使用定长数组存储元素
2.动态顺序表：使用动态开辟的数组存储
了解了线性表与顺序表之后，下面我们就来实现以下动态顺序表吧。
顺序表的实现
函数接口的声明
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int SLDataType;
//动态顺序表
typedef struct Seqlist
SLDataType *a;
int sz;//表示数组中存储了多少个数据
int capacity;//表示数组实际能存储的空间容量
SL;
//初始化
void SeqlistInit(SL* ps);
//顺序表的打印
void SeqlistPrint(SL* ps);
//顺序表的销毁
void SeqlistDestory(SL* ps);
//尾插
void SeqlistPushBack(SL*ps, SLDataType x);
//头插
void SeqlistPushFront(SL*ps, SLDataType x);
//尾删
void SeqlistPopBack(SL*ps);
//头删
void SeqlistPopFront(SL*ps);
//顺序表查找
int SeqlistFind(SL*ps, SLDataType x);
//顺序表检查是否要扩容
void SeqlistCheck(SL*ps);
//顺序表在pos位置插入x
void SeqlisInsert(SL*ps, int pos, SLDataType x);
//顺序表删除pos位置的值
void SeqlistErase(SL*ps, int pos);
//顺序表修改pos位置的值
void SeqlistModify(SL*ps, int pos, SLDataType x);函数接口的实现:
#define _CRT_SECURE_NO_WARNINGS 1
#include"Seqlist.h"
//顺序表检查是否要扩容
void SeqlistCheck(SL*ps)
if (ps->sz == ps->capacity)
int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
SLDataType* temp = (SLDataType*)realloc(ps->a, sizeof(SLDataType*)*newcapacity);
//当一个指针为NULL指针时，realloc就相当于malloc，这里我们还需要判断一下是否扩容成功
if (temp == NULL)
printf("realloc failed\\n");
exit(-1);
//扩容成功
else
ps->a = temp;
ps->capacity = newcapacity;
//初始化的实现
void SeqlistInit(SL* ps)
ps->a = NULL;
ps->sz = ps->capacity = 0;
//顺序表的打印
void SeqlistPrint(SL* ps)
int i = 0;
for (i = 0; i < ps->sz; i++)
printf("%d ", ps->a[i]);
printf("\\n");
//顺序表的销毁
void SeqlistDestory(SL* ps)
free(ps->a);
ps->a = NULL;
ps->a = 0;
ps->capacity = 0;
//尾插的实现
void SeqlistPushBack(SL*ps, SLDataType x)
assert(ps);
//如果空间不够或者空间为0时，就得扩容
SeqlistCheck(ps);
//if (ps->sz == ps->capacity)
//
// int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
// SLDataType* temp = (SLDataType*)realloc(ps->a, sizeof(SLDataType*)*newcapacity);
// //当一个指针为NULL指针时，realloc就相当于malloc，这里我们还需要判断一下是否扩容成功
// if (temp == NULL)
//
// printf("realloc failed\\n");
// exit(-1);
//
// //扩容成功
// else
//
// ps->a = temp;
// ps->capacity = newcapacity;
//
//
//假如空间足够，那么我们直接往后插入
ps->a[ps->sz] = x;
ps->sz++;//顺序表有效元素个数+1
//头插的实现
void SeqlistPushFront(SL*ps, SLDataType x)
assert(ps);
//当空间不够的时候就扩容
SeqlistCheck(ps);
//if (ps->sz == ps->capacity)
//
// int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
// SLDataType* temp = (SLDataType*)realloc(ps->a, sizeof(SLDataType*)*newcapacity);
// //当一个指针为NULL指针时，realloc就相当于malloc，这里我们还需要判断一下是否扩容成功
// if (temp == NULL)
//
// printf("realloc failed\\n");
// exit(-1);
//
// //扩容成功
// else
//
// ps->a = temp;
// ps->capacity = newcapacity;
//
//
//当空间足够的时候，头插的话得向后挪并且是从后往前挪，从前往后会造成覆盖达不到效果
int end = ps->sz-1;
while (end>=0)
ps->a[end + 1] = ps->a[end];
end--;
ps->a[0] = x;
ps->sz++;//顺序表有效元素个数+1
//尾删的实现
void SeqlistPopBack(SL*ps)
assert(ps);
assert(ps->sz > 0);
ps->sz--;//顺序表有效元素个数-1
//头删的实现
void SeqlistPopFront(SL*ps)
assert(ps);
assert(ps->sz > 0);
int begin = 1;
while (begin <ps->sz)
//从前往后覆盖
ps->a[begin-1] = ps->a[begin];
begin++;
ps->sz--;//顺序表有效元素个数-1
//顺序表查找
int SeqlistFind(SL*ps, SLDataType x)
assert(ps);
int i = 0;
for (i = 0; i < ps->sz; i++)
if (ps->a[i] == x)
//找到了
return i;
//找不到
return -1;
//顺序表在pos位置插入x
void SeqlisInsert(SL*ps, int pos, SLDataType x)
assert(ps);
assert(pos >= 0 && pos <= ps->sz);
//当空间不够的时候就扩容
SeqlistCheck(ps);
//相当于头插
int end = ps->sz - 1;
while (end >= pos)
ps->a[end + 1] = ps->a[end];
end--;
ps->a[pos] = x;
ps->sz++;//顺序表有效元素个数+1
//顺序表删除pos位置的值
void SeqlistErase(SL*ps, int pos)
assert(ps);
assert(pos >= 0 && pos < ps->sz);
int begin = pos;
while (begin < ps->sz)
//从前往后覆盖
ps->a[begin-1] = ps->a[begin];
begin++;
ps->sz--;
//顺序表修改pos位置的值
void SeqlistModify(SL*ps, int pos, SLDataType x)
assert(ps);
assert(pos >= 0 && pos < ps->sz);
ps->a[pos] = x;
顺序表的初始化
将结构体中指向动态开辟的数组的指针置空，将size与capacity置为0.
//初始化的实现
void SeqlistInit(SL* ps)
ps->a = NULL;
ps->sz = ps->capacity = 0;
顺序表的销毁
释放在堆上动态开辟的空间，并且将size与capacity置成0
//顺序表的销毁
void SeqlistDestory(SL* ps)
free(ps->a);
ps->a = NULL;
ps->a = 0;
ps->capacity = 0;
顺序表的打印
依次打印动态开辟的数组中的有效数据
//顺序表的打印
void SeqlistPrint(SL* ps)
int i = 0;
for (i = 0; i < ps->sz; i++)
printf("%d ", ps->a[i]);
printf("\\n");
顺序表检查是否要扩容
当size与capacity相等并且都为0时，就将capacity的容量变成4，若是size与capacity相等但是不为0时，我们就需要扩容了将capacity的容量扩成2倍。
//顺序表检查是否要扩容
void SeqlistCheck(SL*ps)
if (ps->sz == ps->capacity)
int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
SLDataType* temp = (SLDataType*)realloc(ps->a, sizeof(SLDataType*)*newcapacity);
//当一个指针为NULL指针时，realloc就相当于malloc，这里我们还需要判断一下是否扩容成功
if (temp == NULL)
printf("realloc failed\\n");
exit(-1);
//扩容成功
else
ps->a = temp;
ps->capacity = newcapacity;
顺序表的尾插
首先要判断一下空间容量是否充足，若空间满了就应该当先扩容再尾插，若空间充足即可直接尾插。
//尾插的实现
void SeqlistPushBack(SL*ps, SLDataType x)
assert(ps);
//如果空间不够或者空间为0时，就得扩容
SeqlistCheck(ps);
//if (ps->sz == ps->capacity)
//
// int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
// SLDataType* temp = (SLDataType*)realloc(ps->a, sizeof(SLDataType*)*newcapacity);
// //当一个指针为NULL指针时，realloc就相当于malloc，这里我们还需要判断一下是否扩容成功
// if (temp == NULL)
//
// printf("realloc failed\\n");
// exit(-1);
//
// //扩容成功
// else
//
// ps->a = temp;
// ps->capacity = newcapacity;
//
//
//假如空间足够，那么我们直接往后插入
ps->a[ps->sz] = x;
ps->sz++;//顺序表有效元素个数+1
顺序表的头插
首先要判断一下空间容量是否充足，若空间满了应当先扩容，若空间足够想要头插的话得将有效数据先往后挪并且是从后往前挪，从前往后会造成覆盖达不到想要的效果，挪动之后再插入数据。
//头插的实现
void SeqlistPushFront(SL*ps, SLDataType x)
assert(ps);
//当空间不够的时候就扩容
SeqlistCheck(ps);
//if (ps->sz == ps->capacity)
//
// int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
// SLDataType* temp = (SLDataType*)realloc(ps->a, sizeof(SLDataType*)*newcapacity);
// //当一个指针为NULL指针时，realloc就相当于malloc，这里我们还需要判断一下是否扩容成功
// if (temp == NULL)
//
// printf("realloc failed\\n");
// exit(-1);
//
// //扩容成功
// else
//
// ps->a = temp;
// ps->capacity = newcapacity;
//
//
//当空间足够的时候，头插的话得向后挪并且是从后往前挪，从前往后会造成覆盖达不到效果
int end = ps->sz-1;
while (end>=0)
ps->a[end + 1] = ps->a[end];
end--;
ps->a[0] = x;
ps->sz++;//顺序表有效元素个数+1
顺序表的尾删
首先对有效数据sz进行判断，如果有效数据为0就不需要删除，大于0就只需要将ps->sz--就可以了。
//尾删的实现
void SeqlistPopBack(SL*ps)
assert(ps);
assert(ps->sz > 0);
ps->sz--;//顺序表有效元素个数-1
顺序表的头删
首先对有效数据sz进行判断，如果有效数据为0就不需要删除，如果有效数据大于0的话，需要将有效数据向前挪动，并且是进行从前往后的覆盖，然后再将ps->sz--就可以达到效果了
//头删的实现
void SeqlistPopFront(SL*ps)
assert(ps);
assert(ps->sz > 0);
int begin = 1;
while (begin <ps->sz)
//从前往后覆盖
ps->a[begin-1] = ps->a[begin];
begin++;
ps->sz--;//顺序表有效元素个数-1
顺序表的查找
在有效数据中进行查找，找到了就返回该位置的下标，找不到则返回-1；
//顺序表查找
int SeqlistFind(SL*ps, SLDataType x)
assert(ps);
int i = 0;
for (i = 0; i < ps->sz; i++)
if (ps->a[i] == x)
//找到了
return i;
//找不到
return -1;
顺序表在pos位置插入x
要想插入数据，首先就得检查空间容量是否足够，空间不足的话首先的扩容，空间足够的话需要将pos位置与pos后面的数据向后挪动，并且是从后往前挪，再将x插入到pos的位置上，(需要注意的是pos的位置必须>=0并且不能超过ps->sz-1)，最后对ps->sz++即可
//顺序表在pos位置插入x
void SeqlisInsert(SL*ps, int pos, SLDataType x)
assert(ps);
assert(pos >= 0 && pos <= ps->sz);
//当空间不够的时候就扩容
SeqlistCheck(ps);
//相当于头插
int end = ps->sz - 1;
while (end >= pos)
ps->a[end + 1] = ps->a[end];
end--;
ps->a[pos] = x;
ps->sz++;//顺序表有效元素个数+1
顺序表删除pos位置的值
删除pos位置的值，需要将pos位置之后的元素从前往后挪动，覆盖pos位置的数据，最后再将ps->sz--即可
//顺序表删除pos位置的值
void SeqlistErase(SL*ps, int pos)
assert(ps);
assert(pos >= 0 && pos < ps->sz);
int begin = pos;
while (begin < ps->sz)
//从前往后覆盖
ps->a[begin-1] = ps->a[begin];
begin++;
ps->sz--;
顺序表修改pos位置的值
直接修改pos位置的值即可
//顺序表修改pos位置的值
void SeqlistModify(SL*ps, int pos, SLDataType x)
assert(ps);
assert(pos >= 0 && pos < ps->sz);
ps->a[pos] = x;
顺序表的缺陷
1.空间不够了需要扩容，增容是需要付出代价的
2.避免频繁扩容（频繁扩容会导致内存碎片变多），空间满了我们一般都是扩2倍，这样做可能会导致一定的空间浪费
3.顺序表要求数据从开始位置连续存储，那么我们在头部或者中间位置插入删除数据就需要挪动数据，效率不高
力扣练习题
Leetcode27.移除元素
题目描述：
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
思路一：遍历数组找到等于val的值，通过挪动数据来覆盖val达到移除所有等于val的元素的效果，时间复杂度是O(N^2),空间复杂度O(1)
思路二：开一个与原数组空间一样大的数组，然后再遍历原数组，不等于val的值就放到新数组里面去，然后再将新数组的值拷回到原数组，时间复杂度是O(N),空间复杂度O(N)，这是一种拿空间换时间的做法。
思路三：双指针的做法，定义一个src与dest，并且让它俩都从数组0下标开始，如果src下标的值等于val，直接让src++，dest不动，如果src下标的值不等于val，那么就把src下标的值赋给dest下标的值，并且让src++，dest++,最后返回的dest正好就是数组新的长度。时间复杂度O(N),空间复杂度O(1)
int removeElement(int* nums, int numsSize, int val) int src = 0; int dest = 0; //遍历完这个数组就结束 while(src<numsSize) //当src下标元素等于val时，src++ if(nums[src]==val) src++; //否则的话将src下标元素的值赋给dest下标元素的值，然后src++，dest++ else nums[dest] = nums[src]; dest++; src++; return dest;
Leetcode26.删除有序数组中的重复项
题目链接：26. 删除有序数组中的重复项
题目描述：
给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。
不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
思路：这道题我们还是采用双指针的解法，不过是快慢指针，定义两个变量，一个是快指针src=1，一个是慢指针dest=0，先考虑特殊情况（如果数组大小为0，直接返回0即可) 然后再来看一般情况，通过src去遍历数组，如果src下标元素的值与dest下标元素的值相等，那么让src++，dest不动，如果不相等，就先让dest++再将src下标元素的值赋给dest下标元素的值，再让src++即可。时间复杂度O(N),空间复杂度O(1).
int removeDuplicates(int* nums, int numsSize) int src = 1;//快指针 int dest = 0;//慢指针 //特殊情况数组大小为0 if(numsSize==0) return 0; //遍历数组 while(src<numsSize) //如果快指针和慢指针所指向的元素是一样的，那么慢指针不动，快指针向后移 if(nums[src]==nums[dest]) src++; //如果快指针和慢指针所指向的元素不一样的，那么慢指针先向后移，将快指针指向元素的值赋给慢指针，快指针再往后移 else dest++; nums[dest] = nums[src]; src++; return dest+1;
Leetcode88.合并两个有序数组
题目链接：88. 合并两个有序数组
题目描述：
给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。
思路：这道题我们需要采用归并的思想，并且是从后往前归并（从大到小），从前往后的话会造成覆盖达不到我们想要的效果。由于nums1的长度是nums1与nums2有效数据长度之和，因此从nums1与nums2中挑选出较大的数依次插入到nums1数组的后面（从后往前），如果nums2先插入完了，那么我们直接返回nums1就可以了，但是如果是nums1的有效数据先插入完，但是nums2的优先数据还没插入完的话，我们还需要额外将nums2剩余的数据插入到nums1中。时间复杂度O(N),空间复杂度O(1).
void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n) int end1 = m-1; int end2 = n-1; int end = n+m-1;//num1最后一个元素的下标 while(end1>=0&&end2>=0) if(nums1[end1]>nums2[end2]) nums1[end] = nums1[end1]; end--; end1--; else nums1[end] = nums2[end2]; end--; end2--; //nums1的有效数已经全放到了nums1后面的位置，nums2还没有完全放进去 while(end2>=0) nums1[end] = nums2[end2]; end--; end2--; return nums1;
Leetcode189.旋转数组
题目链接：189. 旋转数组
题目描述：
给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。
思路：先将n-k个数进行逆置，再将后k个数进行逆置，最后再整体逆置。这样就达到我们想要的效果了。时间复杂度O(N),空间复杂度O(1).
void Reverse(int*nums,int left,int right) while(left<right) int temp = nums[left]; nums[left] = nums[right]; nums[right] = temp; left++; right--; void rotate(int* nums, int numsSize, int k) if(k>=numsSize) k%=numsSize; //前n-k个数逆置 Reverse(nums,0,numsSize-k-1); //后k个数逆置 Reverse(nums,numsSize-k,numsSize-1); //整体逆置 Reverse(nums,0,numsSize-1);
以上就是本篇文章的全部内容了，大家学数据结构的时候不能够光看视频，一定要下去多敲代码做题目巩固自己所学的知识。如果觉得博主的文章对你有帮助的话，可以点赞评论收藏支持一下博主。
力扣练习2（十题）(代码片段)
...搜索插入位置 4.实现strStr()5.(6)Z字形变换 6.(19) 删除链表的倒数第N个结点7.(23) 合并K个升序链表8.(25) K个一组翻转链表9.(58)最后一个单词的长度10.(66)加一1.删除有序数组中的重复项给你一个有序数组nums，请你原地删除重... 查看详情
数据结构[双链表的实现，以及双链表和单链表之间的比较，链表和顺序表的优劣](代码片段)
...能实现：🥇双链表和单链表的比较🥇链表和顺序表的优劣🥇双链表简单介绍：博主在前面介绍了单链表，并实现了它的基本功能，详细请看博客单链表，相信有一点链表基础的同学肯定会知道ÿ... 查看详情
力扣练习1（十题）(代码片段)
...数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案。示例1：输入：nums=[2,7,11,15],target=9 查看详情
普通链表的各种排序及常用操作(代码片段)
声明内容根据数据结构、算法与应用C++描述书籍练习题的实现，实现普通链表的插入，选择，冒泡，计数排序(排列排序),交叉排序，奇偶交叉以及归并排序,链表的反转,循环元素移动，网上也有其他解答，由于新人刚学习算法。... 查看详情
线性表的顺序表示的简单实现（顺序表的实现）(代码片段)
目录1、顺序表的概念2、顺序表的的存储表示和实现3、基本操作的实现 3.1初始化 3.2取值 3.3查找 3.4插入 3.5删除4、测试线性表的功能 1、顺序表的概念：使用一段连续的存储空间存储线性表的元素2、顺序表... 查看详情
02线性表之顺序表(代码片段)
...机“删除”5.5内存销毁5.6“改”5.7“查”6.顺序表相关OJ练习题6.1原地移除元素6.2合并两个有序数组1.本章重点1.线性表概念2.顺序表实现3.顺序表相关O 查看详情
数据结构：线性表顺序表以及单链表详解(代码片段)
...⭐线性表线性表的定义及基本表示线性表的定义基本操作顺序表顺序表的定义顺序表的基本操作增删查改线性表的链式表示单链表的定义链表的建立链表的操作插入节点删除结点⭐前言⭐本文将解析线性表中的顺序表以及链表线... 查看详情
算法练习题力扣练习题——数组：下一个排列(代码片段)
原题说明：实现获取下一个排列的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列。如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。必须原地修改，只允许使用额外常数空... 查看详情
力扣练习006---前k个高频单词(692)(代码片段)
...由高到低排序。如果不同的单词有相同出现频率，按字母顺序排序。示例1：输入:["i","love","leetcode","i","love"," 查看详情
力扣练习题(代码片段)
每日一练力扣1209.删除字符串中的所有相邻重复项II力扣1047.删除字符串中的所有相邻重复项力扣76.最小覆盖子串剑指OfferII039.直方图最大矩形面积力扣1209.删除字符串中的所有相邻重复项II给你一个字符串s，「k倍重复项删除... 查看详情
力扣练习题(代码片段)
每日一练力扣1209.删除字符串中的所有相邻重复项II力扣1047.删除字符串中的所有相邻重复项力扣76.最小覆盖子串剑指OfferII039.直方图最大矩形面积力扣1209.删除字符串中的所有相邻重复项II给你一个字符串s，「k倍重复项删除... 查看详情
数据结构线性表初接触1：线性表的顺序存储结构下基本运算的实现(代码片段)
刚刚接触数据结构这学问，通过听课看书后自行练习了用C语言实现线性表的基本运算，其中有许多点值得注意。这里存储各个功能分块的代码，以便自身的理解及以后的复习；1typedefintElemType;2#defineMaxSize503typedefstruct4ElemTypedata[Max... 查看详情
顺序表的（增删查改）实现(代码片段)
(文章目录)一、线性表1.线性表的概念3.顺序表的优缺点1.优点2.缺点二、顺序表的实现1.函数的定义和结构体的创建--contact.h#include<stdlib.h>#include<stdio.h>typedefinttype;structs type*data;//动态开辟 intsize;//记录数量 intcap;//容量大小... 查看详情
c语言实现顺序表(初阶数据结构)(代码片段)
文章目录前言顺序表的介绍项目分配顺序表的定义顺序表的初始化顺序表的打印顺序表的销毁顺序表的尾插增容函数的实现顺序表的头插顺序表的任意位置插入数据顺序表的尾删顺序表的头删顺序表的任意位置删除顺序表的查找... 查看详情
顺序链表的c风格实现(代码片段)
1//头文件2#ifndef_SEQLIST_H_3#define_SEQLIST_H_4//定义数据类型5typedefvoidSeqList;6typedefvoidSeqListNode;78//顺序链表的生成9SeqList*SeqList_Create(intcapacity);10//顺序链表的删除11voidSeqList_Destory(SeqList*list);12//顺序链表 查看详情
顺序表的基本实现(代码片段)
顺序表的实现1、头文件2、初始化3、销毁4、打印5、尾插6、尾删7、头插8、头删9、查找10、插入11、删除12、检查容量1、头文件我这里主要说的是动态的顺序表，当然静态顺序表的操作基本上是一样的，只是静态顺序表无... 查看详情
力扣-2020年最后一次登录(代码片段)
...xff0c;我是空空star，本篇带大家了解一道简单的力扣sql练习题。文章目录前言一、题目：1890.2020年最后一次登录二、解题1.正确示范①提交SQL运行结果2.正确示范②提交SQL运行结果3.正确示范③提交SQL运行结果4.正确示范④... 查看详情
数据结构实验报告之三元组顺序表存储的稀疏矩阵练习(代码片段)
数据结构实验报告之三元组顺序表存储的稀疏矩阵练习一、实验内容1.实验目的2.实验内容二、实现过程1.编译预处理以及使用类别名2.sumDiagnoal3()函数3.FastTransposeTSMatrix()函数4.主函数三、实验结果四、编程时遇到的问题五、总结... 查看详情