算法2.1,2.3，2.4

c语言是最优雅的语言，你们高级语言的祖宗！

//本文件包含常用宏

#ifndef _MYLIB_H_

#define _MYLIB_H_

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define INFEASIBLE -1

#define OVERFLOW -2

typedef int Status;

#endif

//本文件包含算法2.3顺序表的插入，算法2.4顺序表的删除

#ifndef _SEQLIST_H_

#define _SEQLIST_H_

#include "mylib.h"

#include <stdio.h>

#include <stdlib.h>

#define LIST_INIT_SIZE 100

#define LISTINCREMENT 10

typedef int ElemType;

typedef struct

{

ElemType *elem; //存储空间基址

int length;

int listsize; //当前分配的存储容量

}SqList;

Status InitList_Sq(SqList *L) //构造一个空的线性表L

{

L->elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));

if(!L->elem)

{

printf("OVERFLOW");

exit(OVERFLOW);

}

L->length = 0;

L->listsize = LIST_INIT_SIZE;

return OK;

}

//算法2.3

Status ListInsert_Sq(SqList *L, int i, ElemType e) //在顺序表的第i个位置插入元素e

{

ElemType * q;

ElemType * p;

ElemType * newbase;

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

{

// printf("i不合法");

return ERROR; //i值不合法

}

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

{

newbase = (ElemType *)realloc(L->elem,

(L->listsize + LISTINCREMENT) * sizeof(ElemType));

if(!newbase)

{

//printf("OVERFLOW");

exit(OVERFLOW);

}

L->elem = newbase;

L->listsize += LISTINCREMENT;

}

q = &(L->elem[i - 1]);

for(p = &(L->elem[L->length-1]); p >= q; --p)

{

*(p+1) = *p;

}

*q = e;

++(L->length);

return OK;

}

//算法2.4

Status ListDelete_Sq(SqList *L, int i, ElemType *e) //在顺序表的第i个位置删除元素e，并用e返回

{

ElemType * q;

ElemType * p;

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

{

return ERROR; //i值不合法

}

p = &(L->elem[i-1]);

*e = *p;

q = L->elem + L->length - 1;

for(++p; p <=q; ++p)

{

*(p-1) = *p;

}

--(L->length);

return OK;

}

#endif

//本文件用于测试算法2.3，算法2.4

#include <stdio.h>

#include "SqList.h"

void TestList_Sq(SqList *L) //构造测试函数，初始化Sq长度为10

{

ElemType * p = L->elem;

int n = 10;

int i = 0;

int x = 0;

for(; i < n; i ++)

{

x = rand()%100;

ListInsert_Sq(L, L->length + 1, x);

}

}

void PrintList_Sq(SqList L) //测试函数，打印Sq内容

{

ElemType * p = L.elem;

for(;p < (L.elem + L.length); p ++ )

{

printf("%d ", *p);

}

printf("\n");

}

void main()

{

SqList  L;

ElemType e;

InitList_Sq(&L); //测试初始化函数

printf("length = %d, listsize = %d\n",L.length, L.listsize );

TestList_Sq(&L);

PrintList_Sq(L); //测试插入函数

printf("length = %d, listsize = %d\n",L.length, L.listsize );

ListDelete_Sq(&L, 6, &e); //测试删除函数

printf("length = %d, e = %d\n",L.length, e);

}

//本文件包含算法2.1头文件，MergeList算法

#ifndef _MERGELIST_H_

#define _MERGELIST_H_

#include "mylib.h"

#include "SqList.h"

//算法2.1

void MergeList(SqList La, SqList Lb, SqList *Lc)

{ //已知线性表La和Lb中的数据元素按值非递减排列

int i,j,k; //归并La和Lb得到新的线性表Lc，Lc的数据元素也按值非递减排列

int La_len = La.length;

int Lb_len = Lb.length;

i = j = 0;

k = 0;

InitList_Sq(Lc);

while((i < La_len) && (j < Lb_len))

{

if(La.elem[i] <= Lb.elem[j])

{

ListInsert_Sq(Lc, ++k, La.elem[i]);

i++;

}

else

{

ListInsert_Sq(Lc, ++k, Lb.elem[j]);

j++;

}

}

while(i < La_len)

{

ListInsert_Sq(Lc, ++k, La.elem[i]);

i++;

}

while(j < Lb_len)

{

ListInsert_Sq(Lc, ++k, Lb.elem[j]);

j++;

}

}

#endif

//note:在顺序表末尾插入,是L.length + 1, 不是L.length

//本文件用于测试算法2.1，归并2个有序顺序表到另一个顺序表

#include "MergeList.h"

#include "SqList.h"

#include <stdio.h>

void InitLaLb(SqList *La, SqList *Lb, int m , int n) //构造测试函数，m为La长度，n为 Lb长度

{

int i, x;

i = 0;

x = 0;

for(i = 0; i < m ; )

{

x = 2 * i * i - 2 * i + 12;

ListInsert_Sq(La, ++i, x);

}

for(i = 0; i < n;)

{

x = 2 * i * i;

ListInsert_Sq(Lb, ++i, x);

}

}

void main()

{

int i = 0;

int m = 6;

int n = 10;

SqList La, Lb, Lc;

InitList_Sq(&La);

InitList_Sq(&Lb);

InitList_Sq(&Lc);

InitLaLb(&La, &Lb, m, n);

for(i = 0; i < La.length; i ++)

{

printf("%d ", *(La.elem + i));

}

printf("\n");

for(i = 0; i < Lb.length; i ++)

{

printf("%d ", *(Lb.elem + i));

}

printf("\n");

MergeList(La, Lb, &Lc);

for(i = 0; i < Lc.length; i ++)

{

printf("%d ", *(Lc.elem + i));

}

printf("\n");

printf("%d", Lc.length);

}