C代碼實現順序表
打開VS2017，新建一個空的c項目，再創建如下頭文件和c文件，
該順序表分爲兩種存儲形式，一種是動態存儲，一種是靜態存儲。靜態存儲一次性申請所需空間，而動態存儲可以進行靈活申請存儲空間，二者差別不大，動態存儲無非是多了申請內存空間這個步驟，算法思想都差不多。以下是代碼：
靜態分配的頭文件代碼：
#pragma once
#include<stdio.h>
#include<stdlib.h>
///靜態分配頭文件
#define MAXSIZE 1000
typedef int EleType;//數據類型
typedef struct//結構體
{
EleType Selem[MAXSIZE];//申請MAXSIZE個數據元素存儲的空間
unsigned length;//順序表當前長度0--MAXSIZE-1
}Slist;
///定義線性表的操作函數
Slist* Init_Slist();//初始化線性表
void InsertSlist(Slist* L, unsigned i, EleType e);//在L線性表的第i個元素(邏輯位置)前插入一個元素
unsigned GetSlistLength(Slist L);//獲取線性表長度
EleType GetSElem(Slist L, unsigned i);//獲取第i個位置的元素（邏輯位置）
unsigned LocateSElem(Slist L, EleType e);//確定e在線性表的第幾個位置
void SListDelete(Slist* L, int i, EleType* e);//刪除第幾個元素
void PrintSlist(Slist L);//遍歷線性表
int EmptySlist(Slist L);//線性表判空
void DestroySlist(Slist* L);//釋放線性表內存
靜態分配.c：函數實現代碼：
#include"靜態分配.h"
///靜態分配的函數實現代碼
///定義線性表的操作函數
//初始化線性表
Slist* Init_Slist()
{
Slist* L = (Slist*)malloc(sizeof(Slist));
L->Selem[MAXSIZE] = (EleType*)malloc(MAXSIZE * sizeof(EleType));
L->length = 0;
return L;
}
//在L線性表的第i個元素(邏輯位置)前插入一個元素,注意這裏使用的是邏輯位置
void InsertSlist(Slist* L, unsigned i, EleType e)
{
printf("當前長度爲：%d\n", L->length);
if (L->length >= MAXSIZE)
{
printf("內存溢出!!!\n");
}
if (i<1 || i>=MAXSIZE)
{
printf("非法邏輯位置！！！\n");
}
//if (L->length == 0)
//{
// printf("線性表長度爲0,靜態分配失敗");
// exit(0);
//}
if (L->length == 0)
{
L->Selem[L->length] = e;
L->length++;
printf("length=0插入元素：%d\n", L->Selem[0]);
}
else
{
for (unsigned j = L->length; j >= i - 1; j--)
{
if (j <= 0)
{
break;
}
printf("L.selem[%d]:%d\n",j-1,L->Selem[j-1]);
L->Selem[j] = L->Selem[j - 1];
}
L->Selem[i - 1] = e;
L->length++;
printf("插入成功！！！\n");
}
return;
}
//獲取線性表長度
unsigned GetSlistLength(Slist L)
{
return L.length;
}
//獲取第i個位置的元素（邏輯位置）
EleType GetSElem(Slist L, unsigned i)
{
if (i<1 || i>L.length)
{
printf("非法邏輯位置！！！\n");
exit(0);
}
return L.Selem[i-1];
}
//確定e在線性表的第幾個位置(返回邏輯位置)
unsigned LocateSElem(Slist L, EleType e)
{
int flag=-1;
for (int i = 0; i < L.length-1; i++)
{
if (L.Selem[i] == e)
{
flag = i;
break;
}
}
if (flag == -1)
{
printf("未找到該元素位置\n");
return flag;
}
return flag + 1;
}
//刪除第i個元素(邏輯位置),並且把元素放在e上
void SListDelete(Slist* L, unsigned i, EleType* e)
{
if (L->length == 0)
{
printf("空表不能進行刪除！！！");
exit(0);
}
if (i<1 || i>L->length)
{
printf("非法邏輯位置");
exit("非法邏輯位置");
}
*e = L->Selem[i - 1];
/*for (EleType *p = L->Selem[i]; p >=L->Selem[L->length-1]; p++)
{
*(p - 1) = *p;
}*/
for (int j = i; j < L->length; j++)
{
L->Selem[j - 1] = L->Selem[j];
}
L->length--;
printf("成功刪除！！！\n");
}
//遍歷線性表
void PrintSlist(Slist L)
{
for (int i = 0; i < L.length; i++)
{
printf("%d ", L.Selem[i]);
}
printf("\n");
}
//線性表判空
int EmptySlist(Slist L)
{
if (L.length == 0)
{
return 0;
}
else
{
return 1;
}
}
//釋放線性表內存
void DestroySlist(Slist *L)
{
if (!L->Selem)
exit(0);
free(L->Selem);
L->length = 0;
printf("釋放內存成功\n");
}
動態分配的頭文件代碼
#pragma once
///動態分配的頭文件
#include<stdio.h>
#include<stdlib.h>
typedef int Eletype;
#define initSize 1000
#define incSize 500
typedef struct
{
Eletype* Delem;
unsigned length;
}Dlist;
//初始化線性表
Dlist* InitDlist();
//插入元素
void InsertDlist(Dlist* L, unsigned i, Eletype e);
//求線性表長度
unsigned DlistLength(Dlist L);
//根據位置獲取線性表第i個元素，i爲邏輯位置
Eletype getDelemByPos(Dlist L, unsigned i);
//確定e是線性表第幾個元素
unsigned LocateDElem(Dlist L, Eletype e);
//刪除第i個元素,i爲邏輯位置
void ListDeleteDelem(Dlist* L, unsigned i);
//遍歷打印線性表
void PrintDlist(Dlist L);
//線性表判空
int EmptyDlist(Dlist L);
//銷燬線性表
void DestroyDlist(Dlist* L);
動態分配.c：函數實現
#include"動態分配.h"
///動態分配的函數實現
//初始化線性表
Dlist* InitDlist()
{
Dlist* list = (Dlist*)malloc(sizeof(Dlist));
list->Delem = (Eletype*)malloc(initSize * sizeof(Eletype));
list->length = 0;
return list;
}
//插入元素
void InsertDlist(Dlist* L, int i, Eletype e)
{
if (L->length == initSize)
{
Eletype *p;
p = (Eletype*)realloc(L->Delem, (initSize + incSize) * sizeof(Eletype));
if (!p)
{
printf("內存分配失敗！！！\n");
exit(0);
}
L->Delem = p;
}
if (L->length == 0)//如果線性表沒有元素，則直接給第一個地址賦值
{
L->Delem[0] = e;
printf("元素%d插入成功 \n", e);
L->length ++;
}
else
{
if (i<1 || i>L->length)
{
printf("插入位置有誤!!!");
exit(0);
}
for (int j = L->length - 1; j >= i - 1; j--)
{
if (j < 0)
{
printf(" %d小於0 ",j);
break;
}
L->Delem[j + 1] = L->Delem[j];
}
L->Delem[i - 1] = e;
printf("元素%d插入成功\n", e);
L->length++;
}
}
//求線性表長度
unsigned DlistLength(Dlist L)
{
return L.length;
}
//根據位置獲取線性表第i個元素，i爲邏輯位置
Eletype getDelemByPos(Dlist L, unsigned i)
{
if (&L == NULL) return NULL;
if (i<1 || i>L.length)
{
printf("查找位置出錯!!!");
exit(0);
}
return L.Delem[i - 1];
}
//確定e是線性表第幾個元素,邏輯位置
unsigned LocateDElem(Dlist L, Eletype e)
{
int i;
for (i = 0; i < L.length; i++)
{
if (e == L.Delem[i])
{
break;
}
}
if (i == L.length)
{
return -1;
}
else
{
return i + 1;
}
}
//刪除第i個元素,i爲邏輯位置
void ListDeleteDelem(Dlist* L, unsigned i)
{
if (L->length == 0) exit(0);
if (i<1 || i>L->length)
{
exit(0);
}
for (int j = i; j < L->length; j++)
{
L->Delem[j - 1] = L->Delem[j];
}
L->length--;
}
//遍歷打印線性表
void PrintDlist(Dlist L)
{
for (int i = 0; i <L.length; i++)
{
printf("打印元素：%d", L.Delem[i]);
}
printf("\n");
}
//線性表判空
int EmptyDlist(Dlist L)
{
if (L.length == 0)
{
return 1;
}
else
{
return 0;
}
}
//銷燬線性表
void DestroyDlist(Dlist* L)
{
if (!L->Delem) { exit(0); }
free(L->Delem);
L->length = 0;
}
測試文件頭文件
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void TestSlistTest();//靜態分配測試
void TestDlistTest();//動態分配的測試
測試文件.c函數實現
#include"測試文件.h"
#include"靜態分配.h"
#include"動態分配.h"
void TestSlistTest()//靜態分配測試
{
printf("------------------------靜態分配的測試--------------------\n");
Slist* SL = Init_Slist();
InsertSlist(SL, 1, 10);
InsertSlist(SL, 1, 20);
InsertSlist(SL, 1, 30);
InsertSlist(SL, 1, 40);
InsertSlist(SL, 1, 50);
InsertSlist(SL, 1, 60);
PrintSlist(*SL);
EleType e = GetSElem(*SL, 2);
printf("e:%d\n", e);
unsigned pos = LocateSElem(*SL, 50);
printf("pos:%d\n", pos);
EleType* del = (EleType*)malloc(sizeof(EleType));
SListDelete(SL, 2, del);
PrintSlist(*SL);
DestroySlist(SL);
printf("------------------------靜態分配的測試--------------------\n");
}
void TestDlistTest()//動態分配的測試
{
printf("------------------------動態分配的測試--------------------\n");
Dlist* DL = InitDlist();
printf("%d\n",EmptyDlist(*DL));//判斷是否爲空
InsertDlist(DL, 1, 20);
InsertDlist(DL, 1, 30);
InsertDlist(DL, 1, 40);
InsertDlist(DL, 1, 50);
InsertDlist(DL, 1, 90);
PrintDlist(*DL);
InsertDlist(DL, 2, 99);
PrintDlist(*DL);
DestroyDlist(DL);
printf("------------------------動態分配的測試--------------------\n");
}
最後的順序表.c文件：
#include"測試文件.h"
int main()
{
TestSlistTest();//靜態分配的測試
TestDlistTest();//動態分配的測試
system("pause");
}
#以上就是實現順序表的操作，如有問題，歡迎指正。