数据结构————线性表的实现 合并

1、表的实现

1.1表的数组表示

线性表的定义：线性表是n个元素的有限序列，表中各个数据元素具有相同特性，属于同一数据对象。

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

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INIT_SIZE 10        //初始化表长
#define INCREMENT_SIZE 5    //分配增量

typedef int Status;
typedef int Elemtype;

/*
 * 存储结构
 */
typedef struct
{
    Elemtype *elem;    //存储空间基址（数组）
    int length;        //当前长度
    int size;        //当前分配的表长大小
}SqList;

/*
 * 初始化一个空的线性表
 */
Status InitList(SqList *L)
{
    L->elem = (Elemtype *) malloc(INIT_SIZE * sizeof(Elemtype));
    if (!L->elem)
    {
        return ERROR;
    }
    L->length = 0;
    L->size = INIT_SIZE;
    return OK;
}

//销毁线性表
 
Status DestroyList(SqList *L)
{
    free(L->elem);
    L->length = 0;
    L->size = 0;
    return OK;
}

// 清空线性表
Status ClearList(SqList *L)
{
    L->length = 0;
    return OK;
}

 // 判断线性表是否为空
Status isEmpty(const SqList L)
{
    if (0 == L.length)
        return TRUE;
    else
        return FALSE;
}

/*
 * 获取长度
 */
Status getLength(const SqList L)
{
    return L.length;
}

//根据位置获取
Status GetElem(const SqList L, int i, Elemtype *e)
{
    if (i < 1 || i > L.length)
    {
        return ERROR;
    }
    *e = L.elem[i-1];
    return OK;
}

/*
 * 比较两个元素是否相等
 */
Status compare(Elemtype e1, Elemtype e2)
{
    if (e1 == e2)
        return 0;
    else if (e1 < e2)
        return -1;
    else
        return 1;
}

/*
 * 查找元素
 */
Status FindElem(const SqList L, Elemtype e, Status (*compare)(Elemtype, Elemtype))
{
    int i;
    for (i = 0; i < L.length; i++)
    {
        if (!compare(L.elem[i], e))
        {
            return i + 1;
        }
    }
    if (i >= L.length)
    {
        return ERROR;
    }
}

/*
 * 查找前驱元素
 */
Status PreElem(const SqList L, Elemtype cur_e, Elemtype *pre_e)
{
    int i;
    for (i = 0; i < L.length; i++)
    {
        if (cur_e == L.elem[i])
        {
            if (i != 0)
            {
                *pre_e = L.elem[i - 1];
            }
            else
            {
                return ERROR;
            }
        }
    }
    if (i >= L.length)
    {
        return ERROR;
    }
}

/*
 * 查找后继元素
 */
Status NextElem(const SqList L, Elemtype cur_e, Elemtype *next_e)
{
    int i;
    for (i = 0; i < L.length; i++)
    {
        if (cur_e == L.elem[i])
        {
            if (i < L.length - 1)
            {
                *next_e = L.elem[i + 1];
                return OK;
            }
            else
            {
                return ERROR;
            }
        }
    }
    if (i >= L.length)
    {
        return ERROR;
    }
}

/*
 * 插入元素
 */
Status InsertElem(SqList *L, int i, Elemtype e)
{
    Elemtype *new;
    if (i < 1 || i > L->length + 1)
    {
        return ERROR;
    }
    if (L->length >= L->size)
    {
        new = (Elemtype*) realloc(L->elem, (L->size + INCREMENT_SIZE) * sizeof(Elemtype));
        if (!new)
        {
            return ERROR;
        }
        L->elem = new;
        L->size += INCREMENT_SIZE;
    }
    Elemtype *p = &L->elem[i - 1];//定义指针指向指定位置元素
    Elemtype *q = &L->elem[L->length - 1];
    for (; q >= p; q--)
    {
        *(q + 1) = *q;
    }
    *p = e;
    ++L->length;
    return OK;
}

/*
 * 删除元素并返回其值
 */
Status DeleteElem(SqList *L, int i, Elemtype *e)
{
    if (i < 1 || i > L->length)
    {
        return ERROR;
    }
    Elemtype *p = &L->elem[i - 1];
    *e = *p;
    for (; p < &L->elem[L->length]; p++)
    {
        *(p) = *(p + 1);
    }
    --L->length;
    return OK;
}

/*
 * 访问元素
 */
void visit(Elemtype e)
{
    printf("%d ", e);
}

/*
 * 遍历线性表
 */
Status TraverseList(const SqList L, void (*visit)(Elemtype))
{
    int i;
    for(i = 0; i < L.length; i++)
    {
        visit(L.elem[i]);
    }
    return OK;
}

/*
 * 主函数测试
 */
int main()
{
    SqList L;
    if (InitList(&L))
    {
        Elemtype e;
        printf("init_success\n");
        int i;
        for (i = 0; i < 10; i++)
        {
            InsertElem(&L, i + 1, i);
        }
        printf("length is %d\n", getLength(L));
        if (GetElem(L, 1, &e)) {
            printf("The first element is %d\n", e);
        }
        else
        {
            printf("element is not exist\n");        
        }
        if (isEmpty(L))
        {
            printf("list is empty\n");
        }
        else
        {
            printf("list is not empty\n");
        }
        printf("The 5 at %d\n", FindElem(L, 5, *compare));
        PreElem(L, 6, &e);
        printf("The 6's previous element is %d\n", e);
        NextElem(L, 6, &e);
        printf("The 6's next element is %d\n", e);
        DeleteElem(&L, 1, &e);
        printf("delete first element is %d\n", e);
        printf("list:");
        TraverseList(L,visit);
        if (DestroyList(&L))
        {
            printf("\ndestroy_success\n");
        }
    }
}

链表

#include<stdio.h>
#include<stdlib.h>
//带有头结点的链表 
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;
typedef int Elemtype;
//存储结构
typedef struct _node{
	Elemtype data;
	struct _node *next; 
}LNode,*LinkList; 

//初始化线性表 需要把申请的内存给L,所以传给L的地址； 
Status InitList(LinkList *L)
{
	(*L) = (LinkList )malloc(sizeof(LNode));
	if(!L)
	{
		exit(OVERFLOW);
	}
	(*L)->next = NULL;
	return OK;
}
//判读是否为空 
Status isEmpty(LinkList L)
{
	if(L->next){
		return FALSE;
	}
	else return OK;
	
 } 
 //销毁链表-把链表中的每一个节点都free 需要操作L，改变L的值之后在free 
Status Destroy(LinkList *L)
{
	LinkList temp;
	while(*L)
	{
		temp = (*L)->next; 
		free(*L);
		*L = temp;
	 } 
	 return OK;
 } 
 //清空线性表diyizhong 
Status ClearList(LinkList L) 
{
	LinkList p = L->next;
	L->next = NULL;
	Destroy(&p)	;
}
//清空链表第二种
//Status ClearList(LinkList L)
//{
//	LinkList p = L->next;
//	LinkList q;
//	while(p)
//	{
//		q = p->next;
//		free(q);
//		p=q;
//	}
//  L->next = NULL;
//	return OK;
//	
// } 
//得到长度
 int GetLength(LinkList L)
 {
 	int i= 0;
 	LinkList p = L->next;
 	while(p)
 	{
 		i++;
 		p = p->next;
	 }
	 return i;
  } 
  //根据位置获取元素
  Status GetElem(LinkList L,int i, Elemtype  *e)
  {
  	int j=1;
  	LinkList p = L->next;
  	while(p)
  	{
  		if(j==i-1)
	  {
	  	*e = p->data;
	  	return OK;
	  
	  }
  		j++;
  		p=p->next;
	}
	return ERROR;
	  
   } 
 //比较两个元素是否相等
Status compare(Elemtype e1, Elemtype e2)
   {
   	if(e1==e2)
   	{
   		return 0;
	   }
	   else if(e1<e2){
	   	return -1;
	   }
	   else{
	   	return 1;
	   }
	} 
	//查找制定元素的位置返回其地址
Status  Locate(LinkList L,Elemtype e,LinkList *p)
{
	LinkList q = L->next;
	while(q )
	{
		if(q->data==e)
		{
			*p = q;
			return OK;
		}
		
		
		q = q->next;
		
	 } 
	 
	 return ERROR;
}
int FindElem(LinkList L, Elemtype e, Status (*compare)(Elemtype, Elemtype))
{
    int i = 0;
    LinkList p = L->next;
    while (p)
    {
        i++;
        if (!compare(p->data, e))
        {
            return i;
        }
        p = p->next;
    }
    return 0;
}
//获取前驱元素
Status PreElem(LinkList L,Elemtype cur_e,Elemtype *pre_e)
{
	LinkList q = L->next;
	LinkList p = q->next;
	while(p && cur_e != p->data)
	{	
		q= p;
		p = p->next;
	}
	if(p->data == cur_e)
	{
		*pre_e = q->data; 
		return OK;
	}
	
}
/*
 * 获取后继元素
 */
Status NextElem(LinkList L, Elemtype cur_e, Elemtype *next_e)
{
    LinkList p = L->next;
    while (p->next)
    {
        if (p->data == cur_e)
        {
            *next_e = p->next->data;
            return OK;
        }
        p = p->next;
    }
    return ERROR;
}
/*
 * 插入元素
 */
Status InsertElem(LinkList L, int i, Elemtype e)
{
    int j = 0;
    LinkList s, p = L;
    while (p && j < i - 1)
    {
        j++;
        p = p->next;
    }
    if (!p || j > i - 1)
    {
        return ERROR;
    }
    s = (LinkList) malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return OK;
}
/*
 * 删除元素并返回值
 */
Status DeleteElem(LinkList L, int i, Elemtype *e)
{
    int j = 0;
    LinkList q, p = L;
    while (p->next && j < i - 1)
    {
        j++;
        p = p->next;
    }
    if (!p->next || j > i - 1)
    {
        return ERROR;
    }
    q = p->next;
    p->next = q->next;
    *e = q->data;
    free(q);
    return OK;
}

/*
 * 访问元素
 */
void visit(Elemtype e)
{
    printf("%d ", e);
}

/*
 * 遍历线性表
 */
void TraverseList(LinkList L, void (*visit)(Elemtype))
{
    LinkList p = L->next;
    while (p)
    {
        visit(p->data);
        p = p->next;
    }
}

//合并 
void merge(LinkList La,LinkList Lb,LinkList *Lc)
{
	LinkList pc=La;
	*Lc = La;
	LinkList pb = Lb->next;
	LinkList pa = La->next;
	while(pa && pb)
	{
		if(pa->data<pb->data)
		{
			pc->next = pa;
			pc= pa;
			pa = pa->next;
		}else{
			pc->next=pb;
			pc=pb;
			pb = pb->next;
		}
	}
	pc->next = pa?pa:pb;
}


int main()
{
    LinkList L,L1,L2, p;
    InitList(&L);
    InitList(&L1);
    Elemtype e;
    int i,j;
    if (L)
    {
        printf("init success\n");
    }

    if (isEmpty(L))
    {
        printf("list is empty\n");    
    }

    for (i = 0; i < 10; i++)
    {
        InsertElem(L, i + 1, i);
    }
    
    for (j = 0; j < 10; j++)
    {
        InsertElem(L1, j + 1, j+1);
    }

    if (GetElem(L, 1, &e)) {
        printf("The first element is %d\n", e);
    }
    Locate(L,0,&p);
    printf("地址:%p\n",p);
    printf("%p\n",L->next);

    printf("length is %d\n", GetLength(L));

    printf("The 5 at %d\n", FindElem(L, 5, *compare));

    PreElem(L, 6, &e);
    printf("The 6's previous element is %d\n", e);

    NextElem(L, 6, &e);
    printf("The 6's next element is %d\n", e);

    DeleteElem(L, 1, &e);
    printf("delete first element is %d\n", e);

    printf("list:");
    TraverseList(L,visit);
    printf("\n");
    merge(L,L1,&L2);
    printf("after merge");
    TraverseList(L2,visit);

    Destroy(&L);
    if (!L) {
        printf("\ndestroy success\n");    
    }
}