C++数据结构----单链表

ZAtonement

于 2022-08-23 15:52:51 发布

阅读量216

点赞数

分类专栏： C++数据结构文章标签：数据结构 c++ 链表

本文链接：https://blog.csdn.net/qq_32621445/article/details/126486620

版权

C++数据结构专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一、链表的顺序存储

//seqlist.h
#ifndef  __MY_SEQLIST_H__ 
#define __MY_SEQLIST_H__

typedef void SeqList;
typedef void SeqListNode;

SeqList* SeqList_Create(int capacity);

void SeqList_Destroy(SeqList* list);

void SeqList_Clear(SeqList* list);

int SeqList_Length(SeqList* list);

int SeqList_Capacity(SeqList* list);

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);

SeqListNode* SeqList_Get(SeqList* list, int pos);

SeqListNode* SeqList_Delete(SeqList* list, int pos);


#endif  //__MY_SEQLIST_H__



//seqlist.c


#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "seqlist.h"


//在结构体中套1级指针
//
typedef struct _tag_SeqList
{
	int length;
	int capacity;
	unsigned int *node;   //int* node[]
}TSeqList;

SeqList* SeqList_Create(int capacity)
{
	int ret = 0;
	TSeqList *tmp = NULL;

	tmp = (TSeqList *)malloc(sizeof(TSeqList));
	if (tmp == NULL)
	{
		ret = -1;
		printf("func SeqList_Create() err:%d \n", ret);
		return NULL;
	}
	memset(tmp, 0, sizeof(TSeqList));

	//根据capacity 的大小分配节点的空间
	tmp->node = (unsigned int *)malloc(sizeof(unsigned int *) * capacity);
	if (tmp->node  == NULL)
	{
		ret = -2;
		printf("func SeqList_Create() err: malloc err %d \n", ret);
		return NULL;
	}
	tmp->capacity = capacity;
	tmp->length = 0;
	return tmp;
}

void SeqList_Destroy(SeqList* list)
{
	TSeqList *tlist = NULL;
	if (list == NULL)
	{
		return ;
	}
	tlist = (TSeqList *)list;
	if (tlist->node != NULL)
	{
		free(tlist->node);
	}
	
	free(tlist);

	return ;
}

//清空链表 //回到初始化状态
void SeqList_Clear(SeqList* list)
{
	TSeqList *tlist = NULL;
	if (list == NULL)
	{
		return ;
	}
	tlist = (TSeqList *)list;
	tlist->length = 0; 
	return ;
}

int SeqList_Length(SeqList* list)
{
	TSeqList *tlist = NULL;
	if (list == NULL)
	{
		return -1;
	}
	tlist = (TSeqList *)list;
	return tlist->length;
}

int SeqList_Capacity(SeqList* list)
{

	TSeqList *tlist = NULL;
	if (list == NULL)
	{
		return -1;
	}
	tlist = (TSeqList *)list;
	return tlist->capacity;
}

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos)
{
	int i =0, ret = 0;
	TSeqList *tlist = NULL;

	if (list == NULL || node==NULL ||  pos<0)
	{
		ret = -1;
		printf("fun SeqList_Insert() err:%d \n", ret);
		return ret;
	}
	tlist = (TSeqList*)list;

	//判断是不是满了
	if (tlist->length >= tlist->capacity)
	{
		ret = -2;
		printf("fun SeqList_Insert() (tlist->length >= tlist->capacity) err:%d \n", ret);
		return ret;
	}

	//容错修正  6个长度 容量20;用户pos10位置插入..
	if (pos>=tlist->length)
	{
		pos = tlist->length; //
	}

	//1 元素后移
	for(i=tlist->length; i>pos; i--)
	{
		tlist->node[i] = tlist->node[i-1];
		//a[7] = a[6]
	}
	// i = 3
	// 2插入元素
	tlist->[inode] = (unsigned int )node;
	tlist->length ++;
	return 0;
}

SeqListNode* SeqList_Get(SeqList* list, int pos)
{
	int i =0;
	SeqListNode *ret = 0;
	TSeqList *tlist = NULL;

	if (list == NULL ||  pos<0)
	{
		printf("fun SeqList_Get() err:%d \n", ret);
		return NULL;
	}
	tlist = (TSeqList*)list;

	ret = (void *)tlist->node[pos];
	return ret;
}

SeqListNode* SeqList_Delete(SeqList* list, int pos)
{
	int i = 0;
	SeqListNode *ret = 0;
	TSeqList *tlist = NULL;

	if (list == NULL ||  pos<0) //检查
	{
		printf("fun SeqList_Delete() err:%d \n", ret);
		return NULL;
	}
	tlist = (TSeqList*)list;

	ret = (SeqListNode *)tlist->node[pos]; //缓存pos的位置
	 
	for (i=pos+1; i<tlist->length; i++)  //pos位置后面的元素前移
	{
		tlist->node[i-1] = tlist->node[i];
	}
	tlist->length --;
	return ret;
}


//线性链表的顺序存储

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "seqlist.h"
typedef struct _Teacher
{
	int age;
	char name[64];
}Teacher;


typedef struct _Teacher2
{
	int age;
	char name[64];
}Teacher2;

typedef struct _Teacher3
{
	int age;
	char name[64];
	int age3;

}Teacher3;
void main()
{
	int		ret = 0, i = 0;
	SeqList* list = NULL;

	Teacher t1, t2, t3, t4,t5;
	t1.age = 31;
	t2.age = 32;
	t3.age = 33;
	t4.age = 34;
	t5.age = 35;

	list = SeqList_Create(10);
	if (list == NULL)
	{
		printf("func SeqList_Create() ret :%d \n", ret);
		return ;
	}

	ret = SeqList_Insert(list, (SeqListNode*) &t1, 0); //头插法
	ret = SeqList_Insert(list, (SeqListNode*) &t2, 0); //头插法
	ret = SeqList_Insert(list, (SeqListNode*) &t3, 0); //头插法
	ret = SeqList_Insert(list, (SeqListNode*) &t4, 0); //头插法
	ret = SeqList_Insert(list, (SeqListNode*) &t5, 0); //头插法

	//遍历
	for (i=0; i<SeqList_Length(list); i++)
	{
		Teacher*  tmp = (Teacher *) SeqList_Get(list, i);
		if (tmp == NULL)
		{
			return ;
		}
		printf("tmp->age:%d ", tmp->age);
	}

	//删除链表中的节点
	while( SeqList_Length(list) > 0 )
	{
		SeqList_Delete(list, 0);
	}

	system("pause");

	/*
	typedef void SeqList;
	typedef void SeqListNode;

	SeqList* SeqList_Create(int capacity);

	void SeqList_Destroy(SeqList* list);

	void SeqList_Clear(SeqList* list);

	int SeqList_Length(SeqList* list);

	int SeqList_Capacity(SeqList* list);

	int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);

	SeqListNode* SeqList_Get(SeqList* list, int pos);

	SeqListNode* SeqList_Delete(SeqList* list, int pos);
	*/

	return ;
}

二、线性链表的链式存储

//LinkList.h
#ifndef _LINKLIST_H_
#define _LINKLIST_H_

typedef void LinkList;
//这里相当于一条地址链，一个地址里存着下一个地址，下一个地址存着下下个地址，以此类推。
typedef struct _tag_LinkListNode LinkListNode;
struct _tag_LinkListNode
{
    LinkListNode* next;
};

LinkList* LinkList_Create();

void LinkList_Destroy(LinkList* list);

void LinkList_Clear(LinkList* list);

int LinkList_Length(LinkList* list);

int LinkList_Insert(LinkList* list, LinkListNode* node, int pos);

LinkListNode* LinkList_Get(LinkList* list, int pos);

LinkListNode* LinkList_Delete(LinkList* list, int pos);

#endif


//LinkList.c文件的实现

#include <stdio.h>`
#include <malloc.h>
#include "LinkList.h"

//这是链表头，header指向链表第0个元素，Length为链表当前长度；
typedef struct _tag_LinkList
{
    LinkListNode header;
    int length;
} TLinkList;

//创建链表
LinkList* LinkList_Create() 
{
    TLinkList* ret = (TLinkList*)malloc(sizeof(TLinkList));

    if( ret != NULL )
    {
        ret->length = 0;
        ret->header.next = NULL;
    }

    return ret;
}

//销毁链表
void LinkList_Destroy(LinkList* list) // O(1)
{
    free(list);
}

//清空链表
void LinkList_Clear(LinkList* list) // O(1)
{
    TLinkList* sList = (TLinkList*)list;

    if( sList != NULL )
    {
        sList->length = 0;
        sList->header.next = NULL;
    }
}

//获取链表当前长度
int LinkList_Length(LinkList* list) // O(1)
{
    TLinkList* sList = (TLinkList*)list;
    int ret = -1;

    if( sList != NULL )
    {
        ret = sList->length;
    }

    return ret;
}

//插入值（pos从0开始）
int LinkList_Insert(LinkList* list, LinkListNode* node, int pos) // O(n)
{ 
    TLinkList* sList = (TLinkList*)list;
    int ret = (sList != NULL) && (pos >= 0) && (node != NULL);
    int i = 0;

    if( ret )
    {
        LinkListNode* current = (LinkListNode*)sList;

        for(i=0; (i<pos) && (current->next != NULL); i++)
        {
            current = current->next;
        }

        node->next = current->next;
        current->next = node;

        sList->length++;
    }

    return ret;
}

//链表元素获取
LinkListNode* LinkList_Get(LinkList* list, int pos) // O(n)
{
    TLinkList* sList = (TLinkList*)list;
    LinkListNode* ret = NULL;
    int i = 0;

    if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )
    {
        LinkListNode* current = (LinkListNode*)sList;

        for(i=0; i<pos; i++)
        {
            current = current->next;
        }

        ret = current->next;
    }

    return ret;
}

//链表删除某元素
LinkListNode* LinkList_Delete(LinkList* list, int pos) // O(n)
{
    TLinkList* sList = (TLinkList*)list;
    LinkListNode* ret = NULL;
    int i = 0;

    if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )
    {
        LinkListNode* current = (LinkListNode*)sList;

        for(i=0; i<pos; i++)
        {
            current = current->next;
        }

        ret = current->next;
        current->next = ret->next;

        sList->length--;
    }

    return ret;
}



//链表的链式存储测试框架


#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "linklist.h"

typedef struct Teacher
{
	LinkListNode node; //第一个域 (第一个元素)
	int age;
	char name[64];
}Teacher;

void main()
{
	int len = 0, ret = 0, i = 0;

	LinkList* list = NULL;

	Teacher  t1, t2, t3, t4, t5;
	t1.age = 31;
	t2.age = 32;
	t3.age = 33;
	t4.age = 34;
	t5.age = 35;

	list = LinkList_Create();
	if (list == NULL)
	{
		return ;
	}

	len = LinkList_Length(list);

	//链表的算法和具体业务节点的分离
	ret = LinkList_Insert(list, (LinkListNode*) (&t1), 0);
	ret = LinkList_Insert(list, (LinkListNode*) (&t2), 0);
	ret = LinkList_Insert(list, (LinkListNode*) (&t3), 0);
	ret = LinkList_Insert(list, (LinkListNode*) (&t4), 0);
	ret = LinkList_Insert(list, (LinkListNode*) (&t5), 0);

	//遍历

	for (i=0; i< LinkList_Length(list); i++)
	{
		Teacher *tmp = (Teacher *)LinkList_Get(list, i);
		if (tmp == NULL)
		{
			return ;
		}
		printf("tmp->age:%d ", tmp->age);
	}

	//删除链表
	while (LinkList_Length(list) > 0)
	{
		Teacher *tmp = (Teacher *)LinkList_Delete(list, 0);
		if (tmp == NULL)
		{
			return ;
		}
		printf("tmp->age:%d ", tmp->age);
	}

	LinkList_Destroy(list);

	system("pause");
	return ;
}