C/C++单向链表

由于时间仓促,作者并没有进行任何的检查,总之徒手165行,调试无BUG,基本功能的实现并无大问题,可能有些细节考虑不周(这也是C/C++的诟病,小车不倒只管前推),还忘见谅。

代码是在C++环境编写,可以在C编译平台运行,但要进行修改(把声明变量语句,写在执行语句之前)。

#include <stdio.h>
#include <stdlib.h>
//定义节点,所有节点必须用malloc()申请在堆中,在程序执行阶段保证空间的存在;
//-1表示非正常退出
typedef struct node
{
    int data;
    node *next;
} Node;
//用来表示链表的长度,-1表示无头节点的空表
int len = -1;
//定义一个全局头结点
Node *head = NULL;

//创建一个带有头节点的空链表
void createNodeList()
{
    if (head != NULL)//表示为非空表
        exit(-1);//非正常退出
    head = (Node *)malloc(sizeof(Node));//申请堆空间
    if (head == NULL) //如果head==NULL则申请失败
        exit(-1);
    //头结点的数据域为0,指针域为NULL
    head->data = 0;
    head->next = NULL;
    len = 0;//0表示有头节点的空表

}

//添加一个节点(向当前节点的指针域为NULL的节点后面添加)
void addNode(int data)
{
    if (head == NULL)//表示为空表
        exit(-1);
    Node *newNode = (Node *)malloc((sizeof(Node)));//创建一个新节点
    if (newNode == NULL)//申请失败
        exit(-1);
    //初始化新结点的数据域和指针域
    newNode->data = data;
    newNode->next = NULL;
    //连接工作
    Node *p = head;//当前节点
    Node *q = head->next;//下一个节点
    while (q != NULL)
    {
        //循环成立表示当前结点的指针域不为NULL
        p = q;//更新当前结点
        q = p->next;//更新当前结点的
    }
    //循环结束表示当前节点的指针域为NULL
    //更新当前节点指针域为新结点
    p->next = newNode;
    len++;//表长加一
}
//获取节点数据(0<index<len)
int getNode(int index)
{
    int data = -1;
    if (head == NULL)//表示为空表
        exit(-1);
    if (index < 0)//下标要从0开始
        exit(-1);
    if (index >= len)//下标越界
        exit(-1);
    Node *p = head->next;
    data = p->data;
    for (int i = 0; i < index;i++)
    {
        p=p->next;
    }
    data = p->data;
    return data;
}
//元素查找
int getData(int data)
{
    if (head == NULL)//表示为空表
        exit(-1);
    Node *p = head->next;//表示第一个节点
    for (int i = 0;p!=NULL;i++)
    {
        if (p->data==data)
            return i;//返回下标
        p = p->next;
    }
}
//向屏幕打印链表
void getLinks()
{
    if (head == NULL)//表示为空表
        exit(-1);
    //指向第一个节点
    Node *p = head->next;
    //如果该结节不为NULL则表示存在该节点
    while (p != NULL)
    {
        printf("%d\n", p->data);
        p = p->next;
    }
}
//删除节点
void removeNode(int index)
{
    if (head == NULL)//表示为空表
        exit(-1);
    if (index < 0)//下标要从0开始
        exit(-1);
    if (index >= len)//下标越界
        exit(-1);
    //p表示当前节点,q表示当前节点的指针域
    Node *p = head;//要被删除的前一个节点
    Node *q = head->next;//要被删除的节点
    for (int i = 0; i < index;i++)
    {
        p = q;
        q = p->next;
    }
    //重新连接
    p->next = q->next;
    free(q);//删除q节点
    len--;//表长减一
}
//清空链表
void cleanLinks()//表示为空表
{
    if (head == NULL)
        exit(-1);

    Node *p = head;//当前节点
    Node *q=head->next;//下一个节点
    free(p);//删除当前节点
    while (q!=NULL)
    {
        p = q;
        q = p->next;
        free(p);//删除当前节点
    }
    len = -1;//表示该表为空
}
void main()
{
    //创建表
    createNodeList();
    //添加元素
    addNode(1);
    addNode(2);
    addNode(3);
    addNode(4);
    //打印表,和表长
    getLinks();
    printf("len:%d\n", len);
    //查看第三个节点"4"
    printf("index 3:%d\n",getNode(3));
    //数据4所在节点下标
    printf("data 4:%d\n",getData(4));
    //删除第三个元素”3“
    removeNode(2);
    //分隔符
    printf("=============\n");
    //再次打印表和表长
    getLinks();
    printf("len:%d\n", len);
    cleanLinks();
    system("pause");
}
时间: 2024-08-26 12:14:00

C/C++单向链表的相关文章

数据结构与算法学习-单向链表的实现

链表(Chain本文所说链表均为单向链表,以下均简称单向链表)实际上是由节点(Node)组成的,一个链表拥有不定数量的节点.而向外暴露的只有一个头节点(Head),我们对链表的所有操作,都是直接或者间接地通过其头节点来进行的. 节点(Node)是由一个需要储存的对象及对下一个节点的引用组成的.也就是说,节点拥有两个成员:储存的对象.对下一个节点的引用. 这样说可能大家不是很明白,我贴一张图大家可能更容易理解. package LinkedList; /** * <p><strong>

算法总结之 反转部分单向链表

给定单链表的表头节点head, 以及两个整数from 和 to, 在单向链表上把fro个节点到第to个节点这一部分进行反转 思路: 本题 有可能存在换头的问题,所以函数应该返回调整后的新的头节点 1 判断是否满足 1<=from<=to<=N 如果不满足,直接返回原来的头节点 2 找到第from-1个节点pre和第to+1个节点tPos,fPre即要反转部分的前一个节点,tPos是反转部分的后一个节点,把反转部分先反转,然后正确的链接fPre和tPos package TT; impor

C语言之字符单向链表

/* * @Author: suifengtec * @Date:   2017-09-02 16:06:33 * @Last Modified by:   suifengtec * @Last Modified time: 2017-09-02 20:47:13 **/ /* 字符单向链表 gcc -o a.exe main.c && a  */ #include <stdio.h> #include <stdlib.h> #include <stdbool

C++__单向链表(练习)

单向链表 link.h #ifndef LINK_H_ #define LINK_H_ #define HEADER 0 #define TAIL -1 typedef int data_type; enum LINK_OP { LINK_ERR = -1, LINK_OK }; class LINK { private: data_type data; LINK *next; public: LINK(); LINK(data_type data); virtual ~LINK(); data

单向链表模板

写个单向链表模板练练手: #include <bits/stdc++.h> using namespace std; //create // delete // modify // search class Node{ public: int data; Node* ptr; Node(int elem= 0, Node* node= NULL){ this->data= elem; this->ptr= NULL; } }; class MyList{ private: Node

C#学习单向链表和接口 IList&lt;T&gt;

作者:乌龙哈里 时间:2015-11-04 平台:Window7 64bit,Visual Studio Community 2015 参考: MSDN 索引器(C# 编程指南) <数据结构(C#语言版)>下载 When to use IEnumerable, ICollection, IList and List 章节: 单向链表元素 定义单向链表操作接口 逐步实现单向链表 正文: 前面学习了 IEnumerable<T>.IComparable<T>.ICollec

循环单向链表(约瑟夫环)

#include <stdio.h> #include <stdlib.h> typedef struct List { int data; struct List *next; }List; //创建循环单向链表n为长度 List *list_create(int n) { List *head, *p; int i; head = (List *)malloc(sizeof(List)); p = head; p->data = 1; //创建第一个结点 for (i =

给定单向链表的头指针和一个结点指针,定义一个函数在O(1)时间删除该结点

#include <iostream> #include <string.h> #include <stdlib.h> #include <stack> using namespace std; struct Node { int data; struct Node* next; }; struct Node* create_list(int len) { if (len <= 0) return NULL; struct Node* head; st

python数据结构链表之单向链表

本文和大家分享的主要是python中单向链表相关内容,一起来看看吧,希望对大家学习python有所帮助. 单向链表 单向链表也叫单链表,是链表中最简单的一种形式,它的每个节点包含两个域,一个信息域(元素域)和一个链接域.这个链接指向链表中的下一个节点,而最后一个节点的链接域则指向一个空值. . 表元素域elem用来存放具体的数据. . 链接域next用来存放下一个节点的位置(python中的标识) . 变量p指向链表的头节点(首节点)的位置,从p出发能找到表中的任意节点. 节点实现 class 

数据结构-单向链表 C和C++的实现

数据结构,一堆数据的存放方式. 今天我们学习数据结构中的 链表: 数组,大家相当熟悉的存放数据方式,而链表是数组的一种特殊方式,它每个节点包括两个部分: 数据域:存放数据,此部分与数组相同 指针域:存放了下一个节点的地址 链表比数组多了指针域,因为链表需要通过上一个节点的指针域去找下一个数据,比如有一个链表ABCD四个节点,我们要访问D里边的数据.操作如下: 先通过A节点的指针域找到B节点 再通过B节点的指针域找到C节点 再通过C节点的指针域找到D节点 获取D节点数据域的数据 对比数组直接通过下