数据结构1

最新推荐文章于 2022-12-04 21:27:47 发布
最新推荐文章于 2022-12-04 21:27:47 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： 学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shiyuankongbu/article/details/7997696
版权

ＣＣＮＵ开课了，听了几节课，感觉神马都不会。。。。。

上了一节实验课，酱油，就敲了个结构体，初始化，啥都没敲出来，郁闷

然后开学了，各种无聊，但是感觉没时间搞ＡＣＭ了。

坐了一晚上，终于搞定了实验一。。。累啊


先敲完了十二个基本的函数：

顺序表：

//代码很搓，大神请绕行，请勿鄙视

#include <stdio.h>
#include <cstdlib>
#include <iostream>
using namespace std;
#define ElemType int
const int LIST_INIT_SIZE=100;
const int LISTINCREMENT=10;
typedef struct
{
    ElemType *elem;
    int length;
    int listsize;
    int incrementsize;
}Sqlist;

void InitList(Sqlist &L,int maxsize,int incresize)//初始化
{
    L.elem=new ElemType[maxsize];
    L.length=0;
    L.listsize=maxsize;
    L.incrementsize=incresize;
}

void DestroyList(Sqlist &L)//销毁线性表
{
    delete[]L.elem;
    L.listsize=0;
    L.length=0;
}

void ClearList(Sqlist &L)
{
    delete[]L.elem;
    L.length=0;
}

int ListEmpty(Sqlist L)
{
    if(L.length==0)
    return 1;
    return 0;
}

int ListLength(Sqlist L)
{
    return L.length;
}

void GetElem(Sqlist L,ElemType i,ElemType &e)
{
    if(i<1||i>L.length)
    {
        cout<<i<<"不合法"<<endl;
        return;
    }
    e=*(L.elem+i);
}

int LocateElem(Sqlist L,ElemType e)
{
    int i=0;
    int *p=L.elem;
    while(i<=L.length&&*p++!=e) ++i;
    if(i<=L.length) return i;
    else
    {
        //cout<<e<<"不合法"<<endl;
        return 0;
    }
}

void PriorElem(Sqlist L,ElemType cur_e,ElemType &pre_e)
{
    int i=1;
    ElemType *p=L.elem+1;
    while(i<=L.length&&*p!=cur_e)
    {
        p++;
        i++;
    }
    if(i>L.length||i==1)
    {
        cout<<"求cur_e的PriorElem"<<" ";
        cout<<cur_e<<"不合法"<<endl;
        return;
    }
    else
    {
        pre_e=*--p;
        return ;
    }
}

void NextElem(Sqlist L,ElemType cur_e,ElemType &next_e)
{
    int i=1;
    ElemType *p=L.elem;
    while(i<L.length&&*p!=cur_e)
    {
        i++;
        p++;
    }
    if(i==L.length)
    {
        cout<<"求cur_e的NextElem"<<" ";
        cout<<cur_e<<"不合法"<<endl;
        return;
    }
    else
    {
        next_e=*++p;
        return ;
    }
}

void ListInsert(Sqlist &L,ElemType i,ElemType e)
{
    ElemType *newbase,*p,*q;
    if(i<1||i>L.length+1)
    {
        cout<<i<<"不合法"<<endl;
        return;
    }
    if(L.length>=L.listsize)
    {
        if(!(newbase=(ElemType *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType))))
        {
            cout<<"动态内存分配不够"<<endl;
        }
        L.elem=newbase;
        L.listsize+=LISTINCREMENT;
    }
    q=L.elem+i;
    for(p=L.elem+L.length;p>=q;--p)
    *(p+1)=*p;
    *q=e;
    ++L.length;
}

void ListDelete(Sqlist &L,int i,ElemType &e)
{
    ElemType *p,*q;
    if(i<1||i>L.length)
    {
        //cout<<i<<L.length<<endl;
        cout<<i<<"不合法"<<endl;
        return;
    }
    p=L.elem+i;
    e=*p;
    q=L.elem+L.length;
    for(;p<q;++p)
     *(p)=*(p+1);
    L.length--;
}

void ListTraverse(Sqlist L)
{
    int flag=0;
    for(int i=1;i<=L.length;i++)
    {
        if(!flag)
        {
            cout<<L.elem[i];
            flag=1;
        }
        else
        cout<<" "<<L.elem[i];
    }
    cout<<endl;
}

int main()
{
    Sqlist La,Lb;
    InitList(La,LIST_INIT_SIZE,LISTINCREMENT);
    InitList(Lb,LIST_INIT_SIZE,LISTINCREMENT);
    int n,e;
    cin>>n;
    La.length=n;
    for(int i=1;i<=n;i++)
    cin>>La.elem[i];

    /*   删除元素
    ListDelete(La,4,e);
    cout<<La.length<<endl;
    for(int i=1;i<=La.length;i++)
    cout<<La.elem[i]<<" ";
    cout<<endl;
    */


    //   销毁线性表 or 重置为空表
    //DestroyList(La);
    //ClearList(La);
    /*
    cout<<La.length<<endl;
    if(ListEmpty(La))   //   判断是否为空表
    cout<<"null"<<endl;
    else
    cout<<"occurpied"<<endl;
    //
    */

    // 得到第i个元素
    /*
    GetElem(La,6,e);
    cout<<e<<endl;
    */

    //  定为元素位置
    /*
    e=5;
    cout<<LocateElem(La,e)<<endl;
    */

    //  求 PriorElem or NextElem
    /*
    ElemType pre_e,next_e;
    PriorElem(La,5,pre_e);
    NextElem(La,5,next_e);
    cout<<pre_e<<endl;
    cout<<next_e<<endl;
    */

    //  插入元素
    /*
    ListInsert(La,5,2);
    ListTraverse(La);
    */

    //  删除元素
    /*
    ListDelete(La,5,e);
    ListTraverse(La);
    cout<<e<<endl;
    */

    return 0;
}


链表：（13个函数操作） （12个基本+1个create）


#include <iostream>
#include <cstdlib>
using namespace std;
#define ElemType int
typedef struct Lnode
{
    ElemType data;
    struct Lnode *next;
}Lnode,*LinkList;
void InitList(LinkList &L)
{
    L=(LinkList)malloc(sizeof(Lnode));
    if(!L)
      cout<<"存储分配失败"<<endl;
    L->next=NULL;
}
void DestroyList(LinkList &L)
{
    LinkList q;
    while(L->next)
    {
        q=L->next;
        free(L);
        L=q;
    }
    delete L->next;
}
void ClearList(LinkList L)
{
    LinkList p,q;
    p=L->next;
    while(p)
    {
        q=p->next;
        free(p);
        p=q;
    }
    L->next=NULL;
}
int ListEmpty(LinkList L)
{
    if(L->next!=L)
        return 1;
    return 0;
}
int ListLength(LinkList L)
{
    int i=1;
    LinkList p=L->next;
    while(p)
    {
        i++;
        p=p->next;
    }
    return i;
}
void GetElem(LinkList L,int i,ElemType &e)
{
    if(i==1)
    {
        e=L->data;
        return ;
    }
    LinkList p=L->next;
    int j=1;
    while(p&&j<i-1)
    {
        p=p->next;
        j++;
    }
    if(!p||j>i)
    {
        cout<<i<<" 不合法\n";
        return ;
    }
    e=p->data;
}
int LocateElem(LinkList L,ElemType e)
{
    LinkList p=L;
    int i=0;
    if(p->data==e)
    return 1;
    while(p)
    {
        i++;
        if(p->data==e)
        return i;
        p=p->next;
    }
}
void PriorElem(LinkList L,ElemType cur_e,ElemType &pre_e)
{
    if(LocateElem(L,cur_e)==2)
    {
        int e;
        GetElem(L,1,e);
        pre_e=e;
        return;
    }
    LinkList q,p=L->next;
    while(p->next)
    {
        q=p->next;
        if(q->data==cur_e)
        {
            pre_e=p->data;
            return ;
        }
        p=q;
    }
    cout<<cur_e<<"不合法\n";
}
void NextElem(LinkList L,ElemType cur_e,ElemType &next_e)
{
    LinkList p=L->next;
    while(p->next)
    {
        if(p->data==cur_e)
        {
            next_e=p->next->data;
            return ;
        }
        p=p->next;
    }
    cout<<cur_e<<"不合法\n";
}
void ListInsert1(LinkList &L,int i,int e)//后插
{
    LinkList p;
    LinkList s;
    s=(LinkList)malloc(sizeof(LinkList));
    s->data=e;
    p=L;
    int k=1;
    while(p)
    {
        if(k==i)
        {
            s->next=p->next;
            p->next=s;
            return;
        }
        k++;
        p=p->next;
    }
}
void ListInsert2(LinkList &L,int i,int e)//前插
{
    LinkList p;
    LinkList s;
    s=(LinkList)malloc(sizeof(LinkList));
    s->data=e;
    p=L;
    int k=1;
    if(i==1)
    {
        s->next=L;
        L=s;
        return;
    }
    else
    {
        while(p)
        {
            if(k==i-1)
            {
                s->next=p->next;
                p->next=s;
                return;
            }
            p=p->next;
            k++;
        }
    }
}
void ListDelete(LinkList L,int i,ElemType &e)
{
    LinkList p=L,q;
    if(i==1)
    {
        L->data=(L->next)->data;
    }
    int j=1;
    while(p->next&&j<i-1)
    {
        p=p->next;
        j++;
    }
    q=p->next;
    p->next=q->next;
    e=q->data;
    free(q);
}
void ListTraverse(LinkList L)
{
    LinkList p=L;
    while(p->next)
    {
        int e=p->data;
        cout<<e<<" ";
        p=p->next;
    }
    cout<<p->data<<endl;
    return ;
}
void CreateList(LinkList &L,ElemType a[],int n)
{
    L=NULL;
    LinkList s;
    for(int i=n;i>0;i--)
    {
        s=new Lnode;
        s->data=a[i];
        s->next=L;
        L=s;
    }
}

int main()
{
    LinkList La;
    LinkList p,q;
    InitList(La);
    int n;
    int e,pre_e,next_e;
    int a[100];
    cin>>n;
    for(int i=1;i<=n;i++)
    cin>>a[i];
    CreateList(La,a,n);//创建链表
    ListInsert1(La,3,222);
    ListTraverse(La);
    ListInsert2(La,3,22);
    ListTraverse(La);//输出链表
    return 0;
}




实验一　：　利用线性表实现两个整数集合的交、并、差的运算。

（日，直接数组模拟的嘛，吃饱了撑着用线性表。。。）


#include <stdio.h>
#include <cstdlib>
#include <iostream>
using namespace std;
#define ElemType int
const int LIST_INIT_SIZE=100;
const int LISTINCREMENT=10;
typedef struct
{
    ElemType *elem;
    int length;
    int listsize;
    int incrementsize;
}Sqlist;

void InitList(Sqlist &L,int maxsize,int incresize)//初始化
{
    L.elem=new ElemType[maxsize];
    L.length=0;
    L.listsize=maxsize;
    L.incrementsize=incresize;
}

void DestroyList(Sqlist &L)//销毁线性表
{
    delete[]L.elem;
    L.listsize=0;
    L.length=0;
}

void ClearList(Sqlist &L)
{
    delete[]L.elem;
    L.length=0;
}

int ListEmpty(Sqlist L)
{
    if(L.length==0)
    return 1;
    return 0;
}

int ListLength(Sqlist L)
{
    return L.length;
}

void GetElem(Sqlist L,ElemType i,ElemType &e)
{
    if(i<1||i>L.length)
    {
        cout<<i<<"不合法"<<endl;
        return;
    }
    e=*(L.elem+i);
}

int LocateElem(Sqlist L,ElemType e)
{
    int i=0;
    int *p=L.elem;
    while(i<=L.length&&*p++!=e) ++i;
    if(i<=L.length) return i;
    else
    {
        //cout<<e<<"不合法"<<endl;
        return 0;
    }
}

void PriorElem(Sqlist L,ElemType cur_e,ElemType &pre_e)
{
    int i=1;
    ElemType *p=L.elem+1;
    while(i<=L.length&&*p!=cur_e)
    {
        p++;
        i++;
    }
    if(i>L.length||i==1)
    {
        cout<<"求cur_e的PriorElem"<<" ";
        cout<<cur_e<<"不合法"<<endl;
        return;
    }
    else
    {
        pre_e=*--p;
        return ;
    }
}

void NextElem(Sqlist L,ElemType cur_e,ElemType &next_e)
{
    int i=1;
    ElemType *p=L.elem;
    while(i<L.length&&*p!=cur_e)
    {
        i++;
        p++;
    }
    if(i==L.length)
    {
        cout<<"求cur_e的NextElem"<<" ";
        cout<<cur_e<<"不合法"<<endl;
        return;
    }
    else
    {
        next_e=*++p;
        return ;
    }
}

void ListInsert(Sqlist &L,ElemType i,ElemType e)
{
    ElemType *newbase,*p,*q;
    if(i<1||i>L.length+1)
    {
        cout<<i<<"不合法"<<endl;
        return;
    }
    if(L.length>=L.listsize)
    {
        if(!(newbase=(ElemType *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType))))
        {
            cout<<"动态内存分配不够"<<endl;
        }
        L.elem=newbase;
        L.listsize+=LISTINCREMENT;
    }
    q=L.elem+i;
    for(p=L.elem+L.length;p>=q;--p)
    *(p+1)=*p;
    *q=e;
    ++L.length;
}

void ListDelete(Sqlist &L,int i,ElemType &e)
{
    ElemType *p,*q;
    if(i<1||i>L.length)
    {
        //cout<<i<<L.length<<endl;
        cout<<i<<"不合法"<<endl;
        return;
    }
    p=L.elem+i;
    e=*p;
    q=L.elem+L.length;
    for(;p<q;++p)
     *(p)=*(p+1);
    L.length--;
}

void ListTraverse(Sqlist L)
{
    int flag=0;
    for(int i=1;i<=L.length;i++)
    {
        if(!flag)
        {
            cout<<L.elem[i];
            flag=1;
        }
        else
        cout<<" "<<L.elem[i];
    }
    if(!flag)
    cout<<"null"<<endl;
    else
    cout<<endl;
}

void bing(Sqlist La,Sqlist Lb)
{
    Sqlist Lc;
    ElemType e;
    InitList(Lc,LIST_INIT_SIZE,LISTINCREMENT);
    for(int i=1;i<=La.length;i++)
    ListInsert(Lc,Lc.length+1,La.elem[i]);
    for(int i=1;i<=Lb.length;i++)
    if(!LocateElem(Lc,Lb.elem[i]))
    ListInsert(Lc,Lc.length+1,Lb.elem[i]);
    ListTraverse(Lc);
}
void jiao(Sqlist La,Sqlist Lb)
{
    Sqlist Lc;
    ElemType e;
    InitList(Lc,LIST_INIT_SIZE,LISTINCREMENT);
    for(int i=1;i<=La.length;i++)
    {
        GetElem(La,i,e);
        if(LocateElem(Lb,e))
        ListInsert(Lc,Lc.length+1,e);
    }
    ListTraverse(Lc);
}
void cha(Sqlist La,Sqlist Lb)
{
    Sqlist Lc;
    ElemType e;
    InitList(Lc,LIST_INIT_SIZE,LISTINCREMENT);
    for(int i=1;i<=La.length;i++)
    {
        GetElem(La,i,e);
        if(!LocateElem(Lb,e))
        ListInsert(Lc,Lc.length+1,e);
    }
    ListTraverse(Lc);
}
int main()
{
    Sqlist La,Lb;
    InitList(La,LIST_INIT_SIZE,LISTINCREMENT);
    InitList(Lb,LIST_INIT_SIZE,LISTINCREMENT);
    cout<<"Input the length of set A :"<<endl;
    cin>>La.length;
    cout<<"Input the elements in set A :"<<endl;
    for(int i=1;i<=La.length;i++)
    cin>>La.elem[i];
    cout<<"Input the length of set B :"<<endl;
    cin>>Lb.length;
    cout<<"Input the elements in set B :"<<endl;
    for(int i=1;i<=Lb.length;i++)
    cin>>Lb.elem[i];
    cout<<"Union of set A and set B ："<<endl;
    bing(La,Lb);
    cout<<"Mix of set A and set B ："<<endl;
    jiao(La,Lb);
    cout<<"the difference set of A and B ："<<endl;
    cha(La,Lb);
    cout<<"the difference set of B and A ："<<endl;
    cha(Lb,La);
    //ListTraverse(La);
    //ListTraverse(Lb);
    return 0;
}


shiyuankongbu
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
纯c语言单向链表
shanghaisanmao的专栏
11-19 324
/************************************************* * 单链表操作 * **************************************************/ #include #include #define OK 0 #define ERROR (-1) typedef int Status; typedef struc
单链表
yanjiahong01的专栏
10-03 621
#include #include using namespace std; #define OK 1 #define ERROR 0 typedef int Status; typedef int ElemType; //-------------单链表的存储结构-------------------- typedef struct LNode {  ElemType dat
数据结构——单链表代码总结
Acc222222的博客
08-02 2654
1.单链表结点的定义
数据结构与算法基础（王卓）（5）：关于（单）链表较复杂的操作
Zz_zzzzzzz__的博客
12-04 644
（单）链表的一些较为复杂的操作：默认前置： 取第i个元素 project 1：（自己写的，凑合着也能用） project 2：根据课程上写的（算法复杂度低一些，比较好用） 按值查找（查找其地址，以及是表中第几个元素（位置序号）） project 1: 但是要注意，如果要这么写的话，在类型K的声明里，还需要加上手撸判断表达式的定义： project 2：根据课程上写的（算法复杂度低一些，比较好用） 同理： 插入（把元素e插到第i个位置结点上） project 1：
C语言描述：单向链表的相关操作
Joyee的博客
03-26 394
先找到课本，熟悉单向链表的结构； 关键词： 头结点，头指针，表头，表尾，数据域，地址域（指针域）1，生成空表销毁链表 2，清空链表 3，是否为空表 4，表长 5，查找第i个结点的值6，查找第一个等于e的结点在链表的位置
数据结构视频
03-18
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构往往同高效的检索算法和索引技术...
数据结构真题
10-19
数据结构考试题啊
数据结构基础
10-01
数据结构回顾
数据结构学习笔记1
01-07
数据结构数据结构 数据结构 基本概念和术语 数据：是客观事物的符号表示，能够输入到计算机中并能被计算机程序处理的符号的总称 数据元素：是数据的基本单位，用于完整地描述一个对象 数据对象：是性质相同的数据...
数据结构1800试题.pdf
05-02
你还在苦苦寻找数据结构的题目吗？这里刚刚上传了一份数据结构共1800道试题，轻松解决期末挂科的难题。不信？你下载看看，这里是纯题目，你下载了再来私信我答案。按数据结构教材分章节，每一章节都有选择题、或有...
数据结构题库 数据结构题库
06-30
数据结构题库数据结构题库数据结构题库数据结构题库数据结构题库数据结构题库数据结构题库数据结构题库数据结构题库数据结构题库数据结构题库数据结构题库数据结构题库数据结构题库数据结构题库数据结构题库数据结构...
02331数据结构教材
09-08
自考02331数据结构教材扫描版。 涉及内容有：线性表、栈和队列、串、多维数组和广义表、树、图、排序、查找、文件等。
数据结构Python
04-04
1. **链表**：链表是一种线性数据结构，其中元素在内存中不是连续存储的。链表包括单链表、双链表和环形链表等，它们在Python中可以通过类来实现，理解指针的概念和操作是关键。 2. **栈**：栈是一种后进先出（LIFO...
数据结构—线性表的链式表示
小虾米编程
06-19 2632
1.相关概念 链式存储结构：结点在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理上不一定相邻 线性表的链式表示又称为非顺序映像或链式映像。 与链式存储有关的术语： 1、结点：数据元素的存储映像。由数据域和指针域两部分组成 2、链表： n 个结点由指针链组成一个链表。它是线性表的链式存储映像，称为线性表的链式存储结构 3、单链表、双链表、循环链表： 结点只有一个指针域的链表...
(理解)单链表算法循环条件while(p)和while(p-＞next)有什么区别？
sunshine_r_007的博客
11-18 5312
【问题】 //在带头节点的单链表L中，删除指定位置i p = L; j = 1; while(p->next && j<i) { p = p->next; j++; } //在带头结点的单链表L中，指定位置i插入值e p = L; j = 1; while(p && j<i) { p = p->next; j++; } 单链表的删除算法中循环条件(p->next&&j<i)和插入
单链表（配合数构第二章的笔记使用）
Bqv它不想做功的博客
04-19 207
单链表 头指针用来记录链表第一个元素的地址，链表名可以取头指针名 头指针为空，证明链表是空表 结点：数据元素的存储映像 数据域 指针域 你可以选择把箭头理解成指向元素的地址（因为你也不知道那个地址具体是什么） 其指针的定义为嵌套定义（定义的类型为所在结构体类型） Lnode：普通的（结点）结构体类型变量，可以Lnode a;或者Lnode *a。a.next或者a.data来操作结点的两个域 *...
数据结构复习（2.线性表）
qq_53635710的博客
12-27 1310
1.线性结构特点： 1.只有一个首节点和尾节点 2.除了首位节点之外，其他节点只有一个直接前驱和直接后继 线性结构反映节点间的逻辑关系是一对一的 线性表的直接定义：用数据元素的有限序列表示 eg：(a1,a2,,,,,,,ai-1,ai,ai+1,,,,,,,an) a1处：线性起点 ai-1是ai的直接前驱 ai+1是ai的直接后继 下标是元素的符号，表示元素在表中的位置 n=0时称为空表，记做L=（） n为线性表的...
数据结构1-4章笔记电子版
最新发布
03-23
很抱歉，我无法提供或分享未经授权的电子版笔记。但是，我可以为您介绍数据结构1-4章的主要内容： 第一章介绍了数据结构的基本概念，包括数据元素、数据结构、抽象数据类型等。同时，还介绍了算法设计的基本要求和语句的频度和估算时间复杂度。 第二章介绍了线性表的定义和基本操作，包括插入、删除、查找等。同时，还介绍了线性表的两种存储结构：顺序存储结构和链式存储结构。 第三章介绍了栈和队列的定义和基本操作，以及它们的应用。 第四章介绍了串的定义和基本操作，以及模式匹配算法和KMP算法。 如果您需要更详细的内容，建议您阅读相关的教材或参考资料。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值