DS 线性表2：建设“单链表”算法库

最新推荐文章于 2022-10-02 09:36:34 发布
最新推荐文章于 2022-10-02 09:36:34 发布
阅读量243 收藏 1
点赞数 1
分类专栏： DS线性表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_39286218/article/details/80249381
版权

任务和代码：

main.cpp
/*  
*All rights reserved  
*文件名称:main.c  
*作者: Osseyda  
完成日期：2018.5.9 
*版本号：v2.  
*  
*问题描述：单链表的应用 
*问题输出：程序的多文件组织形式 
*/    
#include <stdio.h>
#include "list.h"

int main(){
    LinkList *Li, *Li1, *Li2;
    InitList(Li);
    ElemType x[7]= {5,8,7,2,5,4,9};
    ElemType e1, e2;
    /*首插法创建单链表*/
    CreateListH(Li, x, 7);
    printf("首插法创建单链表: ");
    DispList(Li);
    printf("\n");
    /*尾插法创建单链表*/
    CreateListT2(Li, x, 7);
    printf("尾插法创建单链表: ");
    DispList(Li);
    printf("\n");
    /*判断该链表是否为空，不为空则打印长度*/
    if(ListEmpty(Li))
        printf("该链表为空");
    else
        printf("该链表不为空且长为%d",ListLength(Li));
    printf("\n\n");
    /*读指定位置的元素值并打印*/
    if(GetElem(Li,4,e1))
        printf("4号位置对应的元素: %d",e1);
    else
        printf("位置不在链表长度之内");
    printf("\n\n");
    /*读指定元素位置并打印*/
    if(LocateElem(Li,11))
        printf("元素值11对应的位置为: %d",LocateElem(Li,11));
    else
        printf("元素值11对应元素不在此链表内");
    printf("\n\n");
    /*指定位置插入元素并打印新的链表*/
    ListInsert(Li,2,3);
    printf("在第2个元素位置添加元素3：");
    DispList(Li);
    printf("\n");
    /*删除指定位置的元素并打印新的链表*/
    ListDelete(Li,5,e2);
    printf("删除5号位置元素%d后的新链表：",e2);
    DispList(Li);
    printf("\n");
    /*删除元素最大的结点后的新链表*/
    delmaxnode(Li);
    printf("删除元素最大的结点后的新链表：");
    DispList(Li);
    printf("\n");
    /*增序排列结点后的新链表*/
    sortUp(Li);
    printf("增序排列结点后的新链表：");
    DispList(Li);
    printf("\n");
    /*拆分单链表，奇数位和偶数位上的元素各自形成链表*/
    printf("L->L1,L2\n");
    split(Li, Li1, Li2);
    printf("子链表L1： ");
    DispList(Li1);
    printf("子链表L2： ");
    DispList(Li2);
    printf("\n");
    return 0;
}
list.h
#ifndef LIST_H_INCLUDED
#define LIST_H_INCLUDED
typedef char ElemType;
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LinkList;
void InitList(LinkList *&L);
bool ListEmpty(LinkList *L);
void CreateListH(LinkList *&L, ElemType a[], int n);
void CreateListT1(LinkList *&L, ElemType a[], int n);
void CreateListT2(LinkList *&L, ElemType a[], int n);
void DestoryList(LinkList *&L);
int ListLength(LinkList *L);
void DispList(LinkList *L);
bool GetElem(LinkList *L, int i, ElemType &e);
int LocateElem(LinkList *L, ElemType e);
bool ListInsert(LinkList *&L, int i, ElemType e);
bool ListDelete(LinkList *&L, int i, ElemType &e);
void split(LinkList *&L, LinkList *&L1, LinkList *&L2);
void delmaxnode(LinkList *&L);
void sortUp(LinkList *&L);
#endif // LIST_H_INCLUDED
list.cpp
#include <stdio.h>
#include "list.h"
#include <malloc.h>

//1.初始化线性表
void InitList(LinkList *&L){
    L=(LinkList *)malloc(sizeof(LinkList));
    L->next=NULL;
}

//2.判断线性表是否为空表
bool ListEmpty(LinkList *L){
    return (L->next==NULL);
}

//3.在新结点与首结点间不断插入新结点,
void CreateListH(LinkList *&L, ElemType a[], int n){
    LinkList *s;
    int i;
    L=(LinkList *)malloc(sizeof(LinkList));
    L->next=NULL;
    for(i=0; i<n; i++){
        s=(LinkList *)malloc(sizeof(LinkList));
        s->data=a[i];
        s->next=L->next;
        L->next=s;     //L->next是跟随结点
    }
}

//4.在新插入的结点之后继续插入结点
void CreateListT1(LinkList *&L, ElemType a[], int n){
    LinkList *s, *r; //把r看成结点增量
    int i;
    L=(LinkList *)malloc(sizeof(LinkList));
    r=L;
    for(i=0; i<n; i++){
        s=(LinkList *)malloc(sizeof(LinkList));
        s->data=a[i];
        r->next=s;
        r=s;
    }
    r->next=NULL;
}

//5.在新插入的结点与NULL之间不断插入新结点
void CreateListT2(LinkList *&L, ElemType a[], int n){
    LinkList *s, *r;    //r是跟随结点
    int i;
    L=(LinkList *)malloc(sizeof(LinkList));
    r=L;
    for(i=0; i<n; i++){
        s=(LinkList *)malloc(sizeof(LinkList));
        s->data=a[i];
        s->next=NULL;
        r->next=s;
        r=s;
    }
}

//6.销毁线性链表
void DestoryList(LinkList *&L){
    LinkList *pre=L, *p=L->next;
    while (p!=NULL){
        free(pre);
        pre=p;       //pre是追随结点
        p=p->next;
    }
    free(pre);
}

//7.求线性表的长度
int ListLength(LinkList *L){
    int n=0;
    LinkList *p=L->next;
    while(p!=NULL){
        n++;
        p=p->next;
    }
    return n;
}

//8.输出线性表
void DispList(LinkList *L){
    LinkList *p=L->next;
    while(p!=NULL){
        printf("%d ", p->data);
        p=p->next;
    }
    printf("\n");
}

//9.求线性表指定位置的某个元素
bool GetElem(LinkList *L, int i, ElemType &e){
    LinkList *p=L;
    int j=0;
    while(j<i && p!=NULL){
        j++;
        p=p->next;
    }
    if(p==NULL)
        return false;
    else{
        e=p->data;
        return true;
    }
}

//10.按元素值查找在线性表中的位置
int LocateElem(LinkList *L, ElemType e){
    int i=1;
    LinkList *p=L->next;
    while(p!=NULL && p->data!=e){
        p=p->next;
        i++;
    }
    if(p==NULL)
        return 0;
    else
        return i;
}

//11.插入数据元素
bool ListInsert(LinkList *&L, int i, ElemType e){
    LinkList *q=L, *s;
    int j=0;
    while(j<i-1 && q!=NULL){
        j++;
        q=q->next;
    }
    if(j==i-1){
        if(q==NULL)
            return false;
        else{
            s=(LinkList *)malloc(sizeof(LinkList));
            s->data=e;
            s->next=q->next;
            q->next=s;
        }
        return true;
    }
    else
        return false;
}

//12.删除数据元素
bool ListDelete(LinkList *&L, int i, ElemType &e){
    LinkList *q=L, *p=L->next;
    int j=1;
    while(j<i && p!=NULL){
        j++;
        q=p;
        p=p->next;
    }
    if(i==j){
        if(p==NULL)
            return false;
        else{
            e=p->data;
            q->next=p->next;
            free(p);
            return true;
        }
    }
    else
        return false;
}

//13.拆分单链表
void split(LinkList *&L, LinkList *&L1, LinkList *&L2){
    LinkList *p=L->next, *q, *r1;
    L1=L;
    r1=L1;
    L2=(LinkList *)malloc(sizeof(LinkList));
    L2->next=NULL;
    while(p!=NULL){
        r1->next=p;
        r1=p;             //r1是p的跟随结点
        p=p->next;
        if(p!=NULL){   //防止出现奇数个元素时，q出现野指针的情况
            q=p->next;
            p->next=L2->next;
            L2->next=p;
            p=q;              //q是p的领跑结点
        }
    }
    r1->next=NULL;
}

//14.删除最大元素节点
void delmaxnode(LinkList *&L){
    LinkList *p=L->next, *pre=L, *maxp=p, *maxpre=pre;
    while(p!=NULL){
        if(maxp->data < p->data){
            maxp=p;
            maxpre=pre;  //pre的作用
        }
        pre=p;
        p=p->next;   //pre是p的跟随结点
    }
    maxpre->next=maxp->next;
    free(maxp);
}

//15.增序排列结点
void sortUp(LinkList *&L){
    LinkList *p, *pre, *q;   //pre是p的前一个结点
    p=L->next->next;
    L->next->next=NULL;
    while(p!=NULL){
        q=p->next;           //在p->next未变化之前先定下p的领跑结点
        pre=L;
        while(pre->next!=NULL && pre->next->data<p->data)
            pre=pre->next;   //找到pre
        p->next=pre->next;
        pre->next=p;
        p=q;                 //若p=p->next则进入死循环
    }
}

Result：

 

Osseyda
关注
专栏目录
假设有两个按元素值递增排列的线性表，均已单链表形式存储，将这两个单链表归并为一个按元素值递减排列的单链表（C语言版）
m0_75063536的博客
11-27 1070
这个算法的基本思路是，首先定义一个虚拟节点作为新链表的头部，然后比较两个链表的当前节点值，将较小的节点插入到新链表的尾部，然后更新相应的指针。最后，将新链表反转，使元素值递减排列。在示例代码中，我们创建了两个有序链表，然后调用。函数将结果链表反转。最后，打印出合并后的链表。// 反转链表，使元素值递减排列。// 创建第一个有序链表。// 创建第二个有序链表。// 合并两个有序链表。函数将它们合并，并通过。// 插入节点到链表头部。// 定义链表节点结构。// 合并两个有序链表。
线性表的单链表实现
08-09
System.out.println("Contains 2: " + list.contains(2)); list.remove(1); System.out.println("After removing 1: " + list); } } ``` 通过这些类和测试，我们可以了解单链表如何作为线性表的一种实现，...
数据结构实验之链表五：单链表的拆分
LsMrSUN的博客
05-06 1429
数据结构实验之链表五：单链表的拆分 Time Limit: 1000ms   Memory limit: 65536K  有疑问？点这里^_^ 题目描述 输入N个整数顺序建立一个单链表，将该单链表拆分成两个子链表，第一个子链表存放了所有的偶数，第二个子链表存放了所有的奇数。两个子链表中数据的相对次序与原链表一致。 输入 第一行输入整数N;；
单链表分离(头插法和尾插法的结合,理解指针变换)
qq_57484399的博客
10-01 980
强调,这两步不能颠倒,我们建立链表肯定会进行这两步操作是无疑的, 但是当我们覆盖一个指针的时候,要考虑这个指针里面是否存着我们需要的信息, 插入前,L2->next 里面存放的是第一个结点 的位置, 我们还要用到, 所以要先进行这一步, 然后再把新节点的位置给 头结点的尾指针.当判断bn 后面没有结点的时候, 我们就可以结束了, 刚才我们用 q 来存放 b 断开联系后的下一个结点 ,那当bn的尾指针是NULL的时候 , 我们就可以结束了, 意思就是不用连接了, 因为 bn 断开后, 没有后继节点了.
单链表删除元素最大的节点
qq_57484399的博客
10-02 3223
现在已经找到了最大的节点, 下面就把最大节点前后的节点链接起来, 然后释放最大节点的空间就可以了。然后每遍历一个节点, 就与最大的结点 进行比较, 如果比最大的节点大, 那就把她当成最大节点,如果 新节点比最大节点大 , 那么就需要把 最大节点和最大节点的前一节点的指针指向新节点。//最大节点的前一个节点。初始的时候 , 最大的结点就是第一个节点 , 最大节点前一节点就是头节点。所以 , 我们只需要知道最大节点的前一个节点 和最大节点就可以了。把最大节点的前一个节点的尾指针指向, 最大节点的后一个节点。
C语言数据结构拦路虎（三）-首插法单链表的理解
f的博客
03-03 437
如果对代码的一些函数或者概念不清楚请读前面两节 定义一个节点，包括数据data，指针next typedef struct node { datatype data; struct node *next; }Linklist; Linklist *head,*p; 理解指针 next ！！！一定要调试，可以画画图，标出地址，起新名字。这样更好理解 1、next，head...
精读大话数据结构，陪你拿下45分 EP2
fanzhaokai0420的博客
08-28 1160
上一期我们学习了数据结构的基本知识，那么这次就要进入实战啦！ 回顾： 什么是线性表？ 内存中以顺序存储的表。 这里我们就要以线性表讲起，来实现各种接口函数 线性表基本形式 #define MAXSIZE 20 //定长顺序表 //方便我们的删改 typedef int SQdateType; //便于更换顺序表的存储元素类型 struct SeqList { int arr[MAXSIZE]; //这个是最大长度，就是总的最大存储容量 int length; //当前表长， }; typ
线性表-3-单链表的头插法与尾插法创建.cpp
06-24
线性表-3-单链表的头插法与尾插法创建.cpp
C++实现数据结构线性表：顺序表与单链表操作
"该资源是一个关于C++实现数据结构中线性表的教程，主要涵盖了顺序表和单链表的基本操作，包括增删改查，以及如何合并两个有序线性表。提供了完整的C++代码实现，并附有注释。代码已在Dev-C++5.4.0环境下测试通过，...
线性表，单链表，栈 java实现
12-09
线性表、单链表和栈是数据结构中基础且重要的概念，它们在计算机科学和软件工程中扮演着核心角色。下面将详细解释这些概念及其Java实现。 **线性表** 是一种基本的数据结构，它是由n（n>=0）个相同类型元素构成的...
精读大话数据结构，陪你拿下45分 EP3
fanzhaokai0420的博客
09-07 152
前面我们学过了顺序表，顺序表指在物理内存中一个紧挨着一个排列的，顺序表中每个元素的地址间是紧密相连的。这种表删除和插入及其麻烦，因为我们要将所有元素后移，最坏的时间复杂度为O(n），所有在处理大量并且顺序和个数随时可变的数据时，采用今天所讲的链表 链表的基本定义 链表是物理内存中每个节点的地址不连续的一种表，他们间通过指针连接，对于链表的基本定义，这里不再多言 我们只需要清楚链表由节点构成，并且由一个头指针标记整个链表。 今天我们所要研究的是链表种的顺序表，即节点的指针域指向下一个节点的地址 节点
【数据结构实验期末考试】---删除单链表中第一个最大元素及其重复结点
池塘春草梦的博客
12-16 2619
1. 已知单链表A，编写一个算法，删除单链表中第一个最大元素。 2. 已知单链表L, 编写一个算法，删除其重复的结点（只保留一个）。
删除单链表中元素值最大的节点
wangzhaoweng的博客
06-05 8940
#include #include #include using namespace std; typedef struct LNode { int data; struct LNode *next; } LinkList; void InitList(LinkList *&L) { L=(LinkList *)malloc(sizeof(LinkList));
链表的首插法和尾插法
球迷保罗的博客
09-21 456
#include<stdio.h> #include<stdlib.h> #include<string.h> typedef struct list_Node{ int data; struct list_Node * node; } L; //头插法 L* FristList(){ L* head=(L*)m...
线性表——链式存储结构之双链表
seu_nuaa_zc的博客
06-09 405
该文章主要介绍线性表的链式存储运算以及相关运算—双链表。 头文件：DLinkList.h template struct DLinkList //双链表结点类型 { T data; //存放数据元素 DLinkList *prior; //指向前一个结点的域 DLinkList *next; //指向下一个结点的域 }; templat
从单链表中删除最大的元素，单链表元素排序
>>向着CTO前进>>
06-09 1010
public class LinkList { public Node head; public LinkList() { head = new Node(); head.next = null; } //尾插法 public void createByTail(int[] arr, int n) { Node tail = head; for(int i=0; i
单链表 首插法
taotaox的专栏
05-21 646
#includeusing namespace std;typedef struct node{        char data;        struct node * next;}ListNode; typedef ListNode *LinkList;LinkList CreateListF(){   char ch;   LinkList hea
[数据结构]头插法与尾插法
热门推荐
ilikeprograming的专栏
09-29 1万+
#include "stdio.h" #include "stdlib.h" typedef struct List { int data; //数据域 struct List *next; //指针域 } List; void TailCreatList(List *L) //尾插法建立链表 { List *s, *r;//s用来指向新生成的节点。r始终指向L的终端节点。 r = L;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值