数据结构复习之单链表

#include <iostream>
using namespace std;
struct LNode{
    int data; // 数据域
    struct LNode *next; // 下一指针域
};

void LinkReverse();
void DeleMin(LNode *L);

void HeadAdd(LNode *L, int e){
    // 在头节点后插入e
    LNode *q, *p = L;
    // 开辟空间
    q = (LNode*)malloc(sizeof(LNode));
    
    q->data = e;
    q->next = p->next;
    p->next = q;
}

void TailAdd(LNode *L, int e){
    // 尾插法
    LNode *q, *p = L;
    // 开辟空间
    q = (LNode *)malloc(sizeof(LNode));
    
    while(p->next != NULL){
        p = p->next;
    }
    
    q->data = e;
    q->next = p->next;
    p->next = q;
}

bool Look(LNode *L, int e){
    // 查找单链表中数据域结点值为e的指针
    LNode *p = L;
    while(p != NULL){
        p = p->next;
        if (p->data == e){
            return true;
        }
    }
    return false;
}

bool DelElem(LNode *L, int e){
    // 单链表按值删除
    LNode *q = L, *p = L->next; // q是p的前驱
    while(p != NULL){
        if (p->data == e){
            // 当找到e,此时p指向e, q仍为p的前驱
            break;
        }
        p = p->next;
        q = q->next;
    }
    if(p -> data == e){
        q->next = p->next;
        free(p);
        return true;
    }else {
        return false;
    }
    
    return false;
}

void print(LNode *p){
    // 打印单链表
    cout << "开始打印..." << endl;
    int i = 0;
    while(p){
        cout << i++ << ":" << p->data << endl;
        p = p->next;
    }
}

int main(){
    
    // 头节点
    LNode *head;
    head = (LNode *)malloc(sizeof(LNode));
    head->data = 101;
    head->next = NULL;
    cout << "head:" << head->data << endl;
    
    cout << "头插法" << endl;
    // 先插入102,变为 101->102
    HeadAdd(head, 102);
    // 再插入103,变为101->103->102
    HeadAdd(head, 103);
    print(head);
    cout << endl;
    
    cout << "尾插法" << endl;
    // 先插入104,变为101->103->102->104
    TailAdd(head, 104);
    // 再插入105,变为101->103->102->105
    TailAdd(head, 105);
    print(head);
    
    
    // 查找元素
    if (Look(head, 104)){
        cout << "104已找到" << endl;
    }else {
        cout << "没找到" << endl;
    }
    cout << endl;
    
    cout << "删除103元素" << endl;
    if (DelElem(head, 103)){
        cout << "删除成功" << endl;
        print(head);
    }else {
        cout << "删除失败, 没有103这个元素" << endl;
    }
    

    cout << endl;
    cout << "下面是练习" << endl;
    cout << "1.反向输出单链表各个节点的值" << endl;
    LinkReverse();
    cout << endl;
    
    cout << "2.写一种高效算法来删除单链表中最小值,保证最小值唯一" << endl;
    cout << "默认链表是L: head->4->6->3->2->5->1->7"<< endl;
    LNode *L;
    L = (LNode *)malloc(sizeof(LNode));
    L->data = 0;
    L->next = NULL;
    TailAdd(L, 4);
    TailAdd(L, 6);
    TailAdd(L, 3);
    TailAdd(L, 2);
    TailAdd(L, 5);
    TailAdd(L, 1);
    TailAdd(L, 7);
    
    DeleMin(L);
    return 0;
}

// 设L位带头节点的单链表,编写算法实现从尾到头反向输出每个节点的值
void LinkReverse(){
    LNode *L;
    LNode *ans;
    L = (LNode *)malloc(sizeof(LNode));
    L->data = 0;
    L->next = NULL;
    ans = (LNode *)malloc(sizeof(LNode));
    ans->data = 0;
    ans->next = NULL;
    
    for (int i = 1; i <= 5; i++){
        TailAdd(L, i);
    }
    cout << "初始链表:" << endl;
    print(L);
    cout << endl;
    
    LNode *p = L->next;
    while (p != NULL){
        HeadAdd(ans, p->data);
        p = p->next;
    }
    print(ans);
}

void DeleMin(LNode *L){
    LNode *p = L->next;
    int min = L->next->data;
    while(p != NULL){
        if (p->data < min){
            min = p->data;
        }
        p = p->next;
    }
    DelElem(L, min);
    print(L);
}

输出结果

head:101
头插法
开始打印...
0:101
1:103
2:102

尾插法
开始打印...
0:101
1:103
2:102
3:104
4:105
104已找到

删除103元素
删除成功
开始打印...
0:101
1:102
2:104
3:105

下面是练习
1.反向输出单链表各个节点的值
初始链表:
开始打印...
0:0
1:1
2:2
3:3
4:4
5:5

开始打印...
0:0
1:5
2:4
3:3
4:2
5:1

2.写一种高效算法来删除单链表中最小值,保证最小值唯一
默认链表是L: head->4->6->3->2->5->1->7
开始打印...
0:0
1:4
2:6
3:3
4:2
5:5
6:7
Program ended with exit code: 0