数据结构和算法（三）线性表：静态链表、循环链表、双向链表

最新推荐文章于 2023-07-03 02:54:24 发布

You图碧

最新推荐文章于 2023-07-03 02:54:24 发布

阅读量206

点赞数

分类专栏：趣学算法

趣学算法专栏收录该内容

29 篇文章 1 订阅

订阅专栏

线性表

1.1静态链表

1.2循环链表

1.3双向链表 double linkedlist

1.1静态链表

静态链表就是使用静态的数组来描述单链表。意思就是：用游标代替指针。

#include <stdio.h>

//定义静态链表	  (即 游标实现法)
#define ElemType int 
#define MAXSIZE 1000
typedef struct
{
	ElemType data;//数据
	int cur; //游标 Cursor  为0 时表示无指向

}Component , StaticLinkList [MAXSIZE];

//初始化静态链表
void InitList(StaticLinkList L)
{
	int i;
	for (i = 0; i < MAXSIZE - 1; i++)  //下标的个数是MAXSIZE　－　１。
		L[i].cur = i + 1;

	L[MAXSIZE - 1].cur = 0;   //目前静态链表为空，最后一个元素的cur为0；

	return 1;

}

//返回下一次的所在下标位置的值。为0说明已经满了。

int  Malloc_SLL(StaticLinkList L)
{
	// 当前数组第一个元素的cur存的值
	// 就是要返回第一个备用空间的下标

	int i = L[0].cur;
	// 由于拿出一个分量来使用了，所以我们就得把它的下一个分量用来做备用

	if (L[0].cur)		  //这个值不为0 ，说明还没到最后一个位置。
		L[0].cur = L[i].cur;	  //把当前位置的游标，即是下一次的位置。
	return i;
}

//查看静态链表中 ，有多少个元素。

int ListLength(StaticLinkList L)
{	  
	int j = 0;
	int i = L[MAXSIZE - 1].cur;	  //元素的下标
	while (i)
	{
		i = L[i].cur;   //游标中保存的是下一次的下标
		j++;			//先看当前中 位置 i 是不是0， 如果不是0 ，那么
		                //就把值j加一，指定出下一次的位置
	}
	return j;  //返回j的值， 即 有的元素的个数。
}

int LinkInsert (StaticLinkList L , int i , ElemType e)
{
    int j ,k , l;
    //首先是最后一个元素的下标
    k = MAXSIZE - 1;
   //首先判读要查入的位置是否在位置中
    if(i < 1 || i > ListLength(L) + 1 )
        return -1; //错误了
    j = Malloc_SLL(L); //获取空闲的下标
   if(j)
   {
        //将数据赋值给此分量
        L[j].data = e;
        //找到第i个元素之前的位置
        for(l = 1; l<=i-1;l++)
        {   k = L[k].cur;   }
             //然后连接起来。下一个位置的游标
             //给新元素
            L[j].cur = L[k].cur;
            //然后把新元素的位置。给i-1的游标
            L[k].cur = j;
            return 1;
   }
   return -1;
}
//将下标为k 的空闲节点回收到备用链表

void Free_SSL(StaticLinkList L, int k)
{
	//把第一个元素cur值赋值给要删除的分量cur
	L[k].cur = L[0].cur;
	//把要删除的分量下标赋值给第一个元素cur
	L[0].cur = k;
}

//静态链表的删除操作

int ListDelete(StaticLinkList L, int i)
{
	int i, k , j;
	if (i < 1 || i > ListLength(L))
	{
		return 0;
	}
	k = MAXSIZE - 1;
	for (j = 1; j <= i - 1; j++)
		k = L[k].cur;

	j = L[k].cur;
	L[k].cur = L[j].cur;

	Free_SSL(L , j);
	return 1;
}

1.2循环链表

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

/*链表存储结构的定义*/
typedef struct CLinkList
{
    int data;
    struct CLinkList *next;
}node;

/************************************************************************/
/* 操作                                                                  */
/************************************************************************/

/*初始化循环链表*/
void ds_init(node **pNode)
{
    int item;
    node *temp;
    node *target;

    printf("输入结点的值，输入0完成初始化\n");

	while(1)
	{
        scanf("%d", &item);
        fflush(stdin);

		if(item == 0)
            return;

        if((*pNode) == NULL)
		{ /*循环链表中只有一个结点*/
			*pNode = (node*)malloc(sizeof(struct CLinkList));
			if(!(*pNode))
				exit(0);
			(*pNode)->data = item;
			(*pNode)->next = *pNode;
		}
        else
		{
            /*找到next指向第一个结点的结点*/
            for(target = (*pNode); target->next != (*pNode); target = target->next)
				;

            /*生成一个新的结点*/
            temp = (node *)malloc(sizeof(struct CLinkList));

			if(!temp)
				exit(0);

			temp->data = item;
            temp->next = *pNode;
            target->next = temp;
        }
    }
}

/*插入结点*/
/*参数：链表的第一个结点，插入的位置*/
void ds_insert(node **pNode , int i)
{
    node *temp;
    node *target;
    node *p;
    int item;
    int j = 1;

    printf("输入要插入结点的值:");
    scanf("%d", &item);

    if(i == 1)
	{ //新插入的结点作为第一个结点
        temp = (node *)malloc(sizeof(struct CLinkList));

		if(!temp)
            exit(0);

		temp ->data = item;

        /*寻找到最后一个结点*/
        for(target = (*pNode); target->next != (*pNode); target = target->next)
			;

		temp->next = (*pNode);
        target->next = temp;
        *pNode = temp;
    }
    else
	{
        target = *pNode;

        for( ; j < (i-1); ++j )
		{
			target=target->next;
		}

		temp = (node *)malloc(sizeof(struct CLinkList));

		if(!temp)
            exit(0);

		temp ->data = item;
        p = target->next;
        target->next = temp;
        temp->next = p;
    }
}

/*删除结点*/
void ds_delete(node **pNode, int i)
{
    node *target;
    node *temp;
    int j = 1;

    if(i == 1)
	{ //删除的是第一个结点
        /*找到最后一个结点*/
        for(target = *pNode; target->next != *pNode;target = target->next)
			;

		temp = *pNode;
        *pNode = (*pNode)->next;
        target->next = *pNode;
        free(temp);
    }
    else
	{
        target = *pNode;

		for( ; j < i-1; ++j )
		{
			target = target->next;
		}

		temp = target->next;
        target->next = temp->next;
        free(temp);
    }
}

/*返回结点所在位置*/
int ds_search(node *pNode, int elem)
{
    node *target;
    int i = 1;

    for(target = pNode; target->data != elem && target->next != pNode; ++i)
	{
		target = target->next;
	}

	if(target->next == pNode) /*表中不存在该元素*/
        return 0;
    else
        return i;
}

/*遍历*/
void ds_traverse(node *pNode)
{
    node *temp;
    temp = pNode;
    printf("***********链表中的元素******************\n");

	do
	{
        printf("%4d ", temp->data);
    }while((temp = temp->next) != pNode);

	printf("\n");
}

int main()
{
    node *pHead = NULL;
    char opp;
	int find;

    printf("1.初始化链表 \n\n2.插入结点 \n\n3.删除结点 \n\n4.返回结点位置 \n\n5.遍历链表  \n\n0.退出 \n\n请选择你的操作：");
    while(opp != '0')
	{
        scanf("%c", &opp);
        switch(opp)
		{
            case '1':
                ds_init(&pHead);
                printf("\n");
                ds_traverse(pHead);
                break;

            case '2':
                printf("输入需要插入结点的位置？");
                scanf("%d",  &find);
                ds_insert(&pHead, find);
                printf("在位置%d插入值后：\n",  find);
                ds_traverse(pHead);
                printf("\n");
                break;

            case '3':
                printf("输入需要删除的结点位置？");
                scanf("%d",  &find);
                ds_delete(&pHead, find);
                printf("删除第%d个结点后:\n",  find);
                ds_traverse(pHead);
                printf("\n");
                break;

            case '4':
                printf("你要查找倒数第几个结点的值？");
                scanf("%d",  &find);
                printf("元素%d所在位置：%d\n",  find,  ds_search(pHead, find));
                //ListTraverse(L);
                printf("\n");
                break;

            case '5':
                ds_traverse(pHead);
                printf("\n");
                break;

            case '0':
                exit(0);
        }
    }

    return 0;
}