数据结构自学记录(二):单链表

代码实现:

//
// Created by ly on 18-11-9.
//
#include <bits/stdc++.h>
using namespace std;
typedef struct Node* ptrLNode;
struct Node {
    int data;
    ptrLNode next;

}LNode;
//头插法，建立单链表
void CreateListF(ptrLNode &L,int a[],int n)
{
    ptrLNode s;
    int i;
    L = (ptrLNode)malloc(sizeof(LNode));
    L->next = NULL; //创建头结点
    for(int i = 0;i < n;i++)
    {
        s = (ptrLNode)malloc(sizeof(LNode));
        s->data = a[i];
        s->next = L->next;
        L->next = s;
    }
}

//尾插法，建立单链表
void CreateListR(ptrLNode &L,int a[],int n)
{
    ptrLNode s,r;
    int i;
    L = (ptrLNode)malloc(sizeof(LNode));
    r = L;
    for(int i = 0;i < n;i++)
    {
        s = (ptrLNode)malloc(sizeof(LNode));
        s->data = a[i];
        r->next = s;
        r = s;
    }
    r->next = NULL;
}

//初始化线性表
void InitList(ptrLNode &L)
{
    L = (ptrLNode)malloc(sizeof(LNode));//创建头结点
    L->next = NULL;
}

//销毁线性表Destory（L）
void DestroyList(ptrLNode &L)
{
    ptrLNode pre,p;
    pre = L;
    p = L->next;
    while(p != NULL)
    {
        free(pre);
        pre = p;
        p = p->next;
    }
    free(pre);
}

//判断线性表是否为空表
bool isEmpty(ptrLNode L)
{
    return (L->next == NULL);
}

//求链表的长度
int ListLength(ptrLNode L)
{
    int len = 0;
    ptrLNode p;
    p = L;
    while (p->next != NULL)
    {
        ++len;
        p = p->next;
    }
}

//求线性表中位置I的元素
bool GetElem(ptrLNode L,int i,int &e) {
    int j = 0;
    ptrLNode p = L;
    while (j < i && p != NULL) {
        ++j;
        p = p->next;
    }
    if (p == NULL)
        return false;
    else {
        e = p->data;
        return true;
    }
}

//按元素值查找,时间复杂度为O（n）
int LocateElem(ptrLNode L,int key)
{
    int i = 1;
    ptrLNode p = L->next;
    while(p != NULL && p->data != key) {
        p = p->next;
        i++;
    }
    if(p == NULL)
        return 0;
    else
        return i;

}

//插入数据元素
bool ListInsert(ptrLNode &L,int i,int key)
{
    int j = 0;
    ptrLNode p = L;
    ptrLNode s;
    while(j < i-1 && p != NULL)
    {
        j++;
        p = p->next;
    }
    if(p == NULL)
    {
        return false;
    } else {
        s = (ptrLNode) malloc(sizeof(LNode));
        s->data = key;
        s->next = p->next;
        p->next = s;
        return true;
    }
}
//删除数据元素
bool ListDelete(ptrLNode &L,int i,int key)
{
    int j = 0;
    ptrLNode p = L;
    ptrLNode q;
    while (j < i-1 && p->next != NULL)
    {
        j++;
        p = p->next;
    }
    if(p == NULL)
        return false;
    else {
        q = p->next;
        if(q == NULL)
        {
            return false;
        }
        key = q->data;
        p->next = q->next;
        free(q);
        return true;
    }
}
//for test
void PrintList(ptrLNode L)
{
    ptrLNode p;
    p = L->next;
    cout << "begin" << endl;
    while(p != NULL)
    {
        cout << p->data << " ";
        p = p -> next;
    }
    cout << endl;
    cout << "end" << endl;

}

//算法设计 删除单链表中值域最大的节点
void deleteMaxNode(ptrLNode &L)
{
    ptrLNode pre = L;
    ptrLNode p = L->next;
    ptrLNode maxPre = pre;
    ptrLNode maxP = p;
    while(p != NULL)
    {
        if(maxP->data < p->data)
        {
            maxP = p;
            maxPre = pre;
        }
        pre = p;
        p = p->next;
    }
    maxPre->next = maxP->next;
    free(maxP);
}

//算法设计 单链表排序
void ListSort(ptrLNode &L)
{
    ptrLNode p,pre,q;
    p = L->next->next;
    L->next->next = NULL;
    while(p != NULL)
    {
        q = p->next;
        pre = L;
        while (pre->next != NULL && pre->next->data < p->data)
        {
            pre = pre->next;
        }
        p->next = pre->next;
        pre->next = p;
        p = q; //扫描原单链表余下的结点
    }
}

//算法设计  ，单链表的所有结点逆之
//方式1：头插法建表
void Reverse(ptrLNode &L)
{
    ptrLNode p,q;
    p = L->next;
    L->next = NULL;
    while(p != NULL) {
        q = p->next;
        p->next = L->next;
        L->next = p;
        p = q;
    }
}
//解法2
void Reverse2(ptrLNode L)
{
    ptrLNode p,q,r;
    p = L->next;
    q = L->next->next;
    r = L->next->next->next;
    // 同步向后面移动...


}
//算法设计：将L，分割成L1，L2
void split(ptrLNode &L,ptrLNode &L1,ptrLNode &L2)
{
    ptrLNode p,q,r1;
    L1 = L;
    r1 = L;
    L2 = (ptrLNode)malloc(sizeof(LNode));
    L2->next = NULL;
    while(p != NULL) {
        r1->next = p;
        r1 = p;
        p = p->next;
        q = p->next;
        p->next = L2->next;
        L2->next = p;
        p = q;
    }
    r1->next = NULL;
}

//单链表实现：荷兰国旗问题
void move2(ptrLNode &L)
{
    //准备工作
    ptrLNode L1,L2,r,r1,r2,p;
    L1 = NULL;
    L2 = NULL;
    p = L->next;
    r = L;
    //插入工作
    while(p != NULL)
    {
        //插入到L，头插法
        if(p->data == 0)
        {
            r->next = p;
            r = p;
        }
        //建立L1不带头结点的单链表
        else if(p->data == 1) {
            if (L1 == NULL)
                L1 = p, r1 = p;
            else {
                r1->next = p;
                r1 = p;
            }
        }
        //建立L2不带头结点的单链表
        else {
            if(L2 == NULL)
            {
                L2 = p;r2 = p;
            } else{
                r2->next = p;
                r2 = p;
            }
        }
        p = p->next;
    }
    //结尾工作
    r->next = r1->next = r2->next = NULL;
    r->next = L1;
    r1->next = L2;
}

int main(void)
{
    int a[] = {1,2,3,4,5,6,7,8,9};
    int len = sizeof(a) / sizeof(int);
    cout << len << endl;
    ptrLNode L;
    //L = (ptrLNode)malloc(sizeof(LNode));
    CreateListF(L,a,len);
    PrintList(L);
    ptrLNode L1;
    CreateListR(L1,a,len);
    PrintList(L1);

    cout << endl;

    //for test  sort
    int b[] = {123,5,12,3,4,13,4,5};
    int len2 = sizeof(b) / sizeof (int);
    ptrLNode L2;
    CreateListF(L2,b,len2);
    ListSort(L2);
    PrintList(L2);
    //for test Reverse
    Reverse(L2);
    PrintList(L2);
    int b1[] = {1,0,2,1,0,0,1,2,2,1,0,2};
    ptrLNode BL;
    CreateListR(BL,b1,12);
    cout << "BL.........." << endl;
    PrintList(BL);
    move2(BL);
    PrintList(BL);
}