线性表-链式存储结构及南航学硕专硕编程真题12-18年(只有链表和顺序表)

最新推荐文章于 2024-07-29 21:39:59 发布
最新推荐文章于 2024-07-29 21:39:59 发布
阅读量261 收藏 2
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wh_computers/article/details/84331214
版权

包含了线性表的基本操作以及南航考研真题的链表操作 12-18年

#include<bits/stdc++.h>
using namespace std;

typedef struct Sqlist {
    int val;
    Sqlist *next;
}*ListNode;

bool InitList(ListNode &listnode)//创建一个空的线性表 
{
    listnode = (ListNode)malloc(sizeof(Sqlist));
    if(!listnode)
    {
        printf("分配失败\n");
        return false;
    }
    listnode->val = -1;
    listnode->next = NULL;
    return true;
}

ListNode SetupList()//给线性表赋值 
{
    ListNode head;
    InitList(head);//创建一个空表 
    ListNode listnode;
    listnode = head;//指向头结点 
    int val,count;
    printf("请输入线性表元素的个数:");
    scanf("%d",&count); 
    printf("请输入线性表的元素:");
    for(int i = 0;i < count;i++)
    {
        scanf("%d",&val);
        listnode->next = (ListNode)malloc(sizeof(Sqlist));
        listnode = listnode->next;
        listnode->val = val;
    }
    listnode->next = NULL;
    return head;
    
}

void DisplayList(ListNode head)//输出链表的所有元素 
{
    ListNode listnode;
    listnode = head;//指向链表头结点    
    while(listnode->next != NULL)
    {
        listnode = listnode->next;
        printf("%d ",listnode->val);
    }    
}

bool DestroyList(ListNode &head)//销毁线性表 
{
    ListNode listnode;
    while(head != NULL)
    {
        listnode = head;
        head = head->next;
        free(listnode);
    }
    head = NULL;
    return true;
}

bool ClearList(ListNode &head)//置线性表为空 
{
    ListNode listnode,tmp;
    listnode = head->next;//从头结点的下一个结点开始 
    tmp = listnode; 
    while(listnode != NULL)
    {
        tmp = listnode;
        listnode = listnode->next;
        free(tmp);
    }
    head->next = NULL;
    return true;
}

bool ListEmpty(ListNode head)//判空 
{
    if(head != NULL && head->next == NULL)
        return true;
    else
        return false;
}

int ListLength(ListNode listnode)//返回数据元素的个数 
{
    int length = 0;
    listnode = listnode->next;//从头结点的下一个结点开始算
    while(listnode != NULL)
    {
        length++;
        listnode = listnode->next;
    } 
    return length;
}

void ListDelete(ListNode &head,int elem)//删除 
{
     ListNode cur,pre;//当前节点和前驱
     cur = head->next;
     pre = head;
     while(cur != NULL)
     {
        if(cur->val == elem)
        {
            ListNode del = cur;
            pre->next = cur->next;
            cur = cur->next;
            free(del);
        }     
        else
        {
            cur = cur->next;
            pre = pre->next;
        }
     }    
} 

bool ListFind(ListNode head,int elem)//在链表中查找某个元素是否存在 
{
    ListNode listnode = head->next;
    while(listnode != NULL)
    {
        if(listnode->val == elem)
            return true;
        else
            listnode = listnode->next;
    }
    return false; 
}

bool Sort_Ascend(ListNode &head)//采用插入排序使线性表非递减 
{
    //先判断是否是空表或者只有一个元素 那么一定是有序的
    if(ListEmpty(head) || ListEmpty(head->next))
        return true;
    ListNode listnode;
    listnode = head->next->next;//从第二个元素开始
    head->next->next = NULL;//断掉原来的链表 
    while(listnode != NULL)
    {
        ListNode tmp = listnode;//取出一个元素 
        listnode = listnode->next;
        ListNode pre = head;//每次判断的头结点
        ListNode cur = head->next;// 需要比较的当前节点 
        while(cur != NULL)
        {
            if(cur->val > tmp->val)//小于当前节点的值则需要插入 
            {
                tmp->next = cur;
                pre->next = tmp;
                break;    
            }    
            else if(cur->next == NULL)//到达链表尾部，插入尾部 
            {
                cur->next = tmp;
                tmp->next = NULL;
                break;
            }
            else
            {
                cur = cur->next;
                pre = pre->next;
            }
        }    
    } 
    return true;
}

bool Sort_Descend(ListNode &head)//采用插入排序使线性表非递增 
{
    //先判断是否是空表或者只有一个元素 那么一定是有序的
    if(ListEmpty(head) || ListEmpty(head->next))
        return true;
    ListNode listnode;
    listnode = head->next->next;//从第二个元素开始
    head->next->next = NULL;//断掉原来的链表 
    while(listnode != NULL)
    {
        ListNode tmp = listnode;//取出一个元素 
        listnode = listnode->next;
        ListNode pre = head;//每次判断的头结点
        ListNode cur = head->next;// 需要比较的当前节点 
        while(cur != NULL)
        {
            if(cur->val < tmp->val)//大于当前节点的值则需要插入 
            {
                tmp->next = cur;
                pre->next = tmp;
                break;    
            }    
            else if(cur->next == NULL)//到达链表尾部，插入尾部 
            {
                cur->next = tmp;
                tmp->next = NULL;
                break;
            }
            else
            {
                cur = cur->next;
                pre = pre->next;
            }
        }    
    } 
    return true;
}

//**************真题分界线 ****************** 

void MergeSort()//17年829和922真题 两个递减合并成递增 
{
    ListNode L1 = SetupList();
    ListNode L2 = SetupList();//构建两个线性表 元素个数至少一个 
    Sort_Descend(L1);
    Sort_Descend(L2);//降序排序
    printf("链表L1:");
    DisplayList(L1);
    printf("\n链表L2:");
    DisplayList(L2);
    /*开始合并 
    思路1 插入排序，题目是原来是递减的，现在要求合并后递增，同时利用原节点,改代码利用的是节点L1.
    思路2 直接把L2插入L1尾部  调用Sort_Ascend函数  太简单就不写了 
    */ 

    ListNode listnode = L1;
    L1 = L1->next->next; //L1从第二个节点开始 
    listnode->next->next = NULL;//断开L1 
    L2 = L2->next;//L2从第一个节点开始
    ListNode pre;//每次判断的前一个结点
    ListNode cur;//需要比较的当前节点 
    while(L1 != NULL || L2 != NULL)
    {
        
        ListNode tmp;
        if(L1 != NULL && L2 != NULL)//找出两个节点中值小的那一个，如果一个为空，则直接取另一个 
        {
            if(L1->val < L2->val)
            {
                tmp = L1;
                L1 = L1->next;    
            }    
            else{
                tmp = L1;
                L1 = L1->next;    
            }
        } 
        else if(L1 == NULL){
            tmp = L2;
            L2 = L2->next;
        }
        else{
            tmp = L1;
            L1 = L1->next;
        }
        pre = listnode;//每次判断的前一个结点
        cur = listnode->next;// 需要比较的当前节点 
        while(cur != NULL)
        {
            if(cur->val > tmp->val)//小于当前节点的值则需要插入 
            {
                tmp->next = cur;
                pre->next = tmp;
                break;    
            }    
            else if(cur->val == tmp->val)//相等则去重 
            {
                break;
            } 
            else if(cur->next == NULL)//到达链表尾部，插入尾部 
            {
                cur->next = tmp;
                tmp->next = NULL;
                break;
            }
            else
            {
                cur = cur->next;
                pre = pre->next;
            }
        }

    } 
    L1 = listnode; 
    printf("\n合并后的链表:");
    DisplayList(L1);     
} 

void Student_Sort()// 17年829和922真题 使及格的成绩在不及格成绩的前面 要求O(n)时间复杂度 
{
    vector<int > student;
    int n;
    printf("请输入学生个数n:");
    scanf("%d",&n);
    printf("请输入所有学生成绩:");
    for(int i = 0;i < n;i++)
    {
        int score;
        scanf("%d",&score);
        student.push_back(score);
    }
    //利用快排的思想 前后同时向中间扫描 然后交换 
    int begin = 0;
    int end =  n-1;
    while(begin < end)
    {
        while(begin < n && student[begin] >= 60 )
            begin++;
        while(end >= 0 && student[end] < 60)
            end--;
        if(begin > end)
            break;
        int tmp = student[begin];
        student[begin] = student[end];
        student[end] = tmp;    
        begin++;
        end--;    
    }
    for(int i = 0;i < n;i++)
        printf("%d ",student[i]); 
    
}

void Delete_Duplicate()//2016年 829和922真题 删除重复节点
{
    ListNode head = SetupList();
    ListNode listnode = head->next;
    while(listnode != NULL)
    {
        ListDelete(listnode,listnode->val);//调用删除函数 
        listnode = listnode->next;
    }
    DisplayList(head);
} 

void SimpleSort()//15年829和922真题 简单选择排序
{
    ListNode head = SetupList();
    ListNode listnode = head->next;
    while(listnode != NULL)
    {
        ListNode min = listnode; //假设当前值是最小值 
        ListNode  cur = listnode->next;
        while(cur != NULL)
        {
            if(min->val > cur->val)
                min = cur;
            cur = cur->next;
        }//找到最小值的节点 
        int tmp = listnode->val;
        listnode->val = min->val;
        min->val = tmp;//交换节点的值 
        listnode = listnode->next;    
    } 
    DisplayList(head);
} 

void AdjustList()//14年829和922真题 偶数次序的节点倒序插入后边 
{
    int flag = 1;//奇偶节点的标志 
    ListNode head = SetupList();
    ListNode pre = head;//当前节点的前驱 
    ListNode cur = head->next;//当前节点 
    ListNode end = head; //最后一个节点an 
    ListNode post = NULL;// end节点的后继
    while(end->next != NULL) { end = end->next; } //找到最后一个节点
    while(cur != end)
    {
        if(flag == 2)//偶数节点
        {
            ListNode tmp = cur;
            pre->next = cur->next;
            cur = cur->next;//去掉偶数节点 
            end->next = tmp;
            tmp->next = post;
            post = tmp;//插入an节点的后面 
            flag = 1;    //下一个是奇数节点 
        } 
        else
        {
            flag = 2; //下一个是偶数节点
            cur = cur->next; 
            pre = pre->next; 
        }
    }
    DisplayList(head);     
}
 
void IntersectionList()//13年829和922真题 求AB链表的交集 并排序
{
    ListNode A = SetupList();
    ListNode B = SetupList();    
    Sort_Ascend(A);
    Sort_Ascend(B); //A B递增有序 
    printf("A链表:");
    DisplayList(A);
    printf("\nB链表:");
    DisplayList(B);
    /*
        开始求交集 注意：A里面可能有重复的元素，还需要去重
        思路1 利用Delete_Duplicate函数，先对A去重，然后利用ListFind函数
        判断A里面的元素是否在B表，不在则删除，最后对A表调用Sort_Descend函数排序
        因为考试题只有一个，所以我们采用思路2
        思路2 通过ListFind函数分别查找A B表，找出交集元素，以及删除A中重复元素 ，
        中间采用插入排序的思想使A表倒序 
    */ 
    ListNode pre = A;
    ListNode cur = A->next;
    while(cur != NULL)
    {
        if(ListFind(B,cur->val) && !ListFind(cur,cur->val) ){ pre = pre->next; cur = cur->next; }    //B中有该节点 A中没重复的 
        else if(ListFind(B,cur->val) && ListFind(cur,cur->val) )//B中有 A中也有 删除该节点 
        { 
            ListNode tmp = cur;
            pre->next = cur->next;
            cur = cur->next;
            free(tmp);
        }
        else//B中没有 
        {
            ListNode tmp = cur;
            pre->next = cur->next;
            cur = cur->next;
            free(tmp);
        }
    } 
    Sort_Descend(A);
    printf("\nAB链表的交集降序排列:");
    DisplayList(A);
} 

int OperateList()//2018年829和922真题 调整链表使负数节点在正数节点后面且返回第一个负数节点位置
{
    /*
        思想: 找到负数节点 插入到尾节点 ,同时第一次就找到了第一个负数节点
        或者最后一个正数节点的位置，如果前面有一个节点插入到尾部，则位置减一 
    */
    ListNode head = SetupList();//建立链表
    int index = 1;
    ListNode end = head->next; //尾节点 用于插入 
    ListNode post = NULL; //尾节点的后继 
    ListNode pre = head; //当前节点的前驱 
    ListNode cur = head->next; //当前节点
    while(end->next != NULL) //找到尾节点 同时找到节点位置 
    {
        end = end->next;
        index++;    
    } 
    while(cur != end) //当前节点未到达尾节点 
    {
        if(cur->val < 0)
        {
            ListNode tmp = cur;
            pre->next = cur->next;
            cur = cur->next; // 断开负节点 
            tmp->next = post;
            end->next = tmp;
            post = end->next; //插入尾节点 
            index--; //位置要减少一  因为少了一个节点 
        } 
        else
        {
            cur = cur->next;
            pre = pre->next;
        }
    }
    if(end->val >= 0) //最好特别判断一下尾节点 如果值大于零 说明位置要加一
        index++; 
    //DisplayList(head);    输出结果 没问题 
    return index;
} 

void  Sort_Negative() //2012年922真题 O(n)时间内使负数在正数前面
{
    /*
        算法思想:思路和18年思路基本一致
    */    
    ListNode head = SetupList();//建立链表
    ListNode end = head->next; //尾节点 用于插入 
    ListNode post = NULL; //尾节点的后继 
    ListNode pre = head; //当前节点的前驱 
    ListNode cur = head->next; //当前节点
    while(end->next != NULL) //找到尾节点 同时找到节点位置 
    {
        end = end->next;    
    } 
    while(cur != end) //当前节点未到达尾节点 
    {
        if(cur->val > 0)
        {
            ListNode tmp = cur;
            pre->next = cur->next;
            cur = cur->next; // 断开负节点 
            tmp->next = post;
            end->next = tmp;
            post = end->next; //插入尾节点 
        } 
        else
        {
            cur = cur->next;
            pre = pre->next;
        }
    }
    DisplayList(head);
} 

int main()
{
    ListNode listnode;
    //listnode = SetupList();
    //DestroyList(listnode);
    //ClearList(listnode);
    //cout<<listnode->val;
    //ListLength(listnode);
    //Sort(listnode);
    //DisplayList(listnode);
    //MergeSort();
    //Student_Sort();
    //Delete_Duplicate();
    //SimpleSort();
    //AdjustList();
    //IntersectionList();
    //printf("%d",OperateList() );
    //Sort_Negative();
    return 0;
} 

NUAA丶无痕
关注
2. 线性表-链式存储-链表1
08-03
在实际应用中，线性表可以采用两种不同的存储方式：顺序存储和链式存储。本篇主要讨论的是链式存储，特别是链表这一实现方式。 链表是一种动态数据结构，它的特点是元素（也称为节点）在内存中不是连续存放的，而是...
线性表的链式存储结构
szyqz的博客
09-19 428
（4）删除第i个元素（i在程序运行时输入），并在删除结束后输出删除元素的值；printf("元素%d在线性表中的位置是：%d\n", elem, pos);printf("第%d个元素的值是：%d\n", i, e);printf("删除的元素是：%d，删除元素后：", e);printf("请输入要插入的元素的值和位置（用空格隔开）：");printf("请输入要删除的元素的位置：");printf("请输入要查找的元素的位置：");printf("请输入要查找的元素的值：");
链表之线性表的链式存储（及面试题）
weixin_65477256的博客
07-29 912
​ 在链式存储结构中，每一个数据元素的存储都是以结点形式表示，在结点中包含数据域和指针域两部分内容：​ 数据域：结点的数据部分，存储的是当前结点数据信息；​ 指针域：相邻结点数据存储空间地址，可以包含前驱指针域(前驱结点存储空间地址)和后继指针域(后继结点存储空间地址)；/* 单向链表结点数据类型的定义 */ /* 结点数据类型的定义：由实际存储数据元素的字段信息抽象实现 */ # if 0 typedef struct stu {int id;int score;} data_t;
线性表链式存储习题
kelvinmao的博客
03-27 1721
Q1：已知L1和L2分别指向两个单链表的头结点，且已知其长度分别为m、n，请设计算法将L2连接到L1的后面。实现这个算法，完成测试，并分析这个算法的复杂度。 A:只需将l1的尾指针指向l2头节点即可，算法很简单，但有一问题需要注意，在将l1的尾指针指向l2头节点之后，一定要记住将无用的l2的头指针free掉；status connectlinklist(linklist l1,linklist l2
数据结构-线性链表-线性表链式存储结构练习
Zou_Cuo的博客
10-28 94
注：本代码采用链式存储结构进行链表的简单操作，如果你的code报RE，请检查存储结构，和勾链。
线性表的链式存储（链表）API及实现
03-27
链表是我们经常用到的一种数据结构，我们在学习数据结构的时候，第一个接触的一般就是线性表了，线性表...把线性表的链式存储结构，API实现及测试函数上传，配套我的文章《【数据结构】线性表的链式存储API及实现》。
链表的C++实现（线性表的链式存储C++实现）
04-05
大致实现了STL中的链表的基本功能，通过对比C语言实现线性表的链式存储可以更好的理解面向对象编程和面向过程的区别，更加深入的理解C语言和C++语言的区别。相关的文章可以在我的主页算法与数据结构专栏查看。
2.C-数据结构-线性表-链表源码
最新发布
09-07
2.C-数据结构-线性表-顺序表源码
c语言数据结构实验：掌握线性表的链式存储结构 熟练掌握循环链表的存储特征和建立方法，掌握线性表的链式存储结构 下面是源码的txt
10-13
2、已知由单链表表示的线性表中，含有三类字符的数据元素(如:字母、数字和其它字符)，设计算法构造三个以循环链表示的线性表，使每一个表中只含同一类的字符，且利用原表中的结点空间作为这三个表的空间。...
南航829计算机专业基础2013到2018年真题.pdf
06-30
南航829计算机专业基础2013到2018年真题
【数据结构】——线性表的相关习题
小宇y的博客
08-01 2234
若将删除结点 * p的操作转换为删除结点 * p的后继结点来实现，将下一个结点的指针域指向上一个结点，在交换数据域后，将* q结点从单链表中断开并释放该结点即可，这样的时间复杂度为O(1)。，也是将新结点的指针域指向下一个结点，该结点与前一个结点连接，然后通过一个中间变量将上一个结点的数据域与该结点交换即可，从而使时间复杂度达到。3、在单链表中删除第i个结点的时间复杂度为（），若将删除结点 * p的操作转换为删除结点 * p的后继结点来实现，其时间复杂度为（）。时，则该双链表为空。
数据结构实验一 顺序表 c++版本
学习笔记，相关教程 分享
10-28 659
思路请点击这里：成员函数说明 一、实验目的 掌握线性表的顺序存储结构的存储特点与操作特点。 掌握顺序表的存储表示与基本操作的实现方法。 熟悉顺序表的基本应用。 了解抽象数据类型的定义、表示与实现的含义。 二、预备知识 阅读课程教材P18~21页内容，熟悉抽象数据类型线性表的定义，了解各基本操作的功能含义。学习范例2-1，体会如何使用线性表提供的基本操作解决更复杂问题的方法。 阅读课程教材P21~26页内容，熟悉线性表的顺序存储结构的存储特点，了解顺序表的随机存取的操作特点。理解顺序表的存储表示方法，掌握顺
链表学习笔记（kk-zkx）
weixin_42585296的博客
09-29 433
链表学习单链表（链式存储结构）链表节点头节点，头指针和首元节点 单链表（链式存储结构） 链表，别名链式存储结构或单链表，用于存储逻辑关系为 “一对一” 的数据。与顺序表不同，链表不限制数据的物理存储状态，换句话说，使用链表存储的数据元素，其物理存储位置是随机的。 栗子，使用链表存储 {1,2,3}，数据的物理存储状态如图 所示： 数据元素随机存储，并通过指针表示数据之间逻辑关系的存储结构就是链式存储结构。 链表节点 链表中每个数据的存储都由以下两部分组成： 数据元素本身，其所在的区域称为数据域； 指向
【数据结构】线性表的顺序存储
zhongyebiao的博客
07-10 609
数据结构-线性表的顺序存储 线性表顺序存储的结构 创建有序的顺序表 遍历顺序表 插入一个元素 合并两个有序的顺序表到一个顺序表中 主函数调用 目录： 数据结构-线性表的顺序存储 目录： 线性表顺序存储的结构： 创建有序的顺序表： 遍历顺序表： 插入一个元素： 合并两个有序的顺序表到一个顺序表中： 主函数调用: 全部代码： 线性表顺序存储的结构： #i...
合并两个线性表的实现
嵌入断崖
03-19 2155
<!-- @page {margin:2cm} p {margin-bottom:0.21cm} -->      题目：编写一个算法实现两个有序（从小到大）顺序表合并成为一个顺序表，合并后的结果放在第一个顺序表中，不另设新的顺序表存储（假设这两个有序顺序表中没有相同的元素）。 源码如下： #define TRUE    1 #define FALSE
数据结构算法代码实现——线性表的链式表示与实现(单链表)(三 )
编程侯的专栏
06-02 9935
线性表的链式表示 使用一组任意的存储单元存储线性表的数据元素（这些存储单元可以是连续也可以是不连续的）。 常见的链式表：单链表、静态链表、循环链表、双向链表。 链表的存储方式和特点我们修改一下上一篇文章的例子：假如现在是新生入校，按照新生的先来后到编号1-6，先到的同学可以随意选择床铺，但是需要记住下一位同学的床铺号（1舍友记住2舍友床铺号，2舍友记住3舍友床铺号，依次类推）。此时无形
线性表创建（最基础）
qq_52988578的博客
03-26 9595
线性表：是最基本、最简单、也是最常用的一种数据结构。 前提：在学习数据结构的时候命名不要使用拼音！这是初学者的经常犯得错误。 顺序表的创建： #include<stdio.h> #define N 10 typedef int SLDataType; typedef struct//创建顺序表 { SLDataType array[N]; int size; }SeqList; void SeqListInit(SeqList &L)//输入顺序表的值 { int
链表操作实践：掌握线性表的链式存储与应用
本讨论主要聚焦于链式存储结构的线性表，也就是链表。 链表的特性主要体现在它的动态内存分配和通过指针链接节点的机制。每个链表节点包含两部分：数据域和指针域。数据域用于存储数据，而指针域则指向下一个节点的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值