順序表的創建，插入，刪除，查找，逆序以及合併兩個有序的順序表

SeqList.h文件：

#ifndef __SEQLIST_H__

#define __SEQLIST_H__


#define FALSE  -1
#define TRUE    0


#define INIT_SIZE     100
#define INCRESS_SIZE  20  




typedef int SeqData;


// 順序表結構
typedef struct _seqList
{
SeqData *list;  // 指向存儲空間的指針
int max_len;       // 保存存儲空間最大長度
int len;           // 保存當前使用的長度
}SeqList;




// 創建順序表
SeqList *Create_List();


// 銷燬順序表
void Destroy(SeqList *s);


// 插入數據：尾插法
int Insert_Last(SeqList *s, SeqData data);


// 插入數據：頭插法
int Insert_Head(SeqList *s, SeqData data);


// 插入數據：在下標爲 pos 的位置插入數據
int Insert_Pos(SeqList *s, int pos, SeqData data);


int GetData(SeqList *s, int pos, SeqData *x);


// 查找元素，如果找到，將該元素的下標給x
int FindData(SeqList *s, SeqData data, SeqData *x);


// 刪除 pos 下標的元素
int Delete_Pos(SeqList *s, int pos);


// 刪除指定數據
int Delete_Data(SeqList *s, SeqData data);


// 逆序
int Reverse_List(SeqList *s);


// 將兩個順序表合併成一張順序表
// 前提：兩張表都是排好序表
// 合併後的表要求是從小到大排列的，函數返回新表的指針
SeqList * Merge_List(SeqList *s1, SeqList *s2);


void Display(SeqList *s);

#endif // __SEQLIST_H__

SeqList.c文件：

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


SeqList *Create_List()
{
// 創建一個順序表
SeqList* s = (SeqList*)malloc(sizeof(SeqList)/sizeof(char));
if (s == NULL)
{
return NULL;
}

// 初始化順序的成員
// 爲順序表分配存儲空間
s->list = (SeqData *)malloc(sizeof(SeqData)/sizeof(char)*INIT_SIZE);
if (s->list == NULL)
{
free(s);  // 創建存儲空間失敗，先釋放順序表結點
return NULL;
}
s->max_len = INIT_SIZE;
s->len = 0;

return s;
}


void Destroy(SeqList *s)
{
if (s == NULL)
return;

// 先釋放存儲空間
free (s->list);

// 釋放順序表
free (s);
}


int AgainMalloc(SeqList *s)
{
if (s == NULL)
return FALSE;

// 新申請空間的字節數
int new_size = sizeof(SeqData)/sizeof(char)*(INIT_SIZE + INCRESS_SIZE);
SeqData* tmp = (SeqData*)realloc(s->list, new_size);
if (tmp == NULL)
{
return FALSE;
}
s->list = tmp;
s->max_len += INCRESS_SIZE;



return TRUE;
}


int Insert_Last(SeqList *s, SeqData data)
{
if (s == NULL)
{
return FALSE;
}

// 檢測順序表是否存滿
if (s->len == s->max_len)
{
// 擴展空間
if (AgainMalloc(s) != TRUE)
{
return FALSE;
}
}


// 插入數據
s->list[s->len] = data;
s->len++;

return TRUE;
}


int Insert_Head(SeqList *s, SeqData data)
{
if (s == NULL)
return FALSE;

// 檢測順序表是否存滿
if (s->len == s->max_len)
{
if (AgainMalloc(s) != TRUE)
{
return FALSE;
}
}

// 進行移位
int i;
for (i = s->len-1; i >= 0; i--)
{
s->list[i+1] = s->list[i];
}

s->list[0] = data;
s->len++;


return TRUE;
}


int Insert_Pos(SeqList *s, int pos, SeqData data)
{
if (s == NULL || pos < 0 || pos > s->len)
return FALSE;

// 檢測順序表是否存滿
if (s->len == s->max_len)
{
if (AgainMalloc(s) != TRUE)
{
return FALSE;
}
}

// 進行移位
int i;
for (i = s->len-1; i >= pos; i--)
{
s->list[i+1] = s->list[i];
}

s->list[pos] = data;
s->len++;


return TRUE;
}


int GetData(SeqList *s, int pos, SeqData *x)
{
if (s == NULL || pos < 0 || pos >= s->len || x == NULL)
return FALSE;

*x = s->list[pos];

return TRUE;
}


int FindData(SeqList *s, SeqData data, SeqData *x)
{
if (s == NULL || x == NULL)
return FALSE;

int i;
int flag = 0;
for (i = 0; i < s->len; i++)
{
if (s->list[i] == data)
{
*x = i;
flag = 1;
break;
}
}
if (flag == 0)
return FALSE;

return TRUE;
}


int Delete_Pos(SeqList *s, int pos)
{
if (s == NULL || pos < 0 || pos >= s->len)
{
return FALSE;
}

// 移動元素
int i;
for (i = pos; i < s->len-1; i++)
{
s->list[i] = s->list[i+1];
}

s->len--;

return TRUE;
}




int Delete_Data(SeqList *s, SeqData data)
{
if (s == NULL)
return FALSE;

int index = -1;
if (FindData(s, data, &index) == FALSE)
return FALSE;

return Delete_Pos(s, index);
}


int Reverse_List(SeqList *s)
{
if (s == NULL)
return FALSE;

int min = 0;
int max = s->len - 1;
SeqData tmp;
while (min < max)
{
tmp = s->list[min];
s->list[min++] = s->list[max];
s->list[max--] = tmp;
}

return TRUE;
}


SeqList * Merge_List(SeqList *s1, SeqList *s2)
{
if (s1 == NULL || s2 == NULL)
return NULL;

SeqList* s3 = (SeqList*)malloc(sizeof(SeqList)/sizeof(char));
if (s3 == NULL)
return NULL;

// 爲s3分配存儲空間
int size = sizeof(SeqData)/sizeof(char)*(s1->len + s2->len);
s3->list = (SeqData*)malloc(size);
s3->len  = s1->len + s2->len;
s3->max_len = s3->len;

int i = 0;     // 遍歷 s1
int j = 0;     // 遍歷 s2
int k = 0;     // 遍歷 s3

while (i < s1->len && j < s2->len)
{
if (s1->list[i] < s2->list[j])
{
s3->list[k++] = s1->list[i++];
}
else
{
s3->list[k++] = s2->list[j++];
}
}

while (i < s1->len)
{
s3->list[k++] = s1->list[i++];
}

while (j < s2->len)
{
s3->list[k++] = s2->list[j++];
}

return s3;
}


void Display(SeqList *s)
{
if (s == NULL)
return;

int i;
int count = 0;
for (i = 0; i < s->len; i++)
{
if (i % 4 == 0)
printf ("\n");

printf ("%8d", s->list[i]);
}

printf ("\n");
}

main.c文件：

#include <stdio.h>
#include "SeqList.h"


int main1()
{
// 創建順序表
SeqList *s = Create_List();
if (s == NULL)
{
printf ("創建失敗\n");
return -1;
}

printf ("創建成功\n");

// 插入數據
int i;
for (i = 0; i < 20; i++)
{
Insert_Last(s, i);
}
#if 0
for (i = 0; i < 20; i++)
{
Insert_Head(s, i);
}
if (Insert_Pos(s, s->len, 1000) == FALSE)
{
printf ("插入失敗");
}
Display(s);

SeqData data;
GetData(s, 5, &data);
printf ("%d\n", data);

int index;
if (FindData(s, 100, &index) == FALSE)
{
printf ("沒有該元素\n");
}
else
printf ("index = %d\n", index);




if (Delete_Pos(s, 5) == FALSE)
{
printf ("刪除失敗\n");
}
if (Delete_Data(s, 15) == FALSE)
{
printf ("刪除失敗\n");
}
#endif
//Reverse_List(s);

Display(s);
Destroy(s);
s = NULL;
printf ("銷燬成功\n");

return 0;
}

//合併兩個有序的順序表
int main()
{
// 創建順序表
SeqList *s1 = Create_List();
if (s1 == NULL)
{
printf ("創建失敗\n");
return -1;
}

SeqList *s2 = Create_List();
if (s2 == NULL)
{
printf ("創建失敗\n");
return -1;
}

int i;
for (i = 0; i < 20; i += 2)
{
Insert_Last(s1, i);
}

for (i = 1; i < 40; i += 2)
{
Insert_Last(s2, i);
}



SeqList *s3 = Merge_List(s1, s2);
printf ("s1: \n");
Display(s1);

printf ("s2: \n");
Display(s2);

printf ("s3: \n");
Display(s3);

return 0;
}