码迷，mamicode.com
首页 > 其他好文 > 详细

数据结构上机实验（2）

时间：2020-05-23 21:53:15      阅读：83      评论：0      收藏：0      [点我收藏+]

标签：函数   选择排序   return   返回   作者   merge   creat   item   bool   

1、顺序表的各种基本运算操作

技术图片

#include <stdio.h>
#include<stdlib.h>
#define MaxSize 50

typedef char ElemType;
typedef struct 
{
ElemType elem[MaxSize];
   int length;
} SqList;

//初始化 O(1)
void InitList(SqList *&L)
{
L=(SqList *)malloc(sizeof(SqList));
L->length=0;
}
//销毁 O(1)
void DestroyList(SqList *L)
{
free(L);
}
//判断是否为空 O(1)
int ListEmpty(SqList *L)
{
return(L->length==0);
}
//求长度 O(1)
int ListLength(SqList *L)
{
return(L->length);
}
//输出顺序表 O(n)
void DispList(SqList *L)
{
int i;
if (ListEmpty(L)) return;
for (i=0;i<L->length;i++)
   printf("%c",L->elem[i]);
printf("\n");
}
//获取第i个位置上的元素返回给e O(1)
int GetElem(SqList *L,int i,ElemType &e)
{
if (i<1 || i>L->length)
   return 0;
e=L->elem[i-1];
return e;
}
//查找返回元素e的位置  O(n)
int LocateElem(SqList *L, ElemType e)
{
int i=0;
while (i<L->length && L->elem[i]!=e) i++;
if (i>=L->length)
   return 0;
else
   return i+1;
}
//把元素e插入到位置i O(n)
bool ListInsert(SqList *&L,int i,ElemType e)
{
int j;
if (i<1 || i>L->length+1)
   return false;
i--;        //将顺序表位序转化为elem下标
for (j=L->length;j>i;j--)   //将elem[i]及后面元素后移一个位置
   L->elem[j]=L->elem[j-1];
L->elem[i]=e;
L->length++;     
return true;
}
//删除位置i上的元素 O(n)
bool ListDelete(SqList *&L,int i,ElemType &e)
{
int j;
if (i<1 || i>L->length)
   return false;
i--;        //将顺序表位序转化为elem下标
e=L->elem[i];
for (j=i;j<L->length-1;j++)   //将elem[i]及后面元素前移一个位置
   L->elem[j]=L->elem[j+1];
L->length--;
return true;
}

int main()
{
SqList *L;
ElemType e;
printf("(1)初始化顺序表L\n");
InitList(L);
printf("(2)依次采用尾插法插入a,b,c,d,e元素\n");
ListInsert(L,1,‘a‘);
ListInsert(L,2,‘b‘);
ListInsert(L,3,‘c‘);
ListInsert(L,4,‘d‘);
ListInsert(L,5,‘e‘);
printf("(3)输出顺序表L:");
DispList(L);
printf("(4)顺序表L长度=%d\n",ListLength(L));
printf("(5)顺序表L为%s\n",(ListEmpty(L)?"空":"非空"));
GetElem(L,4,e);
printf("(6)顺序表L的第4个元素=%c\n",e);
printf("(7)元素a的位置=%d\n",LocateElem(L,‘a‘));
printf("(8)在第3个元素位置上插入f元素\n");
ListInsert(L,3,‘f‘);
printf("(9)输出顺序表L:");
DispList(L);
printf("(10)删除L的第4个元素\n");
    ListDelete(L,4,e);
printf("(11)输出顺序表L:");
DispList(L);
printf("(12)释放顺序表L\n");
DestroyList(L);
}

技术图片

2、单链表的各种基本运算算法

技术图片

#include<stdio.h>
#include<stdlib.h>

typedef char ElemType;
typedef struct LNode
{
    ElemType data;
    struct LNode *next;
} LinkList;

//两种插入学习
//使用头插法
void CreateListF(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;
    }
}
//使用尾插法
void CreateListR(LinkList *&L,ElemType a[],int n)
{
    LinkList *s,*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;
}

//初始化线性表 O(1)
void InitList(LinkList *&L)
{
    L=(LinkList *)malloc(sizeof(LinkList));
    L->next=NULL;
}
//销毁线性表 O(n)
void DestroyList(LinkList *&L)
{
    LinkList *pre=L,*p=L->next;
    while(p!=NULL)
    {
        free(pre);
        pre=p;
        p=pre->next;
    }
    free(pre);
}
//判断线性表是否为空表 O(1)
bool ListEmpty(LinkList *L)
{
    return (L->next==NULL);
}
//求线性表的长度 O(n)
int ListLength(LinkList *L)
{
    int n=0;
    LinkList *p=L;
    while(p->next!=NULL)
    {
        n++;
        p=p->next;
    }
    return (n);
}
//输出线性表 O(n)
void DispList(LinkList *L)
{
    LinkList *p=L->next;
    while(p!=NULL)
    {
        printf("%c",p->data);
        p=p->next;
    }
    printf("\n");
}
//求线性表中某个数据元素值  O(n)
int GetElem(LinkList *L,int i,ElemType &e)
{
    int j=0;
    LinkList *p=L;
    while(j<i&&p!=NULL) //题目中i默认大于0
    {
        j++;
        p=p->next;
    }
    if(p==NULL)
        return 0;
    else
    {
        e=p->data;
        return e;
    }
}
//按元素值查找 O(n)
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;
}
//插入数据元素 O(n)
bool ListInsert(LinkList *&L,int i,ElemType e)
{
    int j=0;
    LinkList *p=L,*s;
    while(j<i-1&&p!=NULL)
    {
        j++;
        p=p->next;
    }
    if(p==NULL)
        return false;
    else
    {
        s=(LinkList *)malloc(sizeof(LinkList));
        s->data=e;
        s->next=p->next;
        p->next=s;
        return true;
    }
 
}
//删除数据元素 O(n)
bool ListDelete(LinkList *&L,int i,ElemType &e)
{
    int j=0;
    LinkList *p=L,*q;
    while(j<i-1&&p!=NULL)
    {
        j++;
        p=p->next;
    }
    if(p==NULL)
        return false;
    else
    {
        q=p->next;
        if(q==NULL)
            return false;
        e=q->data;
        p->next=q->next;
        free(q);
        return true;
    }
}
 
int main()
{
    LinkList *L;
    char s[5]= {‘a‘,‘b‘,‘c‘,‘d‘,‘e‘};
    char e;
    int i,j;
    printf("(1)初始化单链表L\n");
    InitList(L);
    printf("(2)采用尾插法插入a,b,c,d,e元素");
    CreateListR(L,s,5);
    printf("\n");
    printf("(3)输出单链表L:");
    DispList(L);
    printf("(4)单链表L长度=%d\n",ListLength(L));
    i=ListEmpty(L);
    if(i==0)
    {
        printf("(5)该单链表L非空\n");
    }
    else
    {
        printf("(5)该单链表L为空\n");
    }
    e=GetElem(L,3,e);
    printf("(6)第三个元素为：%c\n",e);
    j=LocateElem(L,‘a‘);
    printf("(7)元素a为第%d个元素\n",j);
    printf("(8)在第4个元素位置上插入f元素\n");
    ListInsert(L,4,‘f‘);
    printf("(9)输出单链表L:");
    DispList(L);
    printf("(10)删除L的第3个元素\n");
    ListDelete(L,3,e);
    printf("(11)输出单链表L:");
    DispList(L);
    printf("(12)释放单链表L\n");
    DestroyList(L);
}

技术图片

3、双链表的各种基本运算算法

技术图片

#include <stdio.h>
#include <stdlib.h>

typedef char ElemType;
typedef struct DNode
{
    ElemType data;
    struct DNode *prior;   //指向前驱结点
    struct DNode *next;   //指向后继结点
}DLinkNode;//声明双链表结点类型;

//尾插法建立双链表
void CreateListR(DLinkNode *&L,ElemType a[],int n)
{
    DLinkNode *s,*r;
    //创建头结点
    L=(DLinkNode *)malloc(sizeof(DLinkNode));
    L->prior=L->next=NULL;
    r=L;   //r始终指向终端结点,开始时指向头结点
    for (int i = 0; i < n; i++)
    {
        //创建新结点
        s=(DLinkNode *)malloc(sizeof(DLinkNode));
        //数据域
        s->data=a[i];
        //将节点s插入到节点r之后
        r->next=s;
        s->prior=r;
        r=s;
    }
    r->next=NULL;   //尾结点next域置空
}

//初始化双链表
void InitList(DLinkNode *&L)
{
    L=(DLinkNode *)malloc(sizeof(DLinkNode));
    L->prior=L->next=NULL;
}
//销毁双链表
void DestroyList(DLinkNode *&L)
{
    DLinkNode *pre=L, *p=pre->next;
    while(p!=NULL)
    {
        free(pre);
        //pre,p同步后移一个节点
        pre=p;
        p=pre->next;
    }
    free(p);
}
//判断是否为空
bool ListEmpty(DLinkNode *L)
{
    return(L->next==NULL);
}
//求长度
int ListLength(DLinkNode *L)
{
    DLinkNode *p=L;
    int i=0;   //p指向头结点 i设置为0
    while(p->next!=NULL)
    {
        i++;
        p=p->next;
    }
    return i;
}
//输出线性表
void DispList(DLinkNode *L)
{
    DLinkNode *p=L->next;
    while(p!=NULL)
    {
        printf("%c",p->data);
        p=p->next;
    }
     printf("\n");
}
//求线性表中第i个元素值
int GetElem(DLinkNode *L,int i,ElemType &e)
{
    int j=0;
    DLinkNode *p=L;
    //查找第i个结点p
    while(j<i&&p!=NULL)
    {
        j++;
        p=p->next;
    }
    if (p==NULL)
        return 0;
    else   //找到了
    {
        e=p->data;
        return e;
    }
}
//按元素值查找
int LocateElem(DLinkNode *L,ElemType e)
{
    int i=1;
    DLinkNode *p=L->next;
    while(p!=NULL&&p->data!=e)
    {
        i++;   //i对应结点p的序号
        p=p->next;
    }
    if (p==NULL)
        return 0;
    else
        return i;
}
//插入数据元素
bool ListInsert(DLinkNode *&L,int i,ElemType e)
{
    int j=0;
    DLinkNode *p=L,*s;    // p指向头结点,j设置为0
    while(j<i-1&&p!=NULL)
    {
        j++;
        p=p->next;
    }
    if (p==NULL)
        return false;
    else   //找到第i-1个结点p
    {
        //创建新结点s
        s=(DLinkNode *)malloc(sizeof(DLinkNode));
        s->data=e;
        //将节点s插入到节点p之后
        s->next=p->next;
        if(p->next!=NULL)
            p->next->prior=s;
        s->prior=p;
        p->next=s;
        return true;
    }
}
//删除数据元素 
bool ListDelete(DLinkNode *&L,int i,ElemType &e)
{
    int j=0;
    DLinkNode *p=L,*q;    //p指向头结点,j设置为0
    while(j<i-1&&p!=NULL)
    {
        j++;
        p=p->next;
    }
    if(p==NULL)
        return false;
    else   //找到第i-1个结点p
    {
        q=p->next;   //q指向第i个结点
        //当不存在第i个结点时返回false
        if(q==NULL)
            return false;
        e=q->data;
        //从双链表中删除结点q
        p->next=q->next;
        //若p结点存在后继结点,修改其前驱指针
        if(p->next != NULL)
            p->next->prior = p;
        //释放q结点
        free(q);
        return true;
    }
}

int main()
{
    DLinkNode *h;
    ElemType e;

    printf("(1)初始化双链表h\n");
    InitList(h);
    printf("(2)依次采用尾插法插入a,b,c,d,e元素\n");
    ListInsert(h, 1, ‘a‘);
    ListInsert(h, 2, ‘b‘);
    ListInsert(h, 3, ‘c‘);
    ListInsert(h, 4, ‘d‘);
    ListInsert(h, 5, ‘e‘);
    printf("(3)输出双链表h:");
    DispList(h);
    printf("(4)双链表h长度:%d\n", ListLength(h));
    printf("(5)双链表h为%s\n", (ListEmpty(h) ? "空" : "非空"));
    GetElem(h, 3, e);
    printf("(6)双链表h的第3个元素:%c\n", e);
    printf("(7)元素e的位置:%d\n", LocateElem(h, ‘e‘));
    printf("(8)在第4个元素位置上插入f元素\n");
    ListInsert(h, 4, ‘f‘);
    printf("(9)输出双链表h:");
    DispList(h);
    printf("(10)删除h的第3个元素\n");
    ListDelete(h, 3, e);
    printf("(11)输出双链表h:");
    DispList(h);
    printf("(12)释放双链表h\n");
    DestroyList(h);
}

技术图片

4、循环单链表的各种基本运算操作

技术图片

#include <stdio.h>
#include <malloc.h>

//学习自CSDN作者-静能生悟，循环单链表主要看插入和删除操作的代码实现即可

typedef char ElemType;
typedef struct LNode   // 定义循环单链表结点类型
{
    ElemType data;   // 数据域
    struct LNode *next;   // 指针域
}CLinkList;

//初始化
void InitList(CLinkList *&L)   // 指针的引用
{
    L = (CLinkList *)malloc(sizeof(CLinkList));   //创建头结点
    L->next = L;
}

//销毁循环单链表L
void DestroyList(CLinkList *&L)
{
    CLinkList *p = L;
    CLinkList *q = p->next;
    
    while(q != L)
    {
        free(p);
        p = q;
        q = p->next;
    }
    free(p);
}

//判断是否为空表
int ListEmpty(CLinkList *L)
{
    return (L->next == L);            
}

//求长度
int ListLength(CLinkList *L)
{
    int i = 0;
    CLinkList *p = L;
    
    while(p->next != L)
    {
        i++;
        p = p->next;
    }
    
    return i;
}

//输出循环单链表L
void DispList(CLinkList *L)
{
    CLinkList *p = L->next;
    
    while(p != L)
    {
        printf("%c ", p->data);
        p = p->next;
    }
    printf("\n");
}

//获取循环单链表L中的第i个元素
int GetElem(CLinkList *L, int i, ElemType &e)    
{
    int j = 0;
    CLinkList *p;
    
    if(L->next != L)   // 单链表为非空表时
    {
        if(i == 1)
        {
            e = L->next->data;   // 提取元素
            return 1;
        }
        else   // i不为1时
        {
            p = L->next;
            while((p != L) && (j < i - 1))
            {
                j++;
                p = p->next;
            }
            if(p == L)
                return 0;
            else   // 找到第i个元素
            {
                e = p->data;    
                return e;
            }
        }
    }
    else                        // 单链表为空表时
        return 0;
}

//在循环单链表L中查找元素e
int LocateElem(CLinkList *L, ElemType e)
{
    int n = 1;
    CLinkList *p = L->next;
    
    while((p != L) && (p->data != e))
    {
        p = p->next;
        n++;
    }
    
    if(p == L)
        return 0;
    else
        return n;
}

//在循环单链表L中第i个位置上插入元素e
int ListInsert(CLinkList *&L, int i, ElemType e)
{
    int j = 0;
    CLinkList *p = L, *s;
    
    if((i == 1) || (p->next == L))                        // 原单链表为空表或i=1时
    {
        s = (CLinkList *)malloc(sizeof(CLinkList));        // 创建新结点s
        s->data = e;
        s->next = p ->next;                                // 将s插入到p之后
        p->next = s;
        return 1;
    }
    else
    {
        p = L->next;
        while((p != L) && (j < i - 2))                    // 查找第i-1个结点
        {
            j++;
            p = p->next;
        }
        
        if(p == L)                                        // 未找到第i-1个结点
            return 0;
        else                                            // 找到第i-1个结点
        {
            s = (CLinkList *)malloc(sizeof(CLinkList));    // 创建新结点s
            s->data = e;
            s->next = p->next;                            // 将s插入到p之后
            p->next = s;
            return 1;
        }
    }
}

//在循环单链表L中删除第i个元素
int ListDelete(CLinkList *&L, int i, ElemType &e)
{
    int j = 0;
    CLinkList *p = L, *q;
    
    if(p->next != L)                                    // 原单链表不为空表时
    {
        if(i == 1)                                        // i=1时
        {
            q = L->next;                                // 删除第1个结点
            e = q->data;
            L->next = q->next;
            free(q);
            return 1;
        }
        else                                            // i不为1时
        {
            p = L->next;
            while((p != L) && (j < i - 2))                // 查找第i-1个结点                    
            {
                j++;
                p = p->next;
            }
            if(p == L)                                    // 未查找到第i-1个结点    
                return 0;
            else                                        // 查找到第i-1个结点    
            {
                q = p->next;                            // q指向要删除的结点
                e = q->data;                            // 提取元素
                p->next = q->next;                        // 从单链表中删除q结点
                free(q);                                // 释放q结点
            }
        }
    }
    else
        return 0;
}

int main()
{
    CLinkList *h;
    ElemType e;
    
    printf("(1)初始化循环单链表h\n");
    InitList(h);
    printf("(2)依次采用尾部插入法插入a,b,c,d,e元素\n");
    ListInsert(h, 1, ‘a‘);
    ListInsert(h, 2, ‘b‘);
    ListInsert(h, 3, ‘c‘);
    ListInsert(h, 4, ‘d‘);
    ListInsert(h, 5, ‘e‘);
    printf("(3)输出循环单链表h:");
    DispList(h);
    printf("(4)循环单链表h长度=%d\n", ListLength(h));
    printf("(5)循环单链表h为%s\n", (ListEmpty(h) ? "空" : "非空"));
    GetElem(h, 3, e);
    printf("(6)循环单链表h的第3个元素=%c\n", e);
    printf("(7)元素a的位置=%d\n", LocateElem(h, ‘a‘));
    printf("(8)在第4个元素位置上插入f元素\n");
    ListInsert(h, 4, ‘f‘);
    printf("(9)输出循环单链表h:");
    DispList(h);
    printf("(10)删除h的第3个元素\n");
    ListDelete(h, 3, e);
    printf("(11)输出循环单链表h:");
    DispList(h);
    printf("(12)释放循环单链表h\n");
    DestroyList(h);
}

技术图片

5、循环双链表的各种基本运算操作

技术图片

#include <stdio.h>
#include <malloc.h>

//学习自CSDN作者-静能生悟，循环双链表主要看插入和删除操作的代码实现即可

typedef char ElemType;
typedef struct DNode                        // 定义循环双链表结点类型
{
    ElemType data;                            // 数据域
    struct DNode *prior;                    // 指向直接前驱结点
    struct DNode *next;                        // 指向直接后继结点
}CDLinkList;


//初始化
void InitList(CDLinkList *&L)    // 指针的引用
{
    L = (CDLinkList *)malloc(sizeof(CDLinkList));            // 创建头结点
    L->prior = L->next = L;
}

//销毁循环双链表L
void DestroyList(CDLinkList *&L)
{
    CDLinkList *p = L;
    CDLinkList *q = p->next;
    
    while(q != L)
    {
        free(p);
        p = q;
        q = p->next;
    }
    free(p);
}

//判断循环双链表L是否为空表
int ListEmpty(CDLinkList *L)
{
    return (L->next == L);
}

//求长度
int ListLength(CDLinkList *L)
{
    int i = 0;
    CDLinkList *p = L;
    
    while(p->next != L)
    {
        i++;
        p = p->next;
    }
    return i;
}

//输出循环双链表L
void DispList(CDLinkList *L)
{
    CDLinkList *p = L->next;
    
    while(p != L)
    {
        printf("%c ", p->data);
        p = p->next;
    }
    printf("\n");
}

//获取循环双链表L中第i个元素
int GetElem(CDLinkList *L, int i, ElemType &e)
{
    int j = 0;
    CDLinkList *p;
    
    if(L->next != L)                                // 循环双链表为非空表时
    {
        if(i == 1)
        {
            e = L->next->data;                        // 提取元素
            return 1;
        }
        else                                        // i不为1时
        {
            p = L->next;
            while((p != L) && (j < i - 1))            
            {
                j++;
                p = p->next;
            }
            if(p == L)
                return 0;
            else
            {
                e = p->data;
                return 1;
            }
        }
    }
    else                                            // 循环双链表为空表时
        return 0;
}

//在循环双链表L中查找元素e
int LocateElem(CDLinkList *L, ElemType e)
{
    int n = 1;
    CDLinkList *p = L->next;
    
    while((p != L) && (p->data != e))
    {
        n++;
        p = p->next;
    }
    if(p == NULL)
        return 0;
    else
        return n;
}

//在循环双链表L中第i个位置上插入元素e
int ListInsert(CDLinkList *&L, int i, ElemType e)
{
    int j = 0;
    CDLinkList *p = L, *s;
    
    if(p->next == L)                                    // 原双链表为空表时
    {
        s = (CDLinkList *)malloc(sizeof(CDLinkList));        // 创建新结点s
        s->data = e;
        p->next = s; s->next = p;
        p->prior = s; s->prior = p;
        return 1;
    }
    else if(i == 1)                                        // 原双链表不为空表但i=1时
    {
        s = (CDLinkList *)malloc(sizeof(CDLinkList));        // 创建新结点s
        s->data = e;
        // 将s插入到结点p之后
        s->next = p->next;
        p->next = s;
        s->next->prior = s;
        s->prior = p;
        return 1;
    }
    else
    {
        p = L->next;
        while((p != L) && (j < i - 2))
        {
            j++;
            p = p->next;
        }
        if(p == L)                                        // 未找到第i-1个结点
            return 0;
        else                                            // 找到第i-1个结点p
        {
            s = (CDLinkList *)malloc(sizeof(CDLinkList));    // 创建新结点s
            s->data = e;
            // 将s插入到结点p之后
            s->next = p->next;
            if(p ->next != NULL)
                p->next->prior = s;
            s->prior = p;
            p->next = s;
            return 1;
        }
    }
}

//在循环双链表L中删除第i个元素e
int ListDelete(CDLinkList *&L, int i, ElemType &e)
{
    int j = 0;
    CDLinkList *p = L, *q;
    
    if(p->next != L)                                    // 原双链表不为空表时
    {
        if(i == 1)                                        // i=1时
        {
            q = L->next;                                // 删除第1个结点
            e = q->data;
            L->next = q->next;
            q->next->prior = L;
            free(q);
            return 1;
        }
        else                                            // i不为1时
        {
            p = L->next;
            while((p != NULL) && (j < i - 2))
            {
                j++;
                p = p->next;
            }
            if(p == NULL)                                // 未找到第i-1个结点
                return 0;
            else                                        // 找到第i-1个结点p
            {
                q = p->next;                            // q指向要删除的结点
                if(q == NULL)                            // 不存在第i个结点
                    return 0;
                e = q->data;
                // 从链表中删除q结点
                p->next = q->next;
                if(p->next != NULL)
                    p->next->prior = p;
                free(q);
                return 1;
            }
        }
    }
    else                                                // 原双链表为空表时
        return 0;
}

int main()
{
    CDLinkList *h;
    ElemType e;
    
    printf("(1)初始化循环双链表h\n");
    InitList(h);
    printf("(2)依次采用尾插入法插入a,b,c,d,e元素\n");
    ListInsert(h, 1, ‘a‘);
    ListInsert(h, 2, ‘b‘);
    ListInsert(h, 3, ‘c‘);
    ListInsert(h, 4, ‘d‘);
    ListInsert(h, 5, ‘e‘);
    printf("(3)输出循环双链表h:");
    DispList(h);
    printf("(4)循环双链表h长度=%d\n", ListLength(h));
    printf("(5)循环双链表h为%s\n", (ListEmpty(h) ? "空" : "非空"));
    GetElem(h, 3, e);
    printf("(6)循环双链表h的第3个元素=%c\n", e);
    printf("(7)元素a的位置=%d\n", LocateElem(h, ‘a‘));
    printf("(8)在第4个元素位置上插入f元素\n");
    ListInsert(h, 4, ‘f‘);
    printf("(9)输出循环双链表h:");
    DispList(h);
    printf("(10)删除h的第3个元素\n");
    ListDelete(h, 3, e);
    printf("(11)输出循环双链表h:");
    DispList(h);
    printf("(12)释放循环双链表h\n");
    DestroyList(h);
}

技术图片

6、将单链表按基准划分

技术图片

#include <stdio.h>
#include <malloc.h>

typedef int ElemType;
typedef struct LNode
{
    ElemType data;   //数据域
    struct LNode *next;   //指向后继结点
}LinkNode;   // 声明单链表结点类型

//尾插法建立单链表
void CreateListRear(LinkNode *&L,ElemType a[],int n)
{
    LinkNode *s,*r;
    int i;
    L=(LinkNode *)malloc(sizeof(LinkNode));   //创建头结点
    r=L;   //r始终指向尾结点，开始时指向头结点
    for (int i = 0; i < n; i++)
    {
        //创建新结点s
        s=(LinkNode *)malloc(sizeof(LinkNode));
        s->data=a[i];
        r->next=s;   //将s插入r之后
        r=s;
    }
    r->next=NULL;    //尾结点next域置为NULL
}
//输出单链表
void DispList(LinkNode *L)
{
    LinkNode *p=L->next;   //p指向首节点
    while(p!=NULL)
    {
        printf("%d",p->data );   // p不为NULL,输出p结点的数据域
        p=p->next;    // p移向下一个结点
    }
    printf("\n");
}
//销毁单链表
void DestroyList(LinkNode *L)
{
    LinkNode *pre=L,*p=L->next;    //pre指向头结点，p指向首节点
    while(p!=NULL)
    {
        free(pre);
        pre=p;
        p=pre->next;   // pre、p同步后移一个结点
    }
    free(pre);    // 此时p为NULL,pre指向尾结点,释放它
}
//将L中所有数据结点按e进行划分 【本题核心代码】
void split(LinkNode *&L,ElemType e)
{
    LinkNode *p=L->next,*q,*r;    //p指向首节点
    //L变为空表
    L->next=NULL;
    // r是新链表的尾结点指针
    r=L;

    while(p!=NULL)
    {
        if(p->data<e)   // 若p结点值小于e,将其插入到开头
        {
            q=p->next;
            p->next=L->next;
            L->next=p;
            // 若p结点是第一个在开头插入的结点,则它是尾结点
            if(p->next==NULL)
                r=p;
            p=q;
        }
        else    // 若p结点值大于或等于e,将其插入到末尾
        {
            r->next=p;
            r=p;
            p=p->next;
        }
    }
    r->next=NULL;
}

int main()
{
    LinkNode *L;
    //ElemType a[] = {1,2,3,5,6,7,8,9};
    ElemType a[] = {1,9,8,6,5,3,7,2};
    int n = 8;
    CreateListRear(L,a,n);
    printf("单链表L:");
    DispList(L);
    ElemType x = 4;
    printf("以%d进行划分\n", x);
    split(L,x);
    printf("单链表L:");
    DispList(L);
    DestroyList(L);
}

技术图片

7、将两个单链表合并成一个单链表

技术图片

//注意空间复杂度O(1) 即不能开辟新的辅助空间
#include <stdio.h>
#include <malloc.h>

typedef int ElemType;
typedef struct LNode
{
    ElemType data;   //数据域
    struct LNode *next;   //指向后继结点
}LinkNode;   // 声明单链表结点类型

//尾插法建立单链表
void CreateListRear(LinkNode *&L,ElemType a[],int n)
{
    LinkNode *s,*r;
    int i;
    L=(LinkNode *)malloc(sizeof(LinkNode));   //创建头结点
    r=L;   //r始终指向尾结点，开始时指向头结点
    for (int i = 0; i < n; i++)
    {
        //创建新结点s
        s=(LinkNode *)malloc(sizeof(LinkNode));
        s->data=a[i];
        r->next=s;   //将s插入r之后
        r=s;
    }
    r->next=NULL;    //尾结点next域置为NULL
}
//输出单链表
void DispList(LinkNode *L)
{
    LinkNode *p=L->next;   //p指向首节点
    while(p!=NULL)
    {
        printf("%d ",p->data );   // p不为NULL,输出p结点的数据域
        p=p->next;    // p移向下一个结点
    }
    printf("\n");
}
//销毁单链表
void DestroyList(LinkNode *L)
{
    LinkNode *pre=L,*p=L->next;    //pre指向头结点，p指向首节点
    while(p!=NULL)
    {
        free(pre);
        pre=p;
        p=pre->next;   // pre、p同步后移一个结点
    }
    free(pre);    // 此时p为NULL,pre指向尾结点,释放它
}
//合并
void MergeList(LinkNode *L1,LinkNode *L2,LinkNode *&L3)
{
    LinkNode *p = L1->next;
    LinkNode *q = L2->next;
    LinkNode *r;

    L3=L1;
    // r指向新建单链表L3的尾结点
    r=L3;
    //释放L2头结点
    free(L2);
    while(p!=NULL&&q!=NULL)
    {
        r->next=p;
        r=p;
        p=p->next;

        r->next=q;
        r=q;
        q=q->next;
    }
    r->next=NULL;
    if(q!=NULL)
        p=q;
    r->next=p;
}

int main()
{
    LinkNode *L1, *L2, *L3;
    ElemType a[] = {1,2,3,4,5,6,7,8};
    int n = 8;

    CreateListRear(L1,a,n);
    printf("单链表L1:");
    DispList(L1);
	
	ElemType b[] = {20,19,18,17};
    n = 4;
    CreateListRear(L2,b,n);
    printf("单链表L2:");
    DispList(L2);
    printf("L1和L2合并产生L3\n");
    MergeList(L1,L2,L3);
    printf("单链表L3:");
    DispList(L3);
    DestroyList(L3);
}

技术图片

8、求集合（用单链表表示）的并集、交集、差集运算

技术图片

#include <stdio.h>
#include <stdlib.h>

//重点题型，掌握并集、交集、差集的实现

typedef int ElemType;
typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LinkList;


/* 单链表的初始化 */
void InitList(LinkList *&L)
{
    L = (LinkList *)malloc(sizeof(LinkList));
    L->next=NULL;
}

//向单链表中插入数据元素
bool ListInsert(LinkList *&L,int x,char e)
{
    int j = 0;
    LinkList *p = L, *s;
    while(p!=NULL && j<x-1)
    {
        p = p->next;
        j++;
    }
    if(p==NULL)
    {
        return false;
    }
    else
    {
        s = (LinkList *)malloc(sizeof(LinkList));
        s->data = e;
        s->next = p->next;
        p->next = s;
        return true;
    }
}

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

// 求单链表的长度
int ListLength(LinkList *L)
{
    LinkList *p = L->next;
    int i = 0;
    while(p!=NULL)
    {
        i++;
        p = p->next;
    }
    return i;
}

// 查看单链表是否为空
bool ListEmpty(LinkList *L)
{
    return L->next==NULL;
}

//求单链表中某个数据元素值
bool GetElem(LinkList *L,int i, ElemType &e)
{
    LinkList *p = L;
    int j = 0;
    while(p!=NULL && j < i)
    {
        p=p->next;
        j++;
    }
    if(p==NULL)
    {
        return false;
    }
    else
    {
        e = p->data;
        return true;
    }
}

// 在单链表中查找元素
int LocateElem(LinkList *L,ElemType e)
{
    LinkList *p = L;
    int i = 0;
    while(p!=NULL && p->data!=e)
    {
        p = p->next;
        i++;
    }
    if(p==NULL)
    {
        return 0;
    }
    else
    {
        return i;
    }
}

//删除单链表中第 i 个元素
bool ListDelete(LinkList *&L,int i,ElemType &e)
{
    int j = 0;
    LinkList *p = L, *q;
    while(p!=NULL && j < i - 1)
    {
        p = p->next;
        j++;
    }
    if(p==NULL)
        return false;
    else
    {
        q = p->next;
        if(q==NULL)
            return false;
        e = q->data;
        p->next = q->next;
        free(q);
        return true;
    }
}

//销毁单链表
void DestroyList(LinkList *&L)
{
    LinkList *p = L;
    LinkList *q = p->next;
    while(q!=NULL)
    {
        free(p);
        p = q;
        q = p->next;
    }
    free(p);
}

//将集合 a 和 b 中的元素添加到顺序表 ha 和 hb 中
void CreateListR(LinkList *&L,ElemType e[],int n)
{
    InitList(L);
    int i;
    for(i = 0;i < n; ++i)
    {
        if(!LocateElem(L,e[i]))
            ListInsert(L,i+1,e[i]);
    }
}

//选择排序
void sort(LinkList *&L)
{
    LinkList *p , *pre, *q, *k;
    InitList(p);
    int i = 0;
    int c;
    while(!ListEmpty(L))
    {
        pre = L ->next;
        c = pre->data;
        while(pre!=NULL)
        {
            if(c>=pre->data)
                c = pre->data;
            pre = pre->next;
        }
        ListInsert(p,++i,c);
        int tag = LocateElem(L,c);
        ListDelete(L,tag,c);
    }
    L = p;
}

//并集 
void Union(LinkList *a,LinkList *b,LinkList *&c)
{
    InitList(c);
    LinkList *p = a->next;
    LinkList *q = b->next;
    int k = 0;
    while(p!=NULL && q!=NULL)
    {
        if(p->data < q->data)
        {
            ListInsert(c,k+1,p->data);
            p = p->next;
            k++;
        }
        else if(p->data == q->data)
        {
            ListInsert(c,k+1,p->data);
            p = p->next;
            q = q->next;
            k++;
        }
        else
        {
            ListInsert(c,k+1,q->data);
            q = q->next;
            k++;
        }
    }
    while(p!=NULL)
    {
        ListInsert(c,k+1,p->data);
        p = p->next;
        k++;
    }
    while(q!=NULL)
    {
        ListInsert(c,k+1,q->data);
        q  = q->next;
        k++;
    }
}

//交集 a中元素一个个取出，通过LocateElem函数看b中是否出现，出现则copy至c
void InsterSect(LinkList *a,LinkList *b,LinkList *&c)
{
    DestroyList(c);
    InitList(c);
    LinkList *p = a->next;
    int i = 0;
    while(p!=NULL)
    {
        if(LocateElem(b,p->data))
            ListInsert(c,++i,p->data);
        p = p->next;
    }
}

//差集 a中元素一个个取出，通过LocateElem函数看b中是否出现，不出现则copy至c
void Subs(LinkList *a,LinkList *b,LinkList *&c)
{
    DestroyList(c);
    InitList(c);
    LinkList *p = a->next;
    int i = 0;
    while(p!=NULL)
    {
        if(!LocateElem(b,p->data))
            ListInsert(c,++i,p->data);
        p = p->next;
    }
}


int main( )
{
    LinkList *ha, *hb, *hc;
    ElemType a[]={1,2,3,4};
    ElemType b[]={10,4,22,5,81,2};
    printf("集合的运算如下\n");
    CreateListR(ha,a,4);
    CreateListR(hb,b,6);
    printf("原 集 合 A: "); DispList(ha);
    printf("原 集 合 B: "); DispList(hb);
    sort(ha);
    sort(hb);
    printf("有序集合A："); DispList(ha);
    printf("有序集合B："); DispList(hb);
    Union(ha,hb,hc);
    printf("集合的并C："); DispList(hc);
    InsterSect(ha,hb,hc);
    printf("集合的交C："); DispList(hc);
    Subs(ha,hb,hc);
    printf("集合的差C："); DispList(hc);
    DestroyList(ha);
    DestroyList(hb);
    DestroyList(hc);
}

技术图片

9、求两个多项式的相加运算

技术图片

#include<stdio.h>
#include<stdlib.h>

//学习自CSDN作者-man_zuo

typedef struct 
{
    float coef;   //系数
    int expn;   //指数   
}Term;
typedef struct Ploynomial
{
    Term term;
    Ploynomial *next;
}Ploynomial,*LinkList;

//初始化单链表
void InitList(LinkList &L)
{
    L= (Ploynomial*)malloc(sizeof(Ploynomial));//头结点
    L->term.coef=0.0;
    L->term.expn=-1;
    L->next=NULL;
}
//比较结点的系数大小函数
int cmp(Term a,Term b)
{
    if (a.expn>b.expn) return -1;
    else if(a.expn==b.expn) return 0;
    else return 1;
}
//将结点插入多项式链表的适当位置，可以同时起到创建链表和多项式相加的功能
void insertNode(LinkList &L,Term e)
{
    Ploynomial *q=L;
    while(q->next!=NULL)
    {   //如果当前结点q的下一个结点的指数 大于 要插入的结点的指数
        if (cmp(q->next->term,e)<0)
        {
           q=q->next; 
        }
        else break;   //此时， q.term.expn>e.expn >=q->next->term.expn
    }
    if (q->next!=NULL&&cmp(q->next->term,e)==0)
    {   //指数相同，系数相加
        q->next->term.coef+=e.coef;
    }
    else
    {
        Ploynomial *node = (Ploynomial *)malloc(sizeof(Ploynomial));
        node->term.coef=e.coef;
        node->term.expn=e.expn;
        if(q->next==NULL)
            node->next=NULL;    //如果q结点为尾结点，则node的指针域设为NULL
        else
            node->next=q->next;     //否则node的指针域指向q的下一个结点
        q->next=node;//将node结点插入链表中
    }
}
//输入m项的系数和指数，建立表示一元多项式的有序链表L，演示功能，无需学习
void CreatePolyn(LinkList &L,int n)
{
    Term e;
    InitList(L);
    for (int i = 1; i <= n; i++)
    {
        printf("\n第%d项的系数和指数：",i);
        scanf("%f%d",&e.coef,&e.expn);
        insertNode(L,e);    
    }
}
//用L返回L1+L2的结果
void addPolyn(LinkList &L,LinkList L1,LinkList L2)
{
    Ploynomial *q;
    for (q=L1->next; q!=NULL; q=q->next)
    {
        insertNode(L,q->term);   //将L1的每一项插入到L中
    }
    for (q=L2->next; q!=NULL; q=q->next)
    {
        insertNode(L,q->term);   //将L2的每一项插入到L中
    }
}

//以类数学表达式的形式打印输出一元多项式L,演示功能，无需学习
void visitList(LinkList L)
{
    Ploynomial *q=L;
    int flag;
    while(q->next!=NULL)
    {
        q=q->next;
        flag=1;
        if(q->term.coef==0) continue;//系数为0 不输出
        if(q->term.expn==0&&flag==1) //指数为1
        {
            if(q->term.coef>0)
                printf("+%.2f",q->term.coef);
            else
                printf("%.2f",q->term.coef);
            flag=0;
        }
        if((q->term.coef==1||q->term.coef==-1)&&flag==1)//系数为1
        {
            if(q->term.expn==1){
                if(q->term.coef==1)
                   printf("+X");
                else
                   printf("-X");
            }else{
                if(q->term.coef==1)
                    printf("+X^%d",q->term.expn);
                else
                    printf("-X^%d",q->term.expn);
            }
            flag=0;
        }
        if(flag==1)
        {
            if(q->term.coef>0)
                printf("+%.2fX^%d",q->term.coef,q->term.expn);
            else
                printf("%.2fX^%d",q->term.coef,q->term.expn);
        }

    }
    printf("\n");
}

int main()
{
    LinkList L1,L2;
    int n1,n2;
    printf("请输入多项式L1的项数：");
    scanf("%d",&n1);
    CreatePolyn(L1,n1);
    printf("请输入多项式L2的项数：");
    scanf("%d",&n2);
    CreatePolyn(L2,n2);
    printf("\n多项式L1:  ");
    visitList(L1);
    printf("\n多项式L2:  ");
    visitList(L2);
    LinkList add;
    InitList(add);
    addPolyn(add,L1,L2);
    printf("\nL1 + L2:   ");
    visitList(add);
}

技术图片

10、求两个多项式的相乘运算

技术图片

//用L返回L1*L2的结果
//将该方法加入第九题中即可，书写主方法即可
void multiplyPolyn(LinkList &L,LinkList L1,LinkList L2)
{
    Ploynomial *p,*q;
    Term term;
    term.coef=0.0;
    term.expn=0;
    for(q=L1->next; q!=NULL; q=q->next)
    {
        for(p=L2->next; p!=NULL; p=p->next)
        {
            term.coef=(q->term.coef)*(p->term.coef);//系数相乘
            term.expn=(q->term.expn)+(p->term.expn);// 指数想加
            insertNode(L,term);
        }
    }
}

技术图片

11、用单链表实现两个大整数的相加运算

技术图片

#include <stdio.h>
#include <malloc.h>
#include <string.h>
#define MAX_SIZE 50

//学习于CSDN作者-静能生悟，本题重点在于学习add操作，以及为什么要reverse

typedef struct node
{
    int data;
    struct node *next;
}NodeType;

//创建整数单链表
void createList(NodeType *&h,char a[],int n)
{
    NodeType *p,*r;
    int i=0;
    //创建头结点
    h=(NodeType *)malloc(sizeof(NodeType));
    r=h;   //r指向新创建的头结点
    while(i<n)
    {
        //创建新结点p
        p=(NodeType *)malloc(sizeof(NodeType));
        p->data=a[n-i-1]-‘0‘;
        //将p插入r之后
        r->next=p;
        //r指向新结点
        r=p;
        i++;
    }
    r->next=NULL;
}
//输出单链表
void dispList(NodeType *h)
{
    NodeType *p = h->next; // p指向整数单链表的第一个数据结点

    while(p != NULL)
    {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}
//销毁单链表
void destoryList(NodeType *&h)
{
    NodeType *pre=h;   // pre指向整数单链表的头结点
    NodeType *p=pre->next;   // p指向整数单链表的第一个数据结点(首节点)
    while(p!=NULL)
    {
        free(pre);
        pre=p;   //pre,p同步后移一个结点
        p=p->next;
    }
    free(pre);
}
//两整数单链表h1和h2相加得到h
void addList(NodeType *h1,NodeType *h2,NodeType *&h)
{
    NodeType *p1=h1->next;   //p1指向单链表h1中的第一个数据结点
    NodeType *p2=h2->next;   //p2指向单链表h2中的第一个数据结点
    NodeType *p,*r;
    int carry = 0;

    //创建头结点
    h=(NodeType *)malloc(sizeof(NodeType));
    // r指向新创建头结点
    r=h;
    while(p1!=NULL&&p2!=NULL)
    {
        //创建新结点p
        p=(NodeType *)malloc(sizeof(NodeType));
        p->data=(p1->data+p2->data+carry)%10;   // 求余
        // 将新结点p插入到r指向的头结点之后
        r->next=p;
        // r后移一个结点
        r=p;
        carry=(p1->data+p2->data+carry)/10;   //求商
        // p1和p2指向下一个结点
        p1 = p1->next;
        p2 = p2->next;
    }
    if(p1!=NULL)
        p1=p2;
    while(p1!=NULL)
    {
        p=(NodeType *)malloc(sizeof(NodeType));
        p->data=(p1->data+carry)%10;    // 数据域
        // 将新结点p插入到r指向的头结点之后
        r->next=p;
        // r后移一个结点
        r=p;
        carry=(p1->data+carry)/10;
        p1=p1->next;
    }
    // 最后carry不为0时,创建一个结点存放它
    if(carry>0)
    {
        p=(NodeType *)malloc(sizeof(NodeType));
        p->data=carry;
        // 将新结点p插入到r指向的头结点之后
        r->next = p;
        // r后移一个结点
        r = p;
    }
    r->next=NULL;
}
//逆置整数单链表h
void reverseList(NodeType *&h)
{
    NodeType *p=h->next,*q;
    h->next=NULL;
    while(p!=NULL)
    {
        q=p->next;
        p->next=h->next;
        h->next=p;
        p=q;
    }
}

//求整数单链表h的中间位
/**
*   算法设计思路:
*   定义快指针quick和慢指针slow,初始时都指向头结点,当快指针没有
*   扫描完整数单链表h时,每次让慢指针slow前进一个结点,快指针quick前进两个
*   结点.当快指针到达链表尾时,慢指针slow指向的结点就是中间结点.
*/
int midList(NodeType *h)
{
    NodeType *slow=h;   //定义慢指针
    NodeType *quick=h;   //定义快指针
    while(quick!=NULL&&quick->next!=NULL)
    {
        slow=slow->next;   // 慢指针slow前进一个结点
        quick=quick->next->next;   // 快指针quick前进两个结点
    }
    return slow->data;
}

int main(int argc, char const *argv[])
{
    NodeType *h1,*h2,*h;
    char s[MAX_SIZE],t[MAX_SIZE];
    printf("(1)输入大整数a: ");
    scanf("%s", s);
    printf("(2)输入大整数b: ");
    scanf("%s", t);
    createList(h1,s,strlen(s));
    createList(h2,t,strlen(t));
    printf("(3)整数单链表a: ");
    dispList(h1);
    printf("(4)整数单链表b: ");
    dispList(h2);
    addList(h1,h2,h);
    printf("(5)结果单链表c: ");
    dispList(h);
    reverseList(h);
    printf("(6)对应的整数c: ");
    dispList(h);
    printf("(7)中间位: %d", midList(h));
    destoryList(h);
    destoryList(h1);
    destoryList(h2);

    return 0;
}

技术图片

数据结构上机实验（2）

标签：函数   选择排序   return   返回   作者   merge   creat   item   bool   

原文地址：https://www.cnblogs.com/wangzheming35/p/12944595.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！