C++中单链表

链表的含义

1） 由n个节点离散分配

2） 每个节点通过指针连接

3） 每一个节点由一个前驱节点和一个后驱节点

4）首节点没有前驱节点，尾节点没有后驱节点

节点的构成

节点由两部分构成

1、数据域，用来存放有效数据

2、指针域，用来存放下一个节点

节点构造

  首节点：存放第一个有效数据的节点；

   尾节点：存放最后一个有效数据的节点；

    头节点：头节点的数据类型与首节点的数据类型相同，并且头节点是首节点前面的那个节点，并不存放有效数据；头节点的存在只是为了方便链表的操作。

   头指针：指向头节点的指针；

   尾指针：指向尾节点的指针；

main.cpp

#include <iostream>
#include "Node.h"
int main() {
    PNODE  p= creat(5,1,2,3,4,5);
    print(p);
    p=del(p,4);
    print(p);
    p=insert(p,2,222);
    print(p);
    p = resver(p);
    print(p);
    return 0;
}

Node.cpp

//
// Created by yang on 2017/12/13.
//
//链表 中一个头指针 存放一个地址   每个地址表示一个节点
#include "Node.h"
#include <stdarg.h>
#include <iostream>
#include <string.h>
PNODE creat(int i ,...)
{
    PNODE head,pnew,ptail;  // head  --> 头指针，返回值  pnew 用来存放新申请的节点的值  ptail -> 尾节点，存放链表尾节点地址

    pnew = new NODE();
    std::cout << pnew << std::endl;
    va_list va_p;
    va_start(va_p,i);
    for(int n = 1;n <= i;++n)
    {
        int tmp = va_arg(va_p, int);
        std::cout << tmp  << std::endl;
        if(1 == n)
        {
            head = pnew;
            ptail->pNext = NULL;
        }
        else{
            ptail->pNext = pnew;
        }
        ptail = pnew;  //把新申请的节点地址给尾节点，pnew 存放新的地址
        ptail->data = tmp;
        pnew = new NODE();
    }
    ptail->pNext = NULL;
    delete pnew;
    va_end(va_p);
    std::cout << head << std::endl;
    return  head;
}

void print(PNODE head)
{
    PNODE p = head;
    while(p)
    {
        p = p->pNext;
    }
}

PNODE  del(PNODE phead, int num)
{
    PNODE pre,pnow;  //pre 上一个节点 pnow 现在的节点

    pnow = phead;
    while(pnow->data != num && pnow->pNext)
    {
        pre = pnow;
        pnow = pnow->pNext;
    }
    if(pnow->data == num)
    {
        if (phead == pnow)
            phead->pNext = pnow->pNext;
        else
            pre->pNext = pnow->pNext;
    } else{
        std::cout << "No data Find!" << std::endl;
    }
    return phead;
}

PNODE  insert(PNODE phead,int num,int data)
{
    PNODE pnew = NULL;
    if(phead == NULL)
    {
        pnew = new NODE;
        phead->pNext = pnew;
        phead->data = data;
    }
    PNODE pnow = phead;
    while (pnow->pNext&&pnow->data != num)
    {
        pnow = pnow->pNext;
    }
    if(num == pnow->data){
        pnew = new NODE;
        pnew->data = data;
        pnew->pNext = pnow->pNext;
        pnow->pNext = pnew;
    }
    else{
        std::cout << "Data Not Find!" << std::endl;
    }
    return phead;
}

PNODE resver(PNODE phead)
{
    PNODE pnow,ptmp,pnext; //  pnow 上一个节点 ptmp 临时存放变量  pnext 当前操作节点
    pnow = NULL;
    pnext = phead;
    while (pnext)
    {
        ptmp = pnext->pNext;
        pnext->pNext = pnow;
        pnow = pnext;
        pnext = ptmp;
    }
    return pnow;
}

Node.h

//
// Created by yang on 2017/12/13.
//

#ifndef LIST_NODE_H
#define LIST_NODE_H

typedef struct Node{
    int data;
    struct Node *pNext;
}NODE,*PNODE;
//定义了两个新的数据类型 Node ---> struct Node PNODE ----> struct Node*


PNODE creat(int i,...);
void print(PNODE head);
PNODE  del(PNODE phead, int num);
PNODE  insert(PNODE phead,int num,int data);
PNODE resver(PNODE phead);


class List{
public:
    List(){};
    ~List(){};
private:
    int m_n;
};
#endif //LIST_NODE_H

CMakeLists.txt

cmake_minimum_required(VERSION 3.6)
project(list)

set(CMAKE_CXX_STANDARD 11)

set(SOURCE_FILES main.cpp Node.cpp Node.h)
add_executable(list ${SOURCE_FILES})