单链表

【1】线性表的链式存储

线性表的顺序存储结构特点：

逻辑关系上相邻的两个元素在物理位置上也相邻；

可以随机存取任一元素，它的存储位置可用一个简单直观的公式表示。

然而，从另一个角度来看，这个优点也表明了这种存储结构的弱点：

在做插入或删除操作时，需要移动大量的元素。

 

线性表的链式存储不要求逻辑上相邻的元素在物理位置上也相邻。

因此，它没有顺序存储结构所具有的弱点，但同时也失去随机存取的优点。

另外一点：

链式存储的存储空间采用动态分配，不会存在分配不够用或者浪费的情况。

【2】链式存储结构

链式存储结构如下图：

【3】单链表的实现

1. list.h 头文件

#ifndef _STDAFX_H
#define _STDAFX_H

#include <iostream>
#include <malloc.h>
#include <assert.h>

typedef enum { ERROR = 0, OK}  Status;

typedef int ElemType;

typedef struct _Node
{
    ElemType data;
    struct _Node *next;
} Node, *PNode, *Position;

typedef struct 
{
    PNode head, tail;
    size_t size;
} List, *PList;


PList    InitList();
void    FreeNode(PNode p);
PNode    BuyNode(ElemType x, PNode pN = NULL);

void    Print_List(PList _list);
void    DestroyList(PList _list);
void    ClearList(PList _list);

void    Push_Back(PList _list, ElemType x);
void    Push_Front(PList _list, ElemType x);
void    Pop_Back(PList _list);
void    Pop_Front(PList _list);

PNode    FindPreValue(PList _list, ElemType x);
PNode    FindPos(PList _list, int pos);

Status    Remove(PList _list, ElemType x);
Status    RemoveAll(PList _list, ElemType x);

Status    Erase(PList _list, size_t pos);

Status    Insert(PList _list, int pos, ElemType x);

void    Sort(PList _list);
void    Reverse(PList _list);
void    Merge(PList _list, PList _list1, PList _list2);
void    Link(PList _list, PList _list1);

size_t    Size(PList _list);

#endif

2. list.cpp 实现文件

#include "List.h"
using namespace std;

// 购买节点    
PNode BuyNode(ElemType x, PNode n)
{
    PNode s = (PNode)malloc(sizeof(Node));
    assert(NULL != s); //断言函数
    s->data = x;
    s->next = n;
    return s;
}
// 释放节点
void FreeNode(PNode p)
{
    free(p);
    p = NULL;
}
// 初始化链表
PList InitList()
{
    PList p = (PList)malloc(sizeof(List));
    assert(p != NULL);
    p->size = 0;
    p->head = p->tail = BuyNode(0, NULL); //表明是有头结点的单链表
    return p;
}
// 后面插入数据
void Push_Back(PList _list, ElemType x)
{
    _list->tail = _list->tail->next = BuyNode(x, NULL);
    _list->size += 1;
}
// 前面插入数据
void Push_Front(PList _list, ElemType x)
{
    PNode s =_list->head->next = BuyNode(x, _list->head->next);
    if (NULL == s->next)
    {
        _list->tail = s;
    }
    _list->size += 1;
}
// 打印链表
void Print_List(PList _list)
{
    PNode p = _list->head->next;
    cout << "元素个数: " << _list->size << endl;
    while (p != NULL)
    {
        cout << p->data << " ";
        p = p->next;
    }
    cout << endl;
}
// 清空链表
void ClearList(PList _list)
{
    PNode q = NULL;
    PNode s = _list->head->next;
    while (s != NULL)
    {
        q = s;
        s = s->next;
        free(q);    //FreeNode(q);
    }
    _list->size = 0;
    _list->head->next = NULL;
    _list->tail = _list->head;
}
// 摧毁链表
void DestroyList(PList _list)
{
    ClearList(_list);
    free(_list->head);
    free(_list);
}
// 后面弹出
void Pop_Back(PList _list)
{
    PNode p = _list->head;
    //循环定位找最后节点的前驱
    while (p->next != NULL && p->next->next != NULL)
    {
        p = p->next;
    }

    if (p->next != NULL)
    {
        PNode q = p->next;
        p->next = NULL;
        _list->tail = p;
        free(q);    //FreeNode(q);
        _list->size -= 1;
    }
}
// 前面弹出
void Pop_Front(PList _list)
{
    if (_list->head->next != NULL)
    {
        PNode q = _list->head->next;
        _list->head->next = q->next;
        free(q);    // FreeNode(p);
        _list->size -= 1;
        // 链表仅有一个元素
        if (NULL == _list->head->next)
        {
            _list->tail = _list->head;
        }
    }
} 
// 查找某值前驱
PNode FindPreValue(PList _list, ElemType x)
{
    PNode p = _list->head;
    while (p->next != NULL && p->next->data != x)
    {  
        p = p->next;
    }
    
    if (NULL == p->next)
    {
        p = NULL;
    }

    return p;
}
// 删除某值
Status Remove(PList _list, ElemType x)
{
    PNode p = FindPreValue(_list, x);  //找到前驱
    if (NULL == p) 
    {
        return ERROR;
    }

    PNode q = p->next;
    p->next = q->next;

    _list->size -= 1;
    return OK;
}
// 找某位置的节点
PNode FindPos(PList _list, int pos)
{
    if (pos < -1) 
        return NULL;
    if (-1 == pos) 
        return _list->head;

    int j = 0;
    PNode p = _list->head->next;
    while (j < pos && p != NULL)
    {
        p = p->next;
        ++j;
    }
    return p;
}
// 删除某位置的值
Status Erase(PList _list, size_t pos)
{
    if (pos >= _list->size)
    {
      cout<<"输入位置有误！！！"<<endl;
    }
    PNode p = FindPos(_list, pos - 1);   //找位置前驱
    if (p == NULL || p->next == NULL)   //前者说明空链表//后者说明末节点
    {
        return ERROR;
    }

    PNode q = p->next;
    p->next = q->next;

    if (p->next == NULL)
    {
        _list->tail = p;
    }
    FreeNode(q);
    --_list->size;
    return OK;
}
// 按位置插入数据
Status Insert(PList _list, int pos, ElemType x)
{
    PNode p = FindPos(_list, pos-1);
    if (NULL == p)
    {
        return ERROR;
    }
    p->next = BuyNode(x, p->next);//顺利衔接
    PNode s = p->next;
    if (s->next == NULL)
    {
        _list->tail = s;
    }
    ++_list->size;
    return OK;
}
// 逆置链表
void Reverse(PList _list)
{
    if (_list->size >= 2)
    {
        PNode s = _list->head->next;
        _list->tail = s;
        PNode p = s->next;
        s->next = NULL;
        while (p != NULL)
        {
            s = p;
            p = p->next;
            s->next = _list->head->next;
            _list->head->next = s;
        }
    }
}
// 合并
void Merge(PList _list, PList _list1, PList _list2)
{
    PNode r = _list->head;
    PNode p1 = _list1->head->next;
    PNode p2 = _list2->head->next;
    // 执行合并
    while (p1 != NULL && p2 != NULL)
    {
        if (p1->data <= p2->data)
        {
            r->next = p1;
            p1 = p1->next;
        }
        else
        {
            r->next = p2;
            p2 = p2->next;
        }
        r = r->next;
    }
    // _list2先合并完成
    if (p1 != NULL)
    {
        r->next = p1;
        _list->tail = _list1->tail;
    }
    // _list1先合并完成
    if (p2 != NULL)
    {
        r->next = p2;
        _list->tail = _list2->tail;
    }
    // 合并数量
    _list->size = _list1->size + _list2->size;
    // 收尾
    _list1->head->next = NULL;
    _list1->tail = _list1->head;
    _list1->size = 0;

    _list2->head->next = NULL;
    _list2->tail = _list2->head;
    _list2->size = 0;
}
//连接
void Link(PList _list, PList _list1)
{
    _list->tail->next = _list1->head->next;
    _list->tail = _list1->tail;
    _list->size += _list1->size;

    _list1->head->next = NULL;
    _list1->tail = _list1->head;
    _list1->size = 0;
}

/*
 * 逆置方式2
void Reverse(PList _list)
{
    PNode r = _list->head->next;
    PNode s = r->next;
    PNode p = s->next;
    r->next = NULL;
    _list->tail = r;
    while (p != NULL)
    {
        s->next = r;
        r = s;
        s = p;
        p = p->next;
    }
    s->next = r;
    _list->head->next = s;
}
*/

3. listmain.cpp 测试文件

#include "List.h"
using namespace std;

#define UM_QUIT          0
#define UM_INPUTR     1
#define UM_INPUTH     2
#define UM_PRINT      3
#define UM_ERASE      4
#define UM_REMOVE     5
#define UM_POPFRONT   6
#define UM_POPBACK    7
#define UM_INSERT     8
#define UM_REVERSE    9
#define UM_MERGE      10
#define UM_LINK          11

#define ListNum0      0
#define ListNum1      1
#define ListNum2      2

void main()
{
    PList mylist, mylist1, mylist2;
    int select = 1, pos = 0, num = 0;
    ElemType item;
    mylist = InitList();
    mylist1 = InitList();
    mylist2 = InitList();
    while (select != 0)
    {
        cout << "		*********************菜单********************* " << endl;
        cout << "		**    1.输入数据r    2.输入数据h " << endl;
        cout << "		**    3.打印数据     4.位置删除 " << endl;
        cout << "		**    5.删除某值     6.前面弹出 " << endl;
        cout << "		**    7.后面弹出     8.位置插入 " << endl;
        cout << "		**    9.逆置链表     10.合并链表 " << endl;
        cout << "		**    11.连接链表    0.退出         " << endl;
        cout << "		**********************************************				" << endl;
        cout << "请选择" << endl;
        cin >> select;
        switch (select)
        {
        case UM_QUIT:
            break;
        case UM_INPUTR:
            {
                cout << "请输入要操作的链表：" << endl;
                cin >> num;
                switch (num)
                {
                case ListNum0:
                    cout << "请输入数据并以-1结束" << endl;
                    while (cin >> item, item != -1)
                    {
                        Push_Back(mylist, item);
                    }
                    break;
                case ListNum1:
                    cout << "请输入数据并以-1结束" <<endl;
                    while(cin >> item, item != -1)
                    {
                        Push_Back(mylist1, item);
                    }
                    break;
                case ListNum2:
                    cout << "请输入数据并以-1结束" << endl;
                    while(cin >> item, item != -1)
                    {
                        Push_Back(mylist2,item);
                    }
                    break;
                default:
                    cout << "选择错误 请重新选择" << endl;
                    break;
                }
            }
            break;
        case UM_INPUTH:
            {
                cout << "请输入要操作的链表：" << endl;
                cin >> num;
                switch (num)
                {
                case ListNum0:
                    cout << "请输入数据并以-1结束" << endl;
                    while(cin  >>item, item != -1)
                    {
                        Push_Front(mylist, item);
                    }
                    break;
                case ListNum1:
                    cout << "请输入数据并以-1结束" <<endl;
                    while(cin>>item, item != -1)
                    {
                        Push_Front(mylist1, item);
                    }
                    break;
                case ListNum2:
                    cout << "请输入数据并以-1结束" << endl;
                    while(cin >> item, item != -1)
                    {
                        Push_Front(mylist2, item);
                    }
                    break;
                default:
                    cout << "选择错误 请重新选择" <<endl;
                    break;
                }
            }
            break;
        case UM_PRINT:
            {
                cout << "请输入要操作的链表：" << endl;
                cin >> num;
                switch (num)
                {
                case ListNum0:
                    Print_List(mylist);
                    break;
                case ListNum1:
                    Print_List(mylist1);
                    break;
                case ListNum2:
                    Print_List(mylist2);
                    break;
                default:
                    cout << "选择错误 请重新选择" << endl;
                    break;
                }
            }
            break;
        case UM_ERASE:
            cout << "请输入位置：" << endl;
            cin >> pos;
            Erase(mylist, pos);
            break;
        case UM_REMOVE:
            cout << "请输入要删除的数据：" <<endl;
            cin >> item;
            Remove(mylist, item);
            break;
        case UM_POPFRONT:
            Pop_Front(mylist);
            break;
        case UM_POPBACK:
            Pop_Back(mylist);
            break;
        case UM_INSERT:
            cout << "请输入要插入的数据及位置信息:" << endl;
            cin >> item, pos;
            Insert(mylist, pos, item);
            break;
        case UM_REVERSE:
            Reverse(mylist);
            break;
        case UM_MERGE:
            Merge(mylist, mylist1, mylist2);
            break;
        case UM_LINK:
            Link(mylist, mylist1);
            break;
        default:
            cout << "选择错误! 请重新选择" << endl;
            break;
        }
    }
    DestroyList(mylist);
}

以上代码分为三部分：头文件，实现文件，测试文件。

当时运行环境为VS2010。

Good Good Study, Day Day Up.

顺序  选择  循环  总结