数据结构实验 —— 线性表

顺序表

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

//线性表动态 分配顺序存储结构

#define LIST_INIT_SIZE 100//线性表存储空间的初始分配量

#define LISTINCREMENT 10//线性表存储空间的线性增量

#define ERROR -1 //定义错误 ERROR
#define OK 1

typedef int Status;//状态码
typedef int ElemType;//声明 元素类型

//---------------------创造一个线性表结构体
typedef struct{
    ElemType *elem;//存储空间 基址   -----> 一个指向元素类型的指针
    int length;//当前的长度
    int listsize;//当前分配的存储容量【以sizeof(ElemType) 即存储 单位 元素的 内存大小 为单位】
}SqList;

//初始化 结构体
Status InitList_Sq(SqList *L){
    //指向线性表的指针L，对L中的 基地址分配存储空间
    L->elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
    //根据创建失败返回0来判定是否申请内存成功
    if(!L->elem)
        return ERROR;
    //申请内存成功，定义空表的长度为0，定义初始存储容量
    int i =0;
    printf("请输入顺序表元素个数:");
    scanf("%d",&i);
    for(int j =0;j<i;j++){
        int x;
        printf("请输入元素:");
        scanf("%d",&x);
        L->elem[j] = x;
        printf("\n");
    }
    L->length = i; //长度为i
    L->listsize = LIST_INIT_SIZE;//初始的存储容量
    printf("线性表初始化成功...\n");
    return OK;
}
//打印结构体
void print(SqList *L){
    printf("打印线性表：");
    int i;
    for(i = 0;i < L->length;i++){
        printf("%d ",L->elem[i]);
    }
    printf("\n");
}

//插入结构体
Status ListInsert_Sq(SqList *L,int i,ElemType e){
    if(i < 1 || i > L->length + 1){
        printf("\n插入位置错误\n");
        return ERROR;
    }
        //i 值 不合法
    if(L->length >= L->listsize){
        ElemType *newbase = (ElemType *)realloc(L->elem,(L->listsize + LISTINCREMENT)*sizeof(ElemType));
        if(!newbase)
            return ERROR;
        L->elem = newbase;
        L->listsize += LISTINCREMENT;
    }
    ElemType *q = &(L->elem[i-1]);
    for(ElemType *p = &(L->elem[L->length - 1]);p >= q;--p)
        *(p+1) = *p;
    *q = e;
    ++L->length;
    return OK;

}
//查找线性表   按【值】查找，返回位置
 int findR(SqList *L,int re){
    for(int i = 0 ;i < L->length;i++){
        if(L->elem[i]  == re){
             printf("\n该元素位于第%d个\n",i+1);
             return i;
        }

    }
    printf("\n 没有发现%d\n",re);
    return ERROR;
 }

//查找线性表  按【位置】查找，返回值
ElemType getElem(SqList *L,int i){
    if(i >L->length || i < 1){
        printf("\n位置错误\n");
        return ERROR;
    }
    printf("\n 该位置值为%d\n",L->elem[i-1]);
    return OK;
}

//删除线性表  按【位置】删除
Status deleteP(SqList *L,int i){
    if(i >L->length || i < 1){
        printf("\n位置错误\n");
        return ERROR;
    }
    --i;
    int k;
    //将后面的元素依次 向前移动
    for(k = i;k < L->length;k++){
        L->elem[k] = L->elem[k+1];
    }
    --L->length;
    return OK;

}

//升序排序
Status orderOn(SqList *L){
    for(int k = 0;k < L->length-1;k++){
        for(int i = 0;i < L->length - 1 - k;i++){
            if(L->elem[i+1] < L->elem[i]){
                int temp = L->elem[i+1];
                L->elem[i+1] = L->elem[i];
                L->elem[i] = temp;
            }
        }
    }
}
//降序排序
Status orderUp(SqList *L){
    for(int k = 0;k < L->length-1;k++){
        for(int i = 0;i < L->length - 1 - k;i++){
            if(L->elem[i+1] > L->elem[i]){
                int temp = L->elem[i+1];
                L->elem[i+1] = L->elem[i];
                L->elem[i] = temp;
            }
        }
    }
}

//两个线性表的合并
Status hebin(SqList *L1,SqList *L2,SqList *L){
    int i = 0,j = 0,k=0;
    int ss = 0;//如果有相同的，则计数，在最后减去此长度
    while(i< L1->length && j < L2->length){
        if(L1->elem[i] < L2->elem[j]){
            L->elem[k] = L1->elem[i];
            ++i;
            ++k;
        }else if (L1->elem[i] > L2->elem[j]){
             L->elem[k] = L2->elem[j];
            ++j;
            ++k;
        }else{
            L->elem[k] = L1->elem[i];
            ++i;
            ++j;
            ++k;
            ss++;
        }
    }

    while(i <= L1->length - 1){
        L->elem[k] = L1->elem[i];
        ++i;
        ++k;
    }
    while(j <= L2->length -1){
        L->elem[k] = L2->elem[j];
        ++j;
        ++k;
    }
    if(ss)
        L->length = L1->length + L2->length - ss;
    else
        L->length = L1->length + L2->length;
    print(L);
    return OK;
}
int main()
{
    SqList L;
    int xuanze;
    while(1){
     printf("\n*************\n1.初始化线性表\n2.打印线性表\n3.插入线性表\n4.按值查找线性表\n5.按位置查找\n6.按位置删除\n7.升序\n8.降序\n9.合并\n输入0结束程序\n*************\n请输入选择：");
     scanf("%d",&xuanze);
     switch (xuanze){
                case 1:
                    InitList_Sq(&L);
                    break;
                case 2:
                    print(&L);
                    break;
                case 3:
                    int x1,x2;
                    printf("\n请输入在第几个元素位置插入:");
                    scanf("%d",&x1);
                    printf("\n请输入要插入的元素:");
                    scanf("%d",&x2);
                    ListInsert_Sq(&L,x1,x2);
                    break;

                case 4:
                    int y1;
                    printf("\n请输入要查找的值:");
                    scanf("%d",&y1);
                    findR(&L,y1);
                    break;
                case 5:
                    int y3;
                    printf("请输入要查找的位置【第n个】：");
                    scanf("%d",&y3);
                    getElem(&L,y3);
                    break;
                case 6:
                    int y4;
                    printf("请输入要删除的位置【第n个】：");
                    scanf("%d",&y4);
                    deleteP(&L,y4);
                    break;
                case 7:
                    orderOn(&L);
                    break;
                case 8:
                    orderUp(&L);
                    break;
                case 9:
                    SqList L1;
                    SqList L2;
                    printf("\n初始化 线性表1：\n");
                    InitList_Sq(&L1);
                    printf("\n初始化 线性表2：\n");
                    InitList_Sq(&L2);
                    hebin(&L1,&L2,&L);
                    break;
                case 0:
                    exit(0);
                default:
                    printf("");
        }
   }
    return 0;
}

链表

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

#define ERROR -1
#define OK 1

typedef int Status;
typedef int ElemType;

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

//头插入法建立单链表，头结点head 作为返回值
LNode *create_LinkList(void){
    int data;
    LNode *head,*p;
    head = (LNode *)malloc(sizeof(LNode));  //创建头结点
    head->next = NULL;
    while(1){
        printf("请输入结点数值（输入32767结束添加）：");
        scanf("%d",&data);
        if(data == 32767)
            break;
        p = (LNode *)malloc(sizeof(LNode)); //不断创建新的结点
        p->data = data;
        p->next = head->next;
        head->next=p;

    }
    return head;
}

//尾插入法建立链表   链表的头结点head作为返回值
LNode  *create_LinkListWEI(void)
{
    int data;
    LNode *head, *p, *q;
    head=p=(LNode  *)malloc(sizeof(LNode));
    p->next = NULL;
    while (1)
    {
        printf("请输入结点数值（输入32767结束添加）：");
        scanf("%d",&data);
        if (data == 32767)
            break;
        q = (LNode  *)malloc(sizeof(LNode));
        q->data = data;
        q->next = NULL;
        p->next = q;
        p = q;
    }
    return head;
}

//打印单链表
void print(LNode *head){
    LNode *p = head;
    printf("单链表：");
    while(p->next){
        printf("%d ",p->next->data);
        p = p->next;
    }
    printf("\n");

}
//返回结点数
int getJieD(LNode *head){
    LNode *p = head;
    int c =0;
    while(p->next){
        c++;
        p = p->next;
    }
    return c;
}
//按值查找,返回节点序号【第几个结点】
int findByValue(LNode *head,ElemType e){
    LNode *p = head;
    int i = 0;
    while(p->next){
        if(p->next->data == e){
            return i;
        }
        i++;
        p = p->next;
    }
    return ERROR;

}
//按位置返回结点值
int findByWeiZhi(LNode *head,int w){
    LNode *p = head;
    int i21 = 0;
    while(p->next){
        if(i21 == w){
            return p->next->data;
        }
        i21++;
        p = p->next;
    }
    return ERROR;
}
//按值删除结点
void deleteByValue(LNode *L,int key){
    LNode *p = L,  *q = L->next;
    while  ( q->next != NULL && q->data != key){
        p=q;
        q=q->next;
    }
    if  (q->data == key){
        p->next = q->next;
        free(q);
    }else if(q->next == NULL){
        printf("所要删除的结点不存在!\n");

    }

}
//按位置删除结点【第i个】
Status deleteByW(LNode *head,int key){
    LNode *p = head,*q = head->next;
    int i = 0;
    while(q->next != NULL){
        if( i == key-1){
            p->next = q->next;
            free(q);
            return OK;
        }else{
            p = q;
            q = q->next;
        }
        i++;
    }
    i++;
    //尾部 情况删除
    if(i == key){
        //printf("delete last one int ... \n");
        p->next = NULL;
        free(q);
        return OK;
    }else{
        printf("位置错误！\n");
        return ERROR;
    }
}
//在第i个位置后插入值
Status addInToi(LNode *head,int i,int e){
    LNode *p,*q;
    p = head;
    q = head->next;
    if( getJieD(head) < i){
        printf("位置错误！\n");
        return ERROR;
    }
    int a = 0;
    while(q != NULL){
        if(a == i)
            break;
        p = q;
        q = q->next;
        a++;
    }
    LNode *r;
    r = (LNode *)malloc(sizeof(LNode));
    p->next = r;
    r->data = e;
    r->next = q;
}
//合并
LNode *heBin(LNode *La, LNode *Lb){
    LNode *Lc,  *pa ,  *pb ,  *pc, *ptr ;
    Lc=La;
    pc=La;
    pa=La->next;
    pb=Lb->next;
    while (pa!=NULL    && pb!=NULL){
        if  (pa->data < pb->data){
            pc->next=pa;
            pc=pa;
            pa=pa->next;
        }
/*  将pa所指的结点合并，pa指向下一个结点  */
        if  (pa->data>pb->data){
            pc->next=pb;
            pc=pb;
            pb=pb->next;
        }
/*  将pa所指的结点合并，pa指向下一个结点  */
        if  (pa->data==pb->data){
            pc->next=pa;
            pc=pa;
            pa=pa->next;
            pb=pb->next;
        }
/*  将pa所指的结点合并，pb所指结点删除  */
    }
    if (pa!=NULL)
        pc->next=pa;
    else
        pc->next=pb;     /*将剩余的结点链上*/
    return(Lc);
}

int main(){
    int xuanze;
    LNode *p;
    LNode *a,*b;
    int c;
    int nn;
    int ii;
    int i2,i3;
    while(true){
        printf("\n***************\n");
        printf("1.头插入法初始化链表\n");
        printf("2.尾插入法初始化链表\n");
        printf("3.打印链表\n");
        printf("4.得到链表的结点数\n");
        printf("5.按值查找结点\n");
        printf("6.按位置查找结点【返回第i个结点数值】\n");
        printf("7.按值删除节点\n");
        printf("8.删除第i个位置的结点\n");
        printf("9.在第i个位置插入新的结点\n");
        printf("10.合并\n");
        printf("\n");
        printf("***************\n");
        printf("请输入选项：");
        scanf("%d",&xuanze);

        switch(xuanze){
        case 1:
            p = create_LinkList();
            break;
        case 2:
            p = create_LinkListWEI();
            break;
        case 3:
            print(p);
            break;
        case 4:
            c = getJieD(p);
            print(p);
            printf("结点数：%d\n",c);
            break;
        case 5:
            printf("请输入要查找的数值：");
            scanf("%d",&nn);
            print(p);
            ii = findByValue(p,nn);
            if(ii == -1)
                printf("没有该结点\n");
            else
                printf("该结点在第%d个位置\n",ii +1);
            break;

        case 6:
            printf("请输入位置【第i个】：");
            scanf("%d",&nn);
            print(p);
            i2 = findByWeiZhi(p,nn-1);
            if(i2 == -1)
                printf("位置错误\n");
            else
                printf("该结点的数值是：%d\n",i2);
            break;
        case 7:
            printf("请输入要删除的值【将删除第一个与之相同的结点】:");
            scanf("%d",&nn);
            deleteByValue(p,nn);
            print(p);
            break;
        case 8:
            printf("请输入要删除的地址【将删除第i个位置的结点】：");
            scanf("%d",&nn);
            deleteByW(p,nn);
            print(p);
            break;
        case 9:
            printf("请输入要插入的位置【第i个结点之后】：");
            scanf("%d",&ii);
            printf("请输入要插入结点的值：");
            scanf("%d",&nn);
            addInToi(p,ii,nn);
            print(p);
            break;
        case 10:
            printf("尾插入法初始化第一个链表\n");
            a =  create_LinkListWEI();
            printf("尾插入法初始化第二个链表\n");
            b =  create_LinkListWEI();
            printf("合并\n");
            p = heBin(a,b);
            printf("合并完成的链表:");
            print(p);
            printf("\n");
            break;
        }

    }
    return 0;
}

原文地址：https://www.cnblogs.com/expedition/p/12195690.html

时间： 2024-10-11 22:08:03

数据结构实验 —— 线性表的相关文章

软考之路--数据结构之线性表

数据就是数值,也就是我们通过观察.实验或计算得出的结果.数据有很多种,最简单的就是数字.数据也可以是文字.图像.声音等.数据可以用于科学研究.设计.查证等.结构,组成整体的各部分的搭配和安排,两者完美结合在一起,我们这样需要重新认识她,对她重新审视与定义:数据结构是程序设计的重要理论和技术基础,她所讨论的内容和技术,对从事软件项目的开发有重要作用,通过学习数据结构,我们学会从问题出发,分析和研究计算机加工的数据的特性,以便为应用所设计的数据悬着适当的逻辑结构.存储结构及其相应的操作方法,为提高应

自学数据结构——顺序线性表

胡乱写了一些代码 /* ============================================================================ Name : sqlist.c Author :codecup Version : Copyright : Your copyright notice Description : Hello World in C, Ansi-style ==========================================

[笔记]python数据结构之线性表：linkedlist链表,stack栈,queue队列

python数据结构之线性表 python内置了很多高级数据结构,list,dict,tuple,string,set等,在使用的时候十分舒心.但是,如果从一个初学者的角度利用python学习数据结构时,这些高级的数据结构可能给我们以迷惑. 比如,使用list实现queue的时候,入队操作append()时间复杂度可以认为是O(1),但是,出队操作pop(0)的时间复杂度就是O(n). 如果是想利用python学学数据结构的话,我觉得还是自己实现一遍基本的数据结构为好. 1.链表 在这里,我想使

自学数据结构——顺序线性表2

1 /* 2 ============================================================================ 3 Name : sqlist.c 4 Author : codecup 5 Version : 6 Copyright : Your copyright notice 7 Description : Hello World in C, Ansi-style 8 ==================================

数据结构：线性表插入一次删除一次的代码

#include <iostream> #include <cmath> #include <cstring> #include <algorithm> #include <stack> #include <queue> #include <cstdio> using namespace std; int insertsqlist(int weizhi,double charu,int *t,double b[]){   

数据结构之线性表（顺序存储结构）

小学生放学都是要按顺序排队的,一个接一个,每个小学生的前后位置是固定的,这样便于迅速清点. 其实这就是一个线性表,从这件事里我们就可以找到很多关于线性表的特性,如 1.线性表是一个序列,它是有顺序的(排队) 2.第一个元素无前驱,最后一个无后继,其他每个元素都有一个前驱和后继(一个接一个) 3.元素是有限的(小学生的个数是有限的) 4.数据类型都相同(都是小学生在排队) 说明白线性表示什么,下面我们直接看线性表的实现 线性表的实现分顺序存储结构和链式存储结构 顺序存储结构: #define LI

数据结构：线性表之单链表

线性表(亦作顺序表)是最基本.最简单.也是最常用的一种数据结构.线性表中数据元素之间的关系是一对一的关系,即除了第一个和最后一个数据元素之外,其它数据元素都是首尾相接的.线性表有两种存储结构: ①顺序存储结构,即存储单元在一段连续的地址上存储,常见的数组就是顺序存储结构的线性表: ②链式存储结构,即存储单元在不连续的地址上存储.因为其不连续性,除了要存数据元素信息(数据域)外,还要存储它后继元素(结点)的地址(指针域,链).学习链式结构最好将结点结构牢记于心,如下图: 链表的每个结点只含有一个指

数据结构_线性表的顺序表示和链式表示

/********************************************************************************************************************/ 声明: (1)*.h文件是代码声明, *.cpp文件是代码实现; (2)一般头文件的内容有: ①类型声明; ②函数声明; ③枚举; ④常量; ⑤宏 (3)以下说明是为了方便代码文件的管理而设定的一些规则, 以后代码都会按照此规则编写: 1)Pubuse.h 是几

数据结构之线性表再思考

数据结构学起来妙不可言,贼有意思. 很久没写博客了,今天来一篇长的.前面写的关于线性表的代码和思路,经过我多次反复思考,又有了新的收获,与大家一起分享. 1.线性表的定义 首先要明白什么是线性表,一种常用且最简单的数据结构. 数据结构通俗来说就是:装水的杯子,有的是圆的.有的是方的. 官方定义:线性表是n个数据元素的有限序列. 把这个样的一个数据模型映射到计算机,等同找一块存储空间给它,而线性表一般是申请动态内存,因此就是在堆上给它分配一块内存. 看下图 通过图我们可以了解到,线性表数据结构如何