c语言 顺序表 有序表,顺序表(数据结构)

本篇文章主要针对《数据结构》中的顺序表的增删查改以及一些常用算法进行详尽的代码描述。本代码使用c语言书写，并且通过测试。可以直接拷贝编译，在你的main函数中进行测试。

#include

#include

#define MaxSize 50 //顺序表的表长

#define InitSize 100 //顺序表的初始表长

typedef struct {

int data[MaxSize]; //顺序表的元素

int length; //顺序表的长度

}SqList; //顺序表的类型定义

typedef struct{

int *data; //指示动态分配的数组指针

int dataSize,length; //数组的最大容量和当前储存元素的个数

}mSqList;

/*

* [InitList 顺序表初始化函数]

* @param L [传入需要初始化的顺序表]

* @return [成功初始化返回 1]

*/

int InitList(mSqList *L,int size){

for (int i = 0; i < size; i++) {

L->data[i] = rand()%1000;

}

L->dataSize = InitSize;

L->length = size;

return 1;

}

/**

* [Length 计算表长]

* @param L [传入需要计算长度的顺序表]

* @return [返回表长]

*/

int Length(mSqList L){

return L.length;

}

/**

* [LocateElem 查找元素e所在的位置]

* @param L [传入需要查找的顺序表]

* @param e [需要查找的元素e]

* @return [成功查找返回元素的位置，查找失败返回-1]

*/

int LocateElem(mSqList L,int e){

for(int i = 0; i < L.length; i++)

{

if(L.data[i] == e)

{

return i+1;

}

}

return -1;

}

/**

* [GetElem 按位置查找元素]

* @param L [传入需要查找的顺序表]

* @param position [传入需要查找的位置position]

* @return [查找成功返回查找元素，查找失败返回-1]

*/

int GetElem(mSqList L,int position){

if (position <= 0 || position > L.length)

{

return -1;

}

return L.data[position - 1];

}

/**

* [ListInsert 向线性表对应位置i插入元素e]

* @param L [需要插入的顺序表]

* @param i [元素插入的位置]

* @param e [插入的元素]

* @return [成功返回 1，插入失败返回-1]

*/

int ListInsert(mSqList *L,int i,int e){

if (i < 1 | i > L->length + 1)

{

return -1;

}

if (L->length >= L->dataSize)

{

return -1;

}

for (int j = L->length; j >= i; j--)

{

L->data[j] = L->data[j-1];

}

L->data[i-1] = e;

L->length++;

return 1;

}

/**

* [ListDelete 删除顺序表中位置i的元素]

* @param L [待删除的顺序表]

* @param i [待删除元素的位置]

* @return [成功返回删除元素的值 e，失败返回 -1]

*/

int ListDelete(mSqList *L,int i)

{

int e = 0;

if (i < 1 || i > L->length)

{

return -1;

}

e = L->data[i-1];

for (int j = i; j < L->length; j++)

{

L->data[j-1] = L->data[j];

}

L->length--;

return e;

}

/**

* [ListMinDelete 删除顺序表中最小的元素]

* @param L [待删除的顺序表]

* @return [成功返回删除的元素 e，失败返回 -1]

*/

int ListMinDelete(mSqList *L)

{

int tmp = L->data[0];

int position = 0;

if(L->length < 1)

{

return -1;

}

for (int i = 0; i < L->length; i++)

{

if(tmp > L->data[i])

{

tmp = L->data[i];

position = i;

}

}

L->data[position] = L->data[L->length-1];

L->length--;

return tmp;

}

/**

* [ListReverse 将顺序表原地逆置]

* @param L [需要逆置的顺序表]

* @return [成功返回 1，失败返回 -1]

*/

int ListReverse(mSqList *L)

{

int tmp = 0;

if(L->length <= 0)

{

return -1;

}

for(int i = 0; i < L->length / 2; i++)

{

tmp = L->data[i];

L->data[i] = L->data[L->length - i - 1];

L->data[L->length - i - 1] = tmp;

}

return 1;

}

/**

* [ListElemDelete 删除顺序表中所有相同的元素]

* @param L [待删除的顺序表]

* @param x [待删除的元素 x]

* @return [成功删除反回删除后顺序表的长度 length，失败则返回 -1]

*/

int ListElemDelete(mSqList *L,int x)

{

int k = 0;

int delNUm = 0;

if(L->length <= 0)

{

return -1;

}

for (int i = 0; i < L->length; i++)

{

if(L->data[i] != x)

{

L->data[k] = L->data[i];

k++;

}

}

delNUm = L->length - k;

L->length = k;

return delNUm;

}

/**

* [ListRangeDelete 删除顺序表中在start 和 stop 范围内的 元素]

* @param L [待删除的顺序表]

* @param start [删除值范围的最小值]

* @param stop [删除值范围的最大值]

* @return [成功返回以删除的元素个数，失败返回-1]

*/

int ListRangeDelete(mSqList *L,int start,int stop)

{

int k = 0;

int delNUm = 0;

if (start > stop)

{

return -1;

}

if (L->length <= 0)

{

return -1;

}

for (int i = 0; i < L->length; i++)

{

if(L->data[i] < start || L->data[i] > stop)

{

L->data[k] = L->data[i];

k++;

}

}

delNUm = L->length - k;

L->length = k;

return delNUm;

}

/**

* [ListDumpDelete 删除有序的顺序表中含重复元素的项]

* @param L [待删除的有序顺序表]

* @return [成功返回删除返回删除元素个数，失败返回 -1]

*/

int ListDumpDelete(mSqList *L)

{

int k = 0;

int len = 0;

if(L->length <=0 )

{

return -1;

}

for (int i = 1; i < L->length; i++)

{

if (L->data[k] != L->data[i])

{

L->data[++k] = L->data[j];

}

}

len = L->length - k - 1;

L->length = k + 1;

return len;

}

/**

* [ListBindSorted 将两个有序表进行合并，并且将合并后的有序表返回]

* @param L1 [待合并的有序表L1]

* @param L2 [待合并的有序表L2]

* @param L3 [合并后的有序表L3]

* @return [成功返回 1，失败返回 -1]

*/

int ListBindSorted(mSqList *L1, mSqList *L2, mSqList *L3)

{

if (L1->length + L2->length > L3->dataSize)

{

return -1;

}

int i = 0;

int j = 0;

int k = 0;

while(i < L1->Length && j < L2->length)

{

if (L1->data[i] < L2->data[j])

{

L3->data[k++] = L1->data[i++];

}else {

L3->data[k++] = L2->data[j++];

}

}

while(i < L1->length)

{

L3->data[k++] = L1->data[i++];

}

while(j < L2->length)

{

L3->data[k++] = L2->data[j++];

}

L3->length = k;

return 1;

}