顺序表什么时候用->还是.

在编程中，顺序表通常用于表示一组数据元素，其中每个元素在内存中是连续存储的。当你需要访问列表中的元素时，可以使用指针或者索引来标识位置。在C++等语言中，如果你使用`std::vector`（C++标准库中的动态数组）或其他类似的数据结构，访问元素时一般直接通过元素的下标（索引）使用`.`操作符，如`list[index]`。

然而，如果你在使用某些自定义的顺序表实现或者底层指针操作，比如C风格的数组或者手动管理内存的情况，可能会用到指针箭头`->`来指向元素。例如：

// C-style数组
int* array = new int[5]; // 创建一个包含5个整数的数组
array[0]->value = 10; // 使用指针访问并修改第一个元素

// 或者使用智能指针，如std::unique_ptr
std::unique_ptr<int[]> ptr(new int[5]);
ptr.get()[0] = 10; // 使用get()获取内部指针然后访问

在这里，`->`用来间接访问数组元素，因为`array`实际上是地址，`array[0]`是一个新的指针，所以要再加`->`才能到达实际的值。

相关问题

#include"sequence.h" #include<stdlib.h> typedef struct { SequenceList Vertices; int edge[10000][10000]; int numOfEdges; }MatrixGraph; void Initiate(MatrixGraph *G,int n)//初始化 { int i,j; for(i=0;i<n;i++) for(j=0;j<n;j++) { if(i==j) G->edge[i][j]=0; else G->edge[i][j]=10000; } G->numOfEdges=0; ListInitialize(&G->Vertices); } void InsertVertex(MatrixGraph *G,ElemType vertex)//插入顶点 { ListInsert(&G->Vertices,G->Vertices.size,vertex); } void InsertEdge(MatrixGraph *G,int v1,int v2,int weight)//插入一条边 { if(v1<0||v1>=G->Vertices.size||v2<0||v2>=G->Vertices.size) { printf("参数v1或v2越界出错！\n"); exit(1); } G->edge[v1][v2]=weight; G->numOfEdges++; }

根据你提供的代码，我看到你定义了一个结构体 `MatrixGraph`，它包含了一个顺序表 `Vertices` 和一个二维数组 `edge`，还有一个整数变量 `numOfEdges`。顺序表 `Vertices` 存储了图中的所有顶点，二维数组 `edge` 存储了图中所有边的权值，整数变量 `numOfEdges` 记录了图中边的数量。

在 `Initiate` 函数中，你使用两个嵌套的循环来初始化了一个空图 `G`。具体地，你将 `edge` 数组中的每个元素初始化为一个比较大的数，表示这两个顶点之间没有边。同时，你将 `numOfEdges` 初始化为 0。

在 `InsertVertex` 函数中，你通过调用顺序表的 `ListInsert` 函数，将新的顶点插入到了顺序表 `Vertices` 的末尾。

在 `InsertEdge` 函数中，你首先检查了参数 `v1` 和 `v2` 是否越界，如果越界则输出错误信息并退出程序。如果没有越界，则将边的权值 `weight` 插入到 `edge` 数组中对应的位置上，并将 `numOfEdges` 加 1。

根据你的问题描述，我猜测你可能是在引用 `MatrixGraph` 结构体变量的时候出现了问题。如果你没有正确地定义或者初始化 `MatrixGraph` 结构体变量，那么在引用它的时候可能会出现问题。

你可以检查一下你的代码，在使用 `MatrixGraph` 结构体变量之前是否有正确地定义和初始化它。另外，你也可以提供更多的细节和上下文，这样我才能更好地回答你的问题。

//快速排序 //划分操作 int partition(SqList* L, int low, int high) { low = 0; high = L->length; RedType pivot = L->r[low]; //用子序列的第一个记录作为基准 while (low < high) { //两路快排的方式,使得有大量重复元素的时候,依然能较平均的分布在两个子序列中 // 使用“挖坑法” while (high > low && L->r[high].key >= pivot.key) high--; L->r[low] = L->r[high]; while (low < high && L->r[low].key <= pivot.key) low++; L->r[high] = L->r[low]; } L->r[low] = pivot; //基准记录到位 return low; //返回基准所在位置 } //对顺序表L[low...high]作快速排序 void QuickSort(SqList* L, int low, int high) { if (low < high) {//当序列长度为1时,返回 int pivot = partition(L, low, high); QuickSort(L, low, pivot - 1); QuickSort(L, pivot + 1, high); } }这段代码不能成功进行排序，请改正这段快速排序的代码

在你给出的代码中，有一个问题导致排序无法成功。在划分操作中，传递给 partition 函数的参数 `low` 和 `high` 被重置为了固定的值 0 和 L->length。这会导致递归调用 QuickSort 函数时，每次都传递相同的 `low` 和 `high` 值，导致无限递归。

为了修复这个问题，你应该将划分操作函数的参数修改为传递的 `low` 和 `high`。

以下是修改后的代码：

//划分操作
int partition(SqList* L, int low, int high) {
	RedType pivot = L->r[low]; //用子序列的第一个记录作为基准
	while (low < high) {
		//两路快排的方式,使得有大量重复元素的时候,依然能较平均的分布在两个子序列中
		// 使用“挖坑法”
		while (high > low && L->r[high].key >= pivot.key) high--;
		L->r[low] = L->r[high];
		while (low < high && L->r[low].key <= pivot.key) low++;
		L->r[high] = L->r[low];
	}
	L->r[low] = pivot; //基准记录到位
	return low; //返回基准所在位置
}

//对顺序表L[low...high]作快速排序
void QuickSort(SqList* L, int low, int high) {
	if (low < high) { //当序列长度为1时,返回
		int pivot = partition(L, low, high);
		QuickSort(L, low, pivot - 1);
		QuickSort(L, pivot + 1, high);
	}
}

这样，你应该能够成功地对顺序表进行快速排序了。记得在调用 QuickSort 函数时传递正确的 `low` 和 `high` 值。