目录
一、顺序表的相关概念
1.顺序表：在逻辑结构上是线性表，在物理存储结构上是顺序存储（用连续的存储单元存储）
A)顺序表满足线性表的特征
B)顺序表采用顺序地址映像——地址可计算
——可以实现随机访问
顺序表存储的地址可计算的相关解释
i>数组名表示数组首元素地址 a等价于&a[0]
ii>ADD(a[i])=ADD(a[0])+i*类型大小
（特别的在c语言中并不用计算字节数只需要下标也就是偏移量，所以a[i]的地址：a+i ）
2.预备性操作
我们采用数组模拟顺序表
A)数组长度可计算
例：int a[8]={1,2,3,4,5,6,7,8};
int n;
n = sizeof(a)/sizeof(a[0]);
B)动态数组定义
例：int *a；
a = (int *)malloc(数组长度*sizeof(int));
C)数组传递
i>定义数组
#include<stdio.h>
void fun(int a[],int n)
{
printf("%d\n",sizeof(a));//打印值为4
}
int main()
{
int a[8]={1,2,3,4,5,6,7,8};
int n = sizeof(a)/sizeof(a[0]);
fun(a,n);//两要素：首元素地址和长度
printf("%d\n",sizeof(a));//打印值为32
}我们可以得到主函数里的a是数组名a，而函数fun里的形参a是指针常量a不可改变。
ii>动态数组参数传递
#include<stdio.h>
#include<stdlib.h>
void fun(int a[],int n)
{
printf("%d\n",sizeof(a));//打印值为4
}
int main()
{
int *a;
a=(int *)malloc(8*sizeof(int));
int n = sizeof(a)/sizeof(a[0]);
fun(a,n);//两要素：首元素地址和长度
printf("%d\n",sizeof(a));//打印值为4
}我们不难得出这里主函数的a是指针常量a，而函数fun里的形参a也是指针常量。
二、顺序表的代码实现
1.遍历顺序表
遍历可以说是顺序表中最简单的一部分，这里直接举一个例子帮助大家理解一下
例：有顺序表a = {3,2,5,8,4,7,6,9} 将该数组输出k圈
当k = 3时
输出
3 2 5 8 4 7 6 9
3 2 5 8 4 7 6 9
3 2 5 8 4 7 6 9
分析：咱们最先想到的就是一圈的情况，就是遍历数组输出数组，k圈就是双层循环一层控制圈数，一层遍历数组。
代码实现:
void fun(int a[],int n,int k)
{
for(int i = 0;i < k;i++){
for(int j = 0;j < n;j++){
printf("%d ",a[j]);
}
printf("\n");
}
}结果如下图：
时间复杂度：o（n²）
二次分析：这个题目用双层循环实现在思路上是简单的，但是世家复杂度确实过高，那么如何在o（n）的时间复杂度情况下实现呢？ 不难看出，其实所谓圈数，就是循环输出三次，循环然我们想到了循环队列，所以我们可以依靠取余来实现所谓的圈数输出。
代码如下：
void fun(int a[],int n,int k)
{
for(int i = 0;i < k*n;i++){
if(i%8==0&&i>0){
printf("\n");
}
printf("%d ",a[i%8]);
}
}结果如下：
2.移动顺序表
例：设有顺序表 a = {3,2,5,8,4,7,6,9}要求将顺序表前k个元素移至最后 如果k=3 结果是 a = {8,4,7,6,9,3,2,5}
方法一：将第一个数据元素保存下来，将之后的n-1个元素依次向前移动一个单位长度，最后将保下来的第一个数据元素赋值给最后一个，循环k次
时间复杂度 o（n²）
代码如下
for(i = 0; i < k; i++){
int t = a[0];
for(j = 0; j < n-1; j++){
a[j] = a[j+1];
}
a[j] = t;
}
方法一的变体 将循环体里的加进了判断条件里
for(i = 0; i < k; i++){
int t = a[0];
for(j = 0; j < n-1&&(a[j] = a[j+1],1); j++);
a[j] = t;
}结果如下：
方法二：类似于交换排序，第一个数据元素和之后的元素依次交换，一次交换完成第一个元素移动到最后一个，循环k次
时间复杂度 o（n²）
代码如下
for(i = 0; i < k; i++){
for(j = 0; j < n-1; j++){
int t = a[j];
a[j] = a[j+1];
a[j+1] = t;
}
}结果如下：
方法三：反转，将整个数组反转，就将前k个弄到后面去了，只不过顺序是反的，将前n-k个反转，将后k个反转就可以得到结果。
详细分析如下：
3 2 5 8 4 7 6 9 反转 9 6 7 4 8 5 2 3
我们不难看出5 2 3已经在后面就是顺序反了，而且前面的部分也是恰好相反的，所以9 6 7 4 8 取反， 5 2 3 也取反就得到 8 4 7 6 9 3 2 5了
代码实现：
#include<stdio.h>
void exchange(int a[],int n){
for(int i = 0,j = n - 1; i < j; j--,i++){
int t = a[i];
a[i] = a[j];
a[j] = t;
}
}
int main()
{
int a[8] = {3,2,5,8,4,7,6,9};
int n = sizeof(a)/sizeof(a[0]);
int k = 3;
int i,j;
exchange(a,n);
exchange(a,n-k);
exchange(a+n-k,k);
for(int k = 0; k < n; k++){
printf("%d ",a[k]);
}
return 0;
}结果如下：
3顺序表的查找
定义：在顺序表中按照给定的关键字查找某一数据元素
例：设顺序表 a = {3，2，5，8，4，7，6，9}无序且无重复值，给定一关键字key在顺序表中查找关键字key若找到返回下标，未找到返回-1
分析：在数组遍历过程中，找到一个相等的就break，这就是最简单的思路。
代码实现：
for(i = 0; i < n; i++){
if(a[i] == k){
break;
}
}根据这个代码我们可以继续分析一下：
循环结束的两种情况：
1. i == n -> end
2. i < n && a[i] == k -> end
因为是两种相反的情况，是i==n结束或者a[i]==k结束，所以运行的情况就是再取反所以判断条件是 i < n && a[i] - k，a[i] - k 就是两个不相等
代码总体实现如下：
#include<stdio.h>
int Search(int a[],int n,int k){
int i;
for(i = 0;i < n&&a[i]-k; i++);
/*for(i = 0; i < n; i++){
if(a[i] == k){
break;
}
}*/
/*if(i < n){
return i;
}else{
return -1; //软件工程要求单入口单出口 所以舍弃
}*/
//return (i<n)?(i):(-1); // 但是由于运算符号太多 最好加上括号
if(i == n) //推荐写法
i = -1;
return i;
}
int main()
{
/*查找操作在顺序表中查找关键字key，若找到返回下标，未找到返回-1
时间复杂度为 n
*/
int a[8] = {3,2,4,8,4,7,6,9};
int n = sizeof(a)/sizeof(a[0]);
int k = 8;
printf("%d ",Search(a,n,k));
return 0;
}结果如下：
8的下标是3，正确。
时间复杂度：o（n） 平均查找长度： （1+n）/2
4顺序表的删除
定义：在一个顺序表中删除关键字为key的数据元素
A)无序无重复值
总体算法：第一步 查找 第二步 删除
详细分析：
查找如下：
for(i = 0;i < n&&a[i]-key;i++);查找完成后分为两种情况
case1 i==n ->没找到
case2 i<n ->删除
在情况二的基础上进行删除操作
for(j = i;j < n-1;j++){
a[j] = a[j+1];
}
等价于
for(j = i;j < n-1&&(a[j] = a[j+1] ,1);j++);特别注意：
i>每删除一个数据元素长度就减一
ii>顺序表的删除时间复杂度为 o（n），时间复杂度为 o（1），并且带动了大量数据的移动。
总的代码实现：
#include<stdio.h>
int del(int a[],int n,int key)
{
int i,j;
for(i = 0;i < n&& a[i]-key;i++);
if(i == n){
printf("没有找到");
return n;
}
for(j = i;j<n-1&&(a[j]=a[j+1],1);j++);
n--;
return n;
}
int main()
{
int a[8]={3,2,5,8,4,7,6,9};
int k,n;
n = sizeof(a)/sizeof(a[0]);
for(int i = 0;i < n;i++){
printf("%d ",a[i]);
}
printf("\n请输入删除的数：");
scanf("%d",&k);
n = del(a,n,k);
for(int i = 0;i < n;i++){
printf("%d ",a[i]);
}
return 0;
}运行结果：
B)无序且有重复值
例如 3 2 5 2 2 7 2 9
删除 2
结果为：3 5 7 9
方法一：因为有多个关键字，就不能一找到就跳出查找了，需要进行边找边删的操作
case1 是关键字就删除操作
case2 不是关键字，继续遍历顺序表
所以我们就得出了第一代代码如下：
int del(int a[],int n,int key)
{
int i,j;
for(i = 0;i < n;){
if(key - a[i]){
i++;
}else{
for(j = i;j<n-1&&(a[j]=a[j+1],1);j++);
n--;
}
}
return n;
}结果如下：
方法二：可以创建一个新的数组，如果是关键字，就不插入数组，不是就插入新的数组
for(i = 0; i< n;){
if(a[i]==key){
i++;
}else{
b[j++] = a[i++];
}
}
基于这段代码不难发现，两种情况都是要i++的，所以做了小小的改进
for(i = 0; i< n;i++){
if(a[i]!=key){
b[j++] = a[i];
}
}思考：方法二是两个数组实现了删除操作，其实咱们可以将两个数组重合，实现一个数组实现删除操作
case1 不是关键字 写入本数组 也就是 a[j++] = a[i] （刚开始可能i=j，后面经历了关键字i就会大于j，会实现后面的不是关键字的数据元素，会对j所指的进行覆盖，从而达到删除的目的）
case2 是关键字直接跳过
图解如下：
代码如下：
int del(int a[],int n,int key)
{
int i,j;
for(i = 0,j = 0;i < n ;i++){
if(a[i]-key){
a[j++] = a[i];
}
}
return j;
}结果如下：
5顺序表的插入
特别注意：
i>顺序表存储要足够大
ii>顺序表的插入也要带动大量数据元素的移动
分析：就是将插入位置位置及以后的数据元素全部后移一个单位，将key插入目标位置
void insert(int a[],int n,int i,int key){
int j;
for(j = n-1;j>i;j--){
a[j] = a[j-1];
}
a[i] = key;
}结果如下：
原数组的最后一个数据为0，是因为它没有赋值，默认为0，并不是测试数据就是0，
7581
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
