线性表的顺序存储结构的实现

1.初始化线性表L，即进行动态存储空间分配并置L为一个空表
2.清除线性表L中的所有元素，释放存储空间，使之成为一个空表
3.返回线性表L当前的长度，若L为空则返回０ 
4.判断线性表L是否为空，若为空则返回1, 否则返回0 
5.返回线性表L中第pos个元素的值，若pos超出范围，则停止程序运行
6.顺序扫描（即遍历）输出线性表L中的每个元素 
7.从线性表L中查找值与x相等的元素，若查找成功则返回其位置，否则返回-1
8.把线性表L中第pos个元素的值修改为x的值，若修改成功返回1，否则返回0
9.向线性表L的表头插入元素x 
10.向线性表L的表尾插入元素x
11.向线性表L中第pos个元素位置插入元素x，若插入成功返回１，否则返回０
12.向有序线性表L中插入元素x,　使得插入后仍然有序
13.从线性表L中删除表头元素并返回它，若删除失败则停止程序运行
14.从线性表L中删除表尾元素并返回它，若删除失败则停止程序运行
15.从线性表L中删除第pos个元素并返回它，若删除失败则停止程序运行
16.从线性表L中删除值为x的第一个元素，若成功返回1，失败返回0 */

/*
#include <iostream>
#include <cstdio>
#include <cstdlib>
using namespace std;

typedef int elemType;

struct List
{
       elemType *list;
       int size;
       int maxsize;
};


//进行内存的重新分配！ 
void againMalloc(struct List *L)
{
     elemType *p = (elemType *)realloc(L->list, 2 * L->maxsize * sizeof(elemType));
     if (!p){
          cout << "内存分配失败！" << endl;
          exit(1); 
     }
     L->list = p;
     L->maxsize = 2 * L->maxsize; 
}


//1.初始化线性表L，即进行动态存储空间分配并置L为一个空表
void initList(struct List *L, int ms)
{
     if (ms < 0){
         cout << "非法分配内存！" << endl;
         exit(1); 
     } 
     L->list = (elemType *)malloc(ms * sizeof(elemType));
     L->size = 0;
     L->maxsize = ms;
     return ; 
} 

//2.清除线性表L中的所有元素，释放存储空间，使之成为一个空表
void clearList(struct List *L)
{
     if (L->list){
         free(L->list);
         L->list = NULL;
         L->size = 0; 
     } 
     return ; 
} 

//3.返回线性表L当前的长度，若L为空则返回０
int sizeList(struct List *L)
{
    return L->size; 
} 
 
//4.判断线性表L是否为空，若为空则返回1, 否则返回0 
int emptyList(struct List *L)
{
    if (L->size == 0)
        return 1;
    else 
        return 0; 
} 

//5.返回线性表L中第pos个元素的值，若pos超出范围，则停止程序运行
elemType getElem(struct List *L, int pos)
{
         if (pos < 1 || pos > L->size){
              cout << "数组越界！" << endl;
              exit(1); 
         } 
         return L->list[pos-1]; 
} 

//6.顺序扫描（即遍历）输出线性表L中的每个元素 
void traverseList(struct List *L)
{
     int i;
     for (i = 0; i < L->size; i++){
         cout << L->list[i] << " "; 
     }
     cout << endl;
     return ; 
} 

//7.从线性表L中查找值与x相等的元素，若查找成功则返回其位置，否则返回-1
int findList(struct List *L, elemType x)
{
    int i;
    for (i = 0; i < L->size; i++){
        if (x == L->list[i])
            return i;
    }
    return -1;
}

//8.把线性表L中第pos个元素的值修改为x的值，若修改成功返回1，否则返回0
int updatePosList(struct List *L, int pos, elemType x) 
{ 
    if (pos < 1 || pos > L->size){
        cout << "元素号越界！" << endl;
        return 0; 
    }
    L->list[pos-1] = x;
    return 1; 
}

//9.向线性表L的表头插入元素x 
void insertFirstList(struct List *L, elemType x)
{
     int i; 
     if (L->size == L->maxsize)
         againMalloc(L);
     for (i = L->size-1; i >= 0; i--)
          L->list[i+1] = L->list[i];
     L->list[0] = x;
     L->size++; 
     return ; 
} 

//10.向线性表L的表尾插入元素x
void insertLastList(struct List *L, elemType x)
{
     if (L->size == L->maxsize)
         againMalloc(L);
     L->list[L->size] = x;
     L->size++;
     return ; 
} 

//11.向线性表L中第pos个元素位置插入元素x，若插入成功返回１，否则返回０
int insertPosList(struct List *L, int pos, elemType x)
{
    int i; 
    if (pos < 1 || pos > L->size){
        cout << "元素号越界！" << endl;
        return 0; 
    } 
    if (L->size == L->maxsize)
        againMalloc(L); 
    for (i = L->size - 1; i >= pos - 1; i--){
        L->list[i+1] = L->list[i]; 
    } 
    L->list[pos-1] = x;
    L->size++;
    return 1; 
} 

//12.向有序线性表L中插入元素x,　使得插入后仍然有序
void insertOrderList(struct List *L, elemType x)
{
     if (L->size == L->maxsize)
         againMalloc(L);
     int i, j;
     for (i = 0; i < L->size; i++){
          if (x > L->list[i])
              break;    
     } 
     for (j = L->size - 1; j >= i; j--)
          L->list[j+1] = L->list[j];
     L->list[i] = x;
     L->size++;
     return ; 
} 

//13.从线性表L中删除表头元素并返回它，若删除失败则停止程序运行
void deleteFirstList(struct List *L)
{
     elemType temp;
     if (L->size == 0){
          cout << "线性表为空，不能进行删除操作！" << endl;
          exit(1); 
     } 
     temp = L->list[0];
     for (int i = 1; i < L->size; i++){
          L->list[i-1] = L->list[i];  
     } 
     L->size--;
     return ; 
} 

//14.从线性表L中删除表尾元素并返回它，若删除失败则停止程序运行
void deleteLastList(struct List *L)                                                          
{
     elemType temp; 
     if (L->size == 0){
         cout << "线性表为空，不能进行删除操作！" << endl;
         exit(1); 
     } 
     temp = L->list[L->size-1];
     L->size--;
     return ; 
} 

//15.从线性表L中删除第pos个元素并返回它，若删除失败则停止程序运行
void deletePosList(struct List *L, int pos)
{
     if (pos < 1 || pos > L->size){
         cout << "元素号越界，不能进行删除操作！" << endl;
         exit(1); 
     } 
     elemType temp;
     temp = L->list[pos-1];
     for (int i = pos; i < L->size; i++){
         L->list[i-1] = L->list[i]; 
     } 
     L->size--;
     return ; 
} 

//16.从线性表L中删除值为x的第一个元素，若成功返回1，失败返回0
int deleteValueList(struct List *L, elemType x)
{
    int i, j;
    for (i = 0; i < L->size; i++){
        if (L->list[i] == x)
            break; 
    } 
    if (i == L->size)
        return 0; 
    for (j = i + 1; j < L->size; j++)
         L->list[j-1] = L->list[j];
    L->size--;
    return 1; 
} 


int main()
{
    int a[10] = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20};
    int i;
    struct List L; 
    initList(&L, 5); 
    for (i = 0; i < 10; i++){
        insertFirstList(&L, a[i]); 
    } 
    insertOrderList(&L, 17);
    traverseList(&L);
    clearList(&L);
    initList(&L, 5); 
    for (i = 0; i < 10; i++){
        insertLastList(&L, a[i]); 
    } 
    updatePosList(&L, 3, 100); 
    traverseList(&L); 
    int pos = findList(&L, 20);
    cout << pos << endl; 
    insertPosList(&L, 5, -1);
    deleteFirstList(&L); 
    deleteLastList(&L);
    deletePosList(&L, 2); 
    deleteValueList(&L, 16); 
    traverseList(&L); 
     
    system("pause");
}