go语言获取链表长度 go实现单链表
创建链表L，返回链表长度int listlength(linklist L)
#includestdio.h
目前创新互联已为近千家的企业提供了网站建设、域名、虚拟主机、网站托管维护、企业网站设计、嫩江网站维护等服务，公司将坚持客户导向、应用为本的策略，正道将秉承"和谐、参与、激情"的文化，与客户和合作伙伴齐心协力一起成长，共同发展。
#includestdlib.h
#define OK 1
#define ERROR 0
typedef char ElemType ;
typedef struct LNode
{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
int InitList(LinkList *L )
{
(*L)=(struct LNode *)malloc(sizeof(LNode));
if(!(*L))
return ERROR;
(*L)-next=NULL;
return OK;
}
int InsertList(LinkList *L,int i,ElemType e)
{
LinkList p,s;
int j=0;
p=*L;
while(pji-1)
{
p=p-next ;
++j;
}
if(!p||ji-1)
return ERROR;
s=(struct LNode *)malloc(sizeof(LNode));
s-data=e;
s-next=p-next ;
p-next=s;
return OK;
}
void print(ElemType e)
{
printf("%d-",e);
}
void TraverseList(LinkList L,void(*visit)())
{
LinkList p;
p=L-next ;
while(p )
{
visit(p-data);
p=p-next ;
}
return OK;
}
int DeleteList(LinkList *L,int i,ElemType e)
{
LinkList p;
int j=0;
p=(*L)-next ;
while(pji-1)
{
p=p-next ;
++j;
}
if(!p||ji-1)
return ERROR;
e=p-data ;
return e;
}
int GetElem(LinkList L,ElemType e)
{
LinkList p;
int i=0;
p=L-next ;
while(p)
{
i++;
if(p-data==e)
{
printf("the number you want to find exist! its posotion is %d\n\n",i);
return OK;
}
p=p-next ;
}
printf("the number you want to find not exist!!\n\n");
return OK;
}
int Length(LinkList L)
{
LinkList p;
int i=0;
p=L-next ;
while(p)
{
i++;
p=p-next ;
}
return i;
}
main()
{
LinkList L;
ElemType i;
ElemType e;
InitList(L);
for(i=0;i10;i++)
InsertList(L,1,i);
printf("链表为：");
TraverseList(L,print);
printf("链表长度为：%d\n\n",Length(L));
printf("input the position of the number you want to detele :");
scanf("%d",i);
printf("the number you want to detele is %d\n",DeleteList(L,i,e));
printf("please input the data you want to find is :");
scanf("%d",e);
GetElem(L,e,i);
}
函数：求有头结点单链表长度
int CreateList(LinkList *head)代码的while循环中，加入了一句话：
if (getchar() == '\n') break; // 输入换行时可跳出循环
新写的int getLength(LinkList head)代码如下：
完整代码为：
#includestdio.h
#includemalloc.h
#define ERROR 0
#define OK 1
typedef int ElemType; /*定义表元素的类型*/
typedef struct LNode /*线性表的单链表存储*/
{
ElemType data;
struct LNode *next;
}LNode, *LinkList;
/*创建单链表*/
int CreateList(LinkList *head);
/*函数定义*/
int getLength(LinkList head);
/*你的代码将写在此处*/
int CreateList(LinkList *head)
{
LNode *p, *q;
int e;
*head = (LinkList)malloc(sizeof(LNode));
if (!*head)
return ERROR;
(*head)-next = NULL;
p = *head;
while (scanf("%d", e) == 1)
{
if (getchar() == '\n')
break; // 回车时跳出循环
q = (LNode *)malloc(sizeof(LNode));
if (!q)
return ERROR;
q-data = e;
q-next = NULL;
p-next = q;
p = q;
}
return OK;
}/*CreateList*/
int getLength(LinkList head)
{
LNode *p = head;
int len = 0;
while (p != NULL)
{
++len;
p = p-next;
}
return len;
}
int main()
{
LinkList L = NULL;
CreateList(L);
printf("%d\n", getLength(L));
return 0;
}
gcc编译通过，望采纳~
如何用函数获取双向链表长度？？？
如果不是循环链表要做以下规定的：
表头的prev指针必须初始化为NULL
表尾的next指针必须初始化为NULL
于是计算链表长度可以从表头开始迭代，每次迭代计数加一，当遇到next为NULL时结束迭代，结束之后链表的长度就计算出来了。
新建节点时要养成习惯，prev和next未链接的要赋值为NULL
建立一个单链表，并求其长度的算法描述
int Length(PLNode head)/*求长度*/
{
int n=0;
PLNode p;
p=head-next;
while(p)
{
n++;
p=p-next;
}
从头节点开始，遍历链表，如果未到链表末尾，则长度加一，如此反复，知道链表结尾
已知head指向一个带头结点的单词链表,链表中每个结点包含数据long和指向被解构结点的指针
#include stdio.h
#include conio.h
#include stdlib.h
#define elemType long /*元素类型*/
#define elemPrintType "%ld\t" /*元素打印类型*/
#define status int
#define OVERFLOW -1
#define ERROR 0
#define OK 1
/* 单链表数据结构 */
typedef struct lNode {
elemType data;
struct lNode *next;
} lNode, *linkList;
/******************************** 以下为函数声明 ********************************/
void initList (linkList *L); /* 初始化 */
void destroyList (linkList L); /* 销毁 */
status listIsEmpty (linkList L); /* 判断单链表是否为空 */
int listLength (linkList L); /* 获取单链表长度 */
status listInsertNode (linkList L, int i, elemType e); /* 单链表指定位置插入新元素 */
status listPrint (linkList L); /* 输出链表 */
status listReverse (linkList L); /* 逆置链表 */
/******************************** 以上为函数声明 ********************************/
/* 初始化 */
/* 操作结果：构造一个空的单链表L */
void initList (linkList *L) {
*L = (linkList) malloc (sizeof (struct lNode)); /* 产生头节点，并使L指向此头节点 */
if(!*L) /* 内存分配失败 */
exit (OVERFLOW);
(*L)-next = NULL; /* 指针域为空 */
}
/* 销毁 */
/* 初始条件：单链表L已存在。操作结果：销毁单链表L */
void destroyList (linkList L) {
linkList p,q;
p = L-next; /* p指向第一个结点 */
while (p) { /* 没到表尾 */
q = p-next;
free (p);
p = q;
}
free (L);
}
/* 判断单链表是否为空 */
/* 初始条件：单链表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
status listIsEmpty (linkList L) {
return L-next == NULL;
}
/* 获取单链表长度 */
/* 初始条件：单链表L已存在。操作结果：返回L中数据元素个数 */
int listLength (linkList L) {
int i = 0;
linkList p = L-next; /* p指向第一个结点 */
while (p) { /* 没到表尾 */
i++;
p=p-next;
}
return i;
}
/* 单链表指定位置插入新元素 */
/* 操作结果：在带头结点的单链表L中第i个位置之前插入元素e */
status listInsertNode (linkList L, int i, elemType e) {
int j=0;
linkList p=L,s;
while (p ji-1) { /* 寻找第i-1个结点 */
p = p-next;
j++;
}
if (!p || ji-1) /* 插入位置不合理：i小于1或者大于表长 */
return ERROR;
/* 生成新结点，并插入L中 */
s = (linkList) malloc (sizeof (struct lNode));
s-data = e;
s-next = p-next;
p-next = s;
return OK;
}
/* 输出链表 */
status listPrint (linkList L) {
if (listIsEmpty (L)) {
puts ("链表为空！");
return OK;
}
linkList p = L-next; /* p指向第一个结点 */
while (p!=NULL) {
printf (elemPrintType,p-data);
p = p-next;
}
putchar ('\n');
return OK;
}
/* 逆置链表 */
/* 初始条件：单链表L已存在。操作结果：链表元素逆置 */
status listReverse (linkList L) {
linkList p, q;
if (listIsEmpty (L)||listLength (L)==1) /* 若L为空表或只有一个元素 */
return ERROR;
p = L-next-next; /* p指向第2个结点 */
L-next-next = NULL; /* 首结点置为尾结点 */
/* 自第2个结点起遍历链表，循环将当前结点插入到头结点之后以逆置链表 */
while (p) {
q = p-next; /* q指向p的后继结点 */
/* 将p插入到头结点之后 */
p-next = L-next;
L-next=p;
/* 访问下一结点 */
p = q;
}
return OK;
}
int main (void) {
linkList head;
elemType a=1,b=2,c=3,d=4;
/* 初始化链表 */
initList (head);
/* 插入若干元素 */
listInsertNode (head, 1, a);
listInsertNode (head, 1, b);
listInsertNode (head, 1, c);
listInsertNode (head, 1, d);
puts ("原链表内容：");
listPrint (head); /* 逆置链表 */
listReverse (head); /* 逆置链表 */
puts ("逆置后链表内容：");
listPrint (head);
destroyList (head); /* 销毁 */
getch ();
return 0 ;
}
运行结果
求单链表的长度
struct node {
int data;
struct node *next;
} ;
创建单链表后，最后一个结点的next是NULL，据此来遍历表，获得长度。
void get_len( struct node *head )
{
struct node *p=head-next ;
int len=0;
while ( p )
{
len++;
p=p-next;
}
head-data=len ; //存储长度到头结点
}
分享标题：go语言获取链表长度 go实现单链表
本文地址：http://hbruida.cn/article/doschhg.html
