线性表 链表

计算机中的三大结构：

• 线形结构  不分叉
• 树形结构
• 图形结构

直接前驱、该元素、直接后继

线性表存储

顺序表存储  优点: 快速访问

数组

链式存储  优点：大量删除、更新操作

链表

用typedef将结构体等价于 类型名Lnode，指针Linklist

typedef struct Lnode{
  ElemType data;
  struct Lnode *next;   
}Lnode, *Linklist;

如果不这样写就要加上关键字struct来声明变量。

分配变量返回的是指针  s = new Lnode，则s是指针 

链表的两种方式：

• 头结点
• 头指针

链表建立：

• 头插法 逆序建表   有头指针   没有标记的一端先修改，无标记的后修改。 两者都有标记修改哪一个无所谓。 指针只要一断，就找不到了。
• 尾插法 正序建表   有尾指针

头指针不可以随意改动

 STL List链表是双向链表

代码风格更加偏向工程化 

 

1、单链表操作

#include <iostream>
#include <string>
#include <iomanip>
#include <stdlib.h>

using namespace std;

typedef struct LNode{  // LNode为结构体的名字
    int data;  // 结点的数据域
    struct LNode *next;  // 结点的指针域
}LNode, *LinkList;  // LinkList为指向结构体LNode的指针类型

/*
 typedfs起别名的意思，给整个结构体起了个别名LNode， 指向结构体的指针*LinkList。
 */

bool InitList_L(LinkList &L){  // 构造一个空的单链表L
    L = new LNode;  // 生成新节点作为头结点，用头指针L指向头结点
    /* 每次用new分配空间总会返回一个地址 */
    if(!L)
        return false;  // 生成节点失败
    L->next = NULL;  // 头结点的指针置为空
    return true;
}

void CreateList_H(LinkList &L){  // 头插法建立单链表  逆序
    // 输入n个元素的值，建立到头结点的单链表L
    int n;
    LinkList s;  // 定义一个指针变量
    L= new LNode;
    L->next= NULL;  // 先建立一个带头节点的空链表
    cout << "请输入元素个数n:" << endl;
    cin >> n;
    cout << "请以此输入n个元素：" << endl;
    cout << "前插法创建单链表..." << endl;
    while(n--){
        s = new LNode;  // 生成新结点
        cin >> s->data;  // 输入元素值给新节点的数据域
        s->next= L->next;
        L->next = s;  // 将新结点s插入到头结点之后
    }
}

void CreateList_R(LinkList &L){  // 尾插法创建单链表 正序
    // 输入n个元素的值，建立到带表头结点的单链表L
    int n;
    LinkList s, r;
    L = new LNode;
    L->next = NULL;  // 先建立一个带头结点的空链表
    r = L;  // 尾指针r指向头结点
    cout << "请输入元素个数n:" << endl;
    cin >> n;
    cout << "请以此输入n个元素：" << endl;
    cout << "尾插法创建单链表..." << endl;
    while (n--) {
        s = new LNode;  // 生成新结点
        cin >> s->data;  // 输入元素值赋值给新结点的数据域
        s->next = NULL;   // s就是最后一个
        r->next = s;  // 将新结点s插入尾结点*r之后
        r = s;  // r指向新的尾结点s
    }
}

bool GetElem_L(LinkList L, int i, int &e){  // 单链表的取值  e引用参数
    // 在带头结点的单链表L中查找第i个元素
    // 用e记录L中第i个元素的值
    int j;
    LinkList p;
    p = L->next;  // p指向第一个结点
    j = 1; // j为技术器
    while(j<i && p){  // 顺链域向后扫描，直到p指向第i个元素或者p为空
        p = p->next;  //p指向小一个结点
        j++;  // 计数器j相应加1
    }
    if(!p || j>i)
        return false;   // i值不合法i>n 或 i<=0
    e = p->data;
    return true;
    
}

bool LocateElem_L(LinkList L, int e){  // 按值查找
    //  在带头结点的单链表L中查找值为e的元素
    LinkList p;
    p = L->next;   // L指针不能动，会破坏链表
    while (p && p->data!=e)  // 顺链域向后扫描，直到p为空或p所指向结点的数据域等于e
    {
        p = p->next;   // p指向下一个结点
    }
    if(!p)
        return false;  // 查找失败p为NULL
    return true;
}

bool ListInsert_L(LinkList &L, int i, int e){  // 单链表的插入
    // 带头j结点的单链表L中第一个位置插入值为e的新结点
    int j;
    LinkList p, s;
    p = L;
    j = 0;
    while (p && j<i-1) {  // 查找第i-1个结点，p指向该结点
        p = p->next;
        j++;
    }
    if(!p || j>i-1)  // i>n+1 或者 i<1
        return false;
    s = new LNode;  // 生成新节点
    s->data = e;  // 将新节点的数据域置为e
    s->next = p->next;  // 将新结点的指针域指向节点ai
    p->next = s;  // 将结点p的指针域指向结点s
    return true;
}

bool ListDelect_L(LinkList &L, int i){  // 单链表的删除
    // 在带头结点的单链表L中，删除第i个位置
    LinkList p, q;
    int j;
    p = L;
    j = 0;
    while ((p->next) && (j<i-1))
    {
        p = p->next;
        j++;
    }
    if(!(p->next) || (j>i-1)){  // 当i>n 或i<1时，删除位置不合理
        return false;
    }
    q = p->next;   // 临时保存被删除节点的地址以被释放空间
    p->next = q->next; // 改变删除节点前驱结点的指针域
    delete q;   // 释放被删除结点的空间
    return true;
}

void Listprint_L(LinkList L) //单链表的输出
{
    LinkList p;
    p = L->next;
    while (p)
    {
        cout << p->data << "	";
        p = p->next;
    }
    cout << endl;
    
}

int main(){
    int i, x, e, choose;
    LinkList L;
    cout << "1.初始化
";
    cout << "2.创建单链表（前插法）
";
    cout << "3.创建单链表（尾插法）
";
    cout << "4.取值
";
    cout << "5.查找
";
    cout << "6.插入
";
    cout << "7.删除
";
    cout << "8.输入
";
    cout << "0.退出
";
    choose = -1;
    while (choose != 0)
    {
        cout << "请输入数字选择：";
        cin >> choose;
        switch (choose)
        {
        case 1:
            if(InitList_L(L)){  // 初始化一个空的单链表
                cout << "初始化一个空的单链表！
";
            }
            break;
        case 2: // 创建单链表（前插法）
            CreateList_H(L);
            cout << "前插法创建单链表输出结果：
"  << endl;
            Listprint_L(L);
            break; 
        case 3: // 创建单链表（尾插法）
            CreateList_R(L);
            cout << "尾插法创建单链表输出结果：
" << endl;
            Listprint_L(L);
            break;
        case 4:  // 单链表的按序号取值
            cout << "请输入一个位置用来取值：" << endl;
            cin >> i;
            if(GetElem_L(L, i, e)){
                cout << "查找成功
";
                cout << "第" << i << "个元素是：" << e << endl;
            } else
            {
                cout << "查找失败
" << endl;
            }
            break;
        case 5:  // 单链表的按值查找
            cout << "请输入所要查找元素x" << endl;
            cin >> x;
            if(LocateElem_L(L,x))
                cout << "查找成功" << endl;
            else
                cout << "查找失败！" << endl;
            break;
        case 6:  // 单链表插入
            cout << "请输入出入的位置和元素（用空格隔开）：";
            cin >> i;
            cin >> x;
            if(ListInsert_L(L, i, x))
                cout << "插入成功" << endl;
            else
                cout << "插入失败！" << endl;
            break;
        case 7:  // 单链表删除
            cout << "请输入所有删除的元素位置i:"  << endl;
            cin >> i;
            if(ListDelect_L(L, i))
                cout << "当前单链表的数据元素分别为：" << endl;
                Listprint_L(L);
                cout << endl;
                break;
        }
    }
    
    return 0;
}

 

通过传递应用变量来获取返回值  e。

case 4:  // 单链表的按序号取值
   cout << "请输入一个位置用来取值：" << endl;
   cin >> i;
   if(GetElem_L(L, i, e)){
       cout << "查找成功
";
       cout << "第" << i << "个元素是：" << e << endl;
    } else 9         cout << "查找失败
" << endl;11    break;

bool GetElem_L(LinkList L, int i, int &e){  // 单链表的取值
    // 在带头结点的单链表L中查找第i个元素
    // 用e记录L中第i个元素的值
    int j;
    LinkList p;
    p = L->next;  // p指向第一个结点
    j = 1; // j为技术器
    while(j<i && p){  // 顺链域向后扫描，直到p指向第i个元素或者p为空
        p = p->next;  //p指向小一个结点
        j++;  // 计数器j相应加1
    }
    if(!p || j>i)
        return false;   // i值不合法i>n 或 i<=0
    e = p->data;
    return true;
    
}

2、两个非递减链表合并

Lc辅助头指正   重复利用头结点

#include <iostream>
#include <string>

using namespace std;

typedef struct LNode
{
    int data; 
    struct LNode *next;
}LNode, *LinkList;

void CreateList_R(LinkList &L){
    int n;
    LinkList s, r;
    L = new LNode;
    L->next = NULL;
    r = L;
    cout << "请输入元素个数n:" << endl;
    cin >> n;
    cout << "请依次输入n个整型数（非递归）：" << endl;
    cout << "尾插法创建单链表..." << endl;
    while (n--)
    {
        s = new LNode;
        cin >> s->data;
        s->next = NULL;
        r->next = s;  // 将新节点s插入尾结点r之后
        r = s; // r指向新的尾结点s
    }
}

void mergelinklist(LinkList La, LinkList Lb, LinkList &Lc){
    LinkList p, q, r;  // 结构体指针变量
    p = La->next;
    q = Lb->next;
    Lc = La;  // 这里Lc是没有创建的，而是直接借鉴La来创建链表
    r = Lc;  // r指向Lc的尾部
    while(p && q){
        if(p->data <= q->data){  // 把p指向的结点串起来
            r->next = p;
            r = p;
            p = p->next;  // p更新  p后移一个结点
        }else{
            r->next = q;
            r = q;
            q = q->next;  // q更新  q后移一个结点
        }
    }
    r->next = p ? p : q;
    delete Lb;
}

void Listprint_L(LinkList L){
    LinkList p;
    p = L->next;
    while (p)
    {
        cout << p->data << "	";
        p = p->next;
    }
    cout <<  endl;
    
}


int main(){
    LinkList La, Lb, Lc;
    cout << "创建有序（非递减）单链表La" << endl;
    CreateList_R(La);
    cout << "创建有序（非递减）单链表Lb" << endl;
    CreateList_R(Lb);
    mergelinklist(La, Lb, Lc);
    cout << "合并后的结果Lc：" << endl;
    Listprint_L(Lc);
    return 0;
}

3、单链表 高效 取中间节点   

思路：快慢指针

链表长度为7 中间节点为4

链表长度为6 中间节点为3

#include <iostream>

using namespace std;

typedef struct LNode{
    int data;
    struct LNode *next;
}LNode, *LinkList;

void CreateList_R(LinkList &L){
    int n;
    LinkList s, r;
    L = new LNode;
    L->next = NULL;
    r = L;
    cout << "请输入元素个数n:" << endl;
    cin >> n;
    cout << "尾插法（正序）创建单链表..." << endl;
    while (n--)
    {
        s = new LNode;
        cin >> s->data;
        s->next = NULL;
        r->next = s;
        r =s;
    }
}

LinkList findmiddle(LinkList L){ // 快慢指针找中间元素
    LinkList fast, slow;
    fast = L;
    slow = L;
    while (fast!=NULL && fast->next!=NULL)
    {
        fast = fast->next->next;
        slow = slow->next;
    }
    return slow;
}

void Listprint_L(LinkList L){
    LinkList p;
    p = p->next;
    while (p)
    {
        cout << p->data << "	";
        p = p->next;
    }
    cout << endl;
}
 
int main(){
    LinkList L, mid;
    cout << "创建单链表L:" << endl;
    CreateList_R(L);
    mid = findmiddle(L);
    cout << "单链表中间节点数据为：" << mid->data << endl;
    return 0;
}