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 ; //存储长度到头结点

}