数据结构_顺序表(C语言)_一、按照要求构造顺序表。 1.构造以下顺序表 33 6 8 10 0 3 2 1 2.遍历顺序表(输

（一）顺序表图文解析

顺序表（Sqeuential List）指的是用一组地址连续的存储单位依次存储数据元素的表结构

• 特点:逻辑上相邻的数据元素，其物理次序也是相邻的.

如下图

假设线性表的每个元素占用L个存储单位，并以b为数据元素的存储起始位置；
(例如int整形占4个字节，则L = 4、char字符型占一个字节，则L = 1，还有float、long等)
则线性表中第n个数据元素的存储位置为 b + (n-1) × L 。

用通俗的话来讲

顺序表就像一个可以增加抽屉的屉子，从高到低依次给抽屉编号，你可以在抽屉里存放各种数据类型，顺序表的查找、插入、删除等操作就相当于依照抽屉的编号来查找抽屉里有什么东西，以及拿出或者放入东西。

而在程序中，就是开辟一段连续的空间来存放数据元素，并给每个数据元素依次编号，方便利用数组下标序号来实现查找、插入、删除…等操作。

实际上最简单的顺序表就是数组
创建一个大小为10的整形数组，即是连续的一段存储空间

#include<stdio.h>
int main(){
	int i, arr[10];

	// 赋值
	for(i = 0; i < 10; i++)
	{
		arr[i] = i;
	}
	
	printf("遍历：\n");
	// 遍历
	for(i = 0; i < 10; i++)
	{
		printf("%d  ", arr[i]);
	}
	printf("\n");

	printf("修改第一个元素为100：\n");
	// 修改
	arr[0] = 100;
	for(i = 0; i < 10; i++)
	{
		printf("%d  ", arr[i]);
	}
	printf("\n");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

（二）顺序表代码解析

1. 基本操作

1.1 存储结构

#define MaxSize 50

typedef char DataType;	//自定义数据类型
typedef struct			//定义顺序表结构体类型
{
	DataType *Data;		//用于存放数据
	int Length;			//记录顺序表长度
}SqList;
1
2
3
4
5
6
7
8

1.2 初始化

void InitList(SqList *L)
{
	//为顺序表分配空间
	L->Data = (DataType *)malloc(MaxSize * sizeof(DataType));
	L->Length = 0;
	printf("顺序表已初始化!\n");
}
1
2
3
4
5
6
7

1.3 插入数据

void ListInsert(SqList *L)
{
	if (L->Data != NULL)
	{
		int i, j;
		DataType x;

		printf("请输入插入的位置和数据:");
		scanf("%d %c", &i, &x);

		// 1、插入的位置必须在顺序表长度的范围内
		// 2、顺序表长度必须小于顺序表最大长度，否则再插入数据就会越界溢出
		if (i > 0 && i <= L->Length + 1 && L->Length < MaxSize )
		{
			// 插入位置后的所有元素向后移动一个位置
			for (j = L->Length; j >= i ; j--)
			{
				L->Data[j] = L->Data[j - 1];
			}
			// 完成插入操作
			L->Data[i - 1] = x;
			L->Length++;
			printf("插入成功!\n");
		}else{
			printf("插入失败!\n");
		}
	}
	else
	{
		printf("顺序表已销毁!\n");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

1.4 删除数据

void ListDelete(SqList *L)
{
	if (L->Data != NULL)
	{
		int i, j;

		printf("请输入需要删除的位置:");
		scanf("%d", &i);

		// 删除的位置必须在长度范围内
		if (i > 0 && i <= L->Length)
		{
			// 删除位置后的所有元素前移一个位置
			for ( j = i - 1; j < L->Length; j++)
			{
				L->Data[j] = L->Data[j + 1];
			}
			L->Length--;
			printf("删除成功!\n");
		}else{
			printf("删除失败!\n");
		}
	}
	else
	{
		printf("顺序表已销毁!\n");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

1.5 修改数据

void ListModify(SqList *L)
{
	if (L->Data != NULL)
	{
		int i, j;
		DataType x;

		printf("请输入需要修改的位置和修改数据:");
		scanf("%d %c", &i, &x);

		// 修改的位置必须在长度范围内
		if (i > 0 && i <= L->Length)
		{
			L->Data[i - 1] = x;
			printf("修改成功!\n");
		}
		else
		{
			printf("修改失败!\n");
		}
	}
	else
	{
		printf("顺序表已销毁!\n");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

2. 源代码及测试

2.1 源代码

#include<stdio.h>
#include<stdlib.h>

#define MaxSize 5

typedef char DataType;
typedef struct
{
	DataType *Data;
	int Length;
}SqList;

// 初始化顺序表
void InitList(SqList *L)
{
	L->Data = (DataType *)malloc(MaxSize * sizeof(DataType));
	L->Length = 0;
	printf("顺序表已初始化!\n");
}

// 插入
void ListInsert(SqList *L)
{
	if (L->Data != NULL)
	{
		int i, j;
		DataType x;

		printf("请输入插入的位置和数据:");
		scanf("%d %c", &i, &x);

		// 1、插入的位置必须在顺序表长度的范围内
		// 2、顺序表长度必须小于顺序表最大长度，否则再插入数据就会越界溢出
		if (i > 0 && i <= L->Length + 1 && L->Length < MaxSize )
		{
			// 插入位置后的所有元素向后移动一个位置
			for (j = L->Length; j >= i ; j--)
			{
				L->Data[j] = L->Data[j - 1];
			}
			// 完成插入操作
			L->Data[i - 1] = x;
			L->Length++;
			printf("插入成功!\n");
		}else{
			printf("插入失败!\n");
		}
	}
	else
	{
		printf("顺序表已销毁!\n");
	}
}

// 删除
void ListDelete(SqList *L)
{
	if (L->Data != NULL)
	{
		int i, j;

		printf("请输入需要删除的位置:");
		scanf("%d", &i);

		// 删除的位置必须在长度范围内
		if (i > 0 && i <= L->Length)
		{
			// 删除位置后的所有元素前移一个位置
			for ( j = i - 1; j < L->Length; j++)
			{
				L->Data[j] = L->Data[j + 1];
			}
			L->Length--;
			printf("删除成功!\n");
		}else{
			printf("删除失败!\n");
		}
	}
	else
	{
		printf("顺序表已销毁!\n");
	}
}

// 修改
void ListModify(SqList *L)
{
	if (L->Data != NULL)
	{
		int i, j;
		DataType x;

		printf("请输入需要修改的位置和修改数据:");
		scanf("%d %c", &i, &x);

		// 修改的位置必须在长度范围内
		if (i > 0 && i <= L->Length)
		{
			L->Data[i - 1] = x;
			printf("修改成功!\n");
		}
		else
		{
			printf("修改失败!\n");
		}
	}
	else
	{
		printf("顺序表已销毁!\n");
	}
}

// 遍历顺序表
void DisplayList(SqList L)
{
	if (L.Data != NULL)
	{
		if (L.Length)
		{
			int i;
			printf("遍历结果:");
			for (i = 0; i < L.Length; i++)
			{
				printf("%c ", L.Data[i]);
			}
			printf("\n");
		}else{
			printf("顺序表为空!\n");
		}
	}
	else
	{
		printf("顺序表已销毁!\n");
	}
}

// 清空顺序表
void ClearList(SqList *L)
{
	if (L->Data != NULL)
	{
		int i;
		for (i = 0; i < L->Length; i++)
		{
			L->Data[i] = '\0';
		}		
		L->Length = 0;
		printf("顺序表已清空!\n");
	}
	else
	{
		printf("顺序表已销毁!\n");
	}
}

// 销毁顺序表
void DestroyList(SqList *L)
{
	if (L->Data)
	{
		free(L->Data);
		L->Data = NULL;
		L->Length = 0;
		printf("顺序表已销毁!\n");
	}
	else
	{
		printf("顺序表已销毁!\n");
	}
}

int main(){
	printf("************************************\n");
	printf("0:退出\t1:初始化\t2:插入\t3:删除\n");
	printf("4:修改\t5:遍历\t\t6:清空\t7:销毁\n");
	printf("************************************\n");
	
	int k;
	SqList L;
	InitList(&L);
	while (1)
    {
        printf("请输入操作序号:");
        scanf("%d", &k);
		if (!k)
		{
			break;
		}
		switch (k)
		{
			case 1:InitList(&L);	break;
			case 2:ListInsert(&L);	break;
			case 3:ListDelete(&L);	break;
			case 4:ListModify(&L);	break;
			case 5:DisplayList(L);	break;
			case 6:ClearList(&L);	break;
			case 7:DestroyList(&L);	break;
			default:break;
		}
		printf("\n");
	}
	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204

2.2 测试结果