一次单链表的简单练习

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

typedef int elemType ;

typedef struct Node{ /* 定义单链表结点类型 */
elemType element;
Node *next;
}Node;

/* 1.初始化线性表，即置单链表的表头指针为空 */
void initList(Node *pNode)
{
pNode = NULL;
printf("初始化成功\n");
}

/* 2.创建线性表，此函数输入负数终止读取数据*/
Node *creatList(Node *pHead)
{
Node *p1;
Node *p2;

p1=p2=(Node *)malloc(sizeof(Node)); //申请新节点
// memset(p1,0,sizeof(Node));

scanf("%d",&p1->element); //输入新节点
p1->next = NULL; //新节点的指针置为空
while(p1->element > 0) //输入的值大于0则继续，直到输入的值为负
{
if(pHead == NULL) //空表，接入表头
{
pHead = p1;
}
else
{
p2->next = p1; //非空表，接入表尾
}
p2 = p1;
p1=(Node *)malloc(sizeof(Node)); //再重申请一个节点
// memset(p1,0,sizeof(Node));
scanf("%d",&p1->element);
p1->next = NULL;
}
printf("creatList函数执行，链表创建成功\n");
return pHead; //返回链表的头指针
}

/* 3.打印链表，链表的遍历*/
void printList(Node *pNode)
{
Node *pHead; //定义一个链表头指针
pHead = pNode;
if(NULL == pHead) //链表为空
{
printf("PrintList函数执行，链表为空\n");
}
else
{
while(NULL != pHead)
{
printf("%d ",pHead->element);
pHead = pHead->next;
}
printf("\n");
}
}

/* 4.清除线性表L中的所有元素，即释放单链表L中所有的结点，使之成为一个空表 */
void clearList(Node *pNode)
{
Node *pHead;
Node *pNext; //定义两个相邻节点

pHead = pNode;

if(pHead == NULL)
{
printf("clearList函数执行，链表为空\n");
return;
}
while(pHead->next != NULL)
{
pNext = pHead->next;//保存下一结点的指针
free(pHead);
pHead = pNext; //表头下移
}
printf("clearList函数执行，链表已经清除\n");
//pNode = NULL;
}

/* 5.返回单链表的长度 */
int sizeList(Node *pNode)
{
int size = 0;
Node *pHead;

pHead = pNode;
if(pHead == NULL)
{
printf("sizeList函数执行，链表长度 %d \n",size);
return 0;
}
while(pHead != NULL)
{
size++; //遍历链表size大小比链表的实际长度小1
pHead = pHead->next;
}
printf("sizeList函数执行，链表长度 %d \n",size);
return size; //链表的实际长度

}

/* 6.检查单链表是否为空，若为空则返回１，否则返回０ */
int isEmptyList(Node *pNode)
{
if(pNode == NULL)
{
printf("isEmptyList函数执行，链表为空\n");
return 1;
}
printf("isEmptyList函数执行，链表非空\n");
return 0;
}

/* 7.返回单链表中第pos个结点中的元素，若pos超出范围，则停止程序运行 */
elemType getElement(Node *pNode, int pos)
{
Node *pHead;
pHead = pNode;
int i=0;
if(pos < 1)
{
printf("getElement函数执行，pos值非法\n");
return 0;
}
if(pHead == NULL)
{
printf("getElement函数执行，链表为空\n");
return 0;
//exit(1);
}
while(pHead !=NULL)
{
++i;
if(i == pos)
{
break;
}
pHead = pHead->next; //移到下一结点
}
if(i < pos) //链表长度不足则退出
{
printf("getElement函数执行，pos值超出链表长度\n");
return 0;
}
return pHead->element;

}

/* 8.从单链表中查找具有给定值x的第一个元素，若查找成功则返回该结点data域的存储地址，否则返回NULL */
elemType *getElemAddr(Node *pNode, elemType x)
{
Node *pHead;
pHead = pNode;

if(NULL == pHead)
{
printf("getElemAddr函数执行，链表为空\n");
return NULL;
}
if(x < 0)
{
printf("getElemAddr函数执行，给定值X不合法\n");
return NULL;
}
while((pHead->element != x) && (NULL != pHead->next)) //判断是否到链表末尾，以及是否存在所要找的元素
{
pHead = pHead->next;
}
if((pHead->element != x) && (pHead != NULL))
{
printf("getElemAddr函数执行，在链表中未找到x值\n");
return NULL;
}
if(pHead->element == x)
{
printf("getElemAddr函数执行，元素 %d 的地址为 0x%x\n",x,&(pHead->element));
}
return &(pHead->element);//返回元素的地址
}

/* 9.把单链表中第pos个结点的值修改为x的值，若修改成功返回１，否则返回０ */
int modifyElem(Node *pNode,int pos,elemType x)
{
Node *pHead;
pHead = pNode;
int i = 0;

if(NULL == pHead)
{
printf("modifyElem函数执行，链表为空\n");
}
if(pos < 1)
{
printf("modifyElem函数执行，pos值非法\n");
return 0;
}
while(pHead !=NULL)
{
++i;
if(i == pos)
{
break;
}
pHead = pHead->next; //移到下一结点
}
if(i < pos) //链表长度不足则退出
{
printf("modifyElem函数执行，pos值超出链表长度\n");
return 0;
}
pNode = pHead;
pNode->element = x;
printf("modifyElem函数执行\n");
return 1;

}

/* 10.向单链表的表头插入一个元素 */
int insertHeadList(Node **pNode,elemType insertElem)
{
Node *pInsert;
pInsert = (Node *)malloc(sizeof(Node));
//memset(pInsert,0,sizeof(Node));
pInsert->element = insertElem;
pInsert->next = *pNode;
*pNode = pInsert;
return 0;
}
/******************************************************************/
int main()
{
Node *pList=NULL;
int length = 0;

elemType posElem;

initList(pList); //链表初始化
printList(pList);

pList=creatList(pList); //创建链表
printList(pList);

sizeList(pList); //链表的长度
printList(pList);

isEmptyList(pList); //判断链表是否为空链表

posElem = getElement(pList,3); //获取第三个元素，如果元素不足3个，则返回0
printf("getElement函数执行，位置 3 中的元素为 %d\n",posElem);
printList(pList);

getElemAddr(pList,5); //获得元素5的地址

modifyElem(pList,4,1); //将链表中位置4上的元素修改为1
printList(pList);

insertHeadList(&pList,12); //表头插入元素12
printList(pList);

clearList(pList); //清空链表
system("pause");
return 0;
}

时间： 2024-10-14 06:06:35

一次单链表的简单练习的相关文章

c# 单链表实现 简单示例（可复制直接运行）

最近学习数据结构,发现c# 其实和c 的链表的实现差不多的 下面是一段可直接运行的代码 1 using System; 2 using System.Collections.Generic; 3 using System.Text; 4 using System.Threading; 5 6 namespace SingleLinkedList 7 { 8 class Program 9 { 10 static void Main(string[] args) 11 { 12 13 //实例调用

侵入式单链表的简单实现

通常情况下,单链表的定义是这样子滴, typedef struct foo_s { int data; struct foo_s *next; } foo_t; 结构体里包含了链表指针next; 而侵入式单链表却不同,让结构体包含一个通用的链表.看起来是这个样儿滴, typedef struct list_s { struct list_s *next; } list_t; typedef struct foo_s { int data; list_t link; } foo_t; 所有包含了l

单链表的简单操作

单链表是一种最简单的线性表的链式存储结构,单链表又称线性链表,每个数据元素用一个结点来存储,结点分为存放数据元素的data和存放指向链表下一个结点的指针next. 链表实现:(LinkList.h) //单链表 #ifndef LINKLIST_H_ #define LINKLIST_H_ #include <iostream> //using namespace std; template <typename T> struct Node { //数据成员 T data; Nod

单链表的简单c++实现

以下代码只实现了单链表的手动创建以及输出功能 #include<iostream> using namespace std; struct node { int data; node *next; }; class list { public: void creat(); void show(); private: node *head; }; void list::creat() //创建链表 { node *f=new node(); //建立链表的第一个元素 f->data=44;

对带头结点的单链表的简单操作

#pragma once #include<stdio.h> #include<stdlib.h> #include<assert.h> #include<memory.h> #define DataType int           //int 可以改写为其它数据类型 typedef struct Node { DataType data; struct Node *next; }Node,*pNode;          //定义结点结构体      

单链表的简单实现

//定义一个节点类 class Node{ int data; Node nextNode; public Node(int data) { // TODO Auto-generated constructor stub this.data = data; } } 链表类: package test; /** * * @author dao * */ // 链表类 public class ListNode { Node firstNode; // 第一个节点 int length = 0; N

侵入式单链表的简单实现(cont)

前一节介绍的侵入式链表的实现的封装性做得不好,因为会让消费者foo.c直接使用宏container_of().这一节对list的定义做了一下改进,如下所示: typedef struct list_s { struct list_s *next; size_t offset; } list_t; 既然链表结点存了offset, 那么就不再需要container_of()了.(注:Solaris的侵入式双向循环链表就是这么实现的) 1. list.h 1 #ifndef _LIST_H 2 #de

用最简单的方式学Python单链表

Python 实现单链表 在本博客中,我们介绍单链表这种数据结构,链表结构为基于数组的序列提供了另一种选择(例如Python列表). 基于数组的序列和链表都能够对其中的元素保持一定得顺序,但采用的方式截然不同 什么是单链表 单链表 最简单的形式就是由多个节点的集合共同构成一个线性序列.每个节点存储一个对象的引用,这个引用指向序列中的一个元素,即存储指向列表的下一个节点. 其实,上面的术语用生活中的大白话来解释,就是我们现在有三个人--我.你.他.当我用手指指向你,你用手指指向他,这样就形成了一个

大话数据结构---单链表

单链表在存储结构上与顺序存储的区别:不用开辟连续的存储空间,存储位置任意,只需要让数据的前驱知道它的位置就可以,而使用单链表示只需要知道单链表的第一个元素就能找到其他所有的元素,为了方便 一般会设置一个头指针指向第一个元素. 单链表的数据读取:通过头指针一个一个往后遍历 单链表的插入: 删除: 自定义单链表的简单实现: package com.neuedu.entity; /* * 项目名称:JavaSqList * @author:wzc * @date 创建时间:2017年9月2日 上午9: