精华内容
下载资源
问答
  • 2021-05-23 11:25:21

    该楼层疑似违规已被系统折叠 隐藏此楼查看此楼

    #include "stdafx.h"

    //定义链表节点类型

    struct node

    {

    int val;//值域

    struct node * next;//指针域

    };

    struct node * creat_link();//声明链表生成函数

    struct node * merge_link(struct node * first_link, struct node * second_link);//声明链表合并函数

    int main(int argc, char* argv[])

    {

    //定义三个链表的头指针以及临时指针变量o

    struct node * ha, * hb, * hc, * o;

    //生成两个递增有序的链表A和B

    ha=creat_link(); hb=creat_link();

    //打印合并前的链表A

    printf("\n\n链表A: HA -> ");

    for(o=ha; o!=NULL; o=o->next)

    {

    printf("%d", o->val);

    if(o->next!=NULL) printf(" -> ");

    }

    printf("\n\n");

    //打印合并前的链表B

    printf("链表B: HB -> ");

    for(o=hb; o!=NULL; o=o->next)

    {

    printf("%d", o->val);

    if(o->next!=NULL) printf(" -> ");

    }

    printf("\n\n");

    //合并两个有序链表A和B为递减有序表C

    hc=merge_link(ha, hb);

    //打印并删除合并后的链表C

    printf("链表C: HC -> ");

    for(; hc!=NULL;)

    {

    printf("%d", hc->val);

    if(hc->next!=NULL) printf(" -> ");

    //删除C表的第一个节点

    o=hc; hc=hc->next; delete o;

    }

    printf("\n\n");

    return 0;

    }

    //定义链表生成函数

    struct node * creat_link()

    {

    //声明链表头指针以及临时变量val

    int val;

    struct node * head=NULL, * p;

    //采用头插法创建递增有序的链表

    printf("\n请按递减序列输入各元素值,回车间隔,-1结束:\n");

    for(;;)

    {

    //读入新的元素值

    fflush(stdin); scanf("%d", &val);

    //当元素值为-1时创建过程结束

    if(val==-1) break;

    //生成新节点,赋值为val

    p=new struct node; p->val=val;

    //将节点p头插至链表

    p->next=head; head=p;

    }

    //返回所创建的链表头指针

    return head;

    }

    //定义链表合并函数

    struct node * merge_link(struct node * first_link, struct node * second_link)

    {

    //声明链表头指针以及临时指针变量q

    struct node * result_link=NULL, * q;

    //当A表和B表都不为空时

    for(;first_link!=NULL && second_link!=NULL;)

    {

    //如果B表的第一个数据节点数值较小

    if(first_link->val>second_link->val)

    {

    q=second_link;//q指向B表的第一个节点

    second_link=q->next;//将节点q从B表中逻辑删除

    }

    else//如果A表的第一个数据节点数值较小

    {

    q=first_link;//q指向A表的第一个节点

    first_link=q->next;//将节点q从A表中逻辑删除

    }

    q->next=result_link; result_link=q;//将节点q头插至表C

    }

    //当A表不为空时

    for(;first_link!=NULL;)

    {

    q=first_link;//q指向A表的第一个节点

    first_link=q->next;//将节点q从A表中逻辑删除

    q->next=result_link; result_link=q;//将节点q头插至表C

    }

    //当B表不为空时

    for(;second_link!=NULL;)

    {

    q=second_link;//q指向B表的第一个节点

    second_link=q->next;//将节点q从B表中逻辑删除

    q->next=result_link; result_link=q;//将节点q头插至表C

    }

    //返回合并的链表头指针

    return result_link;

    }

    运行时出现“

    fatal error C1083: Cannot open include file: *stdafx.h*: No such file or directory

    执行 cl.exe 时出错.

    ” 这个东西 是什么情况?

    更多相关内容
  • 匿名用户 1级 2017-12-26 回答 #include #include #include #defineOVERFLOW -2 #define OK 1 #define ERROR 0 #defineLIST_INIT_... } } 这个是我最近编写的 顺序表也是线性表的 这里还有链表的程序 用的话再传给你

    匿名用户

    1级

    2017-12-26 回答

    #include

    #include

    #include

    #defineOVERFLOW -2

    #define OK 1

    #define ERROR 0

    #defineLIST_INIT_SIZE 100

    #defineLISTINCREMENT 10

    typedef intElemType;

    typedef intStatus;

    //定义顺序存储结构

    typedef struct

    {

    ElemType *elem;

    int length;

    int listsize;

    }SqList;

    //初始化顺序表

    StatusInitList_Sq(SqList &L)

    {

    L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));

    if(!L.elem ) exit(ERROR);

    L.length =0;

    L.listsize =LIST_INIT_SIZE;

    return OK;

    }

    //自定义创建顺序表

    voidCreate_SqList(SqList &L)

    {

    int c,i=0;

    int *newBase;

    printf("请输入顺序表元素:\n");

    while((scanf("%d",&c))!=EOF)

    {

    if(i>=L.listsize) //自定义顺序表大小超过初始化大小

    {

    newBase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));

    //为初始顺序表以LISTINCREMENT大小重新增加存储空间

    if(!newBase)exit(OVERFLOW);

    L.elem=newBase;

    L.listsize+=LISTINCREMENT;

    }

    L.elem[i++]=c;

    }

    L.length=i;

    printf("输入的顺序表元素:\n");

    for(i=0;i

    printf("%d ",L.elem[i]);

    printf("\n");

    }

    //在指定位置插入元素

    StatusListInsert(SqList &L,int i,ElemType e)

    {

    ElemType *p,*q,*newbase;

    if(i<1||i>L.length+1)

    {

    printf("插入位置错误\n");

    return(ERROR);

    }

    if(L.length>=L.listsize)

    {

    newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));

    if(!newbase) exit(OVERFLOW);

    L.elem=newbase;

    L.listsize+=LISTINCREMENT;

    }

    if(i==L.length) L.elem[i+1]=e;

    q=&(L.elem[i-1]);

    for(p=&(L.elem[L.length-1]);p>=q;--p)*(p+1)=*p;

    *q=e;

    ++L.length;

    return OK;

    }

    //在指定位置删除元素

    StatusListDelete_Sq(SqList &L,int i,ElemType *e)

    {

    ElemType *p,*q;

    if(i<1||i>L.length+1)

    return ERROR;

    p=&(L.elem[i-1]);

    *e=*p;

    q=L.elem+L.length-1;

    for(++p;p<=q;++p)

    *(p-1)=*p;

    --L.length ;

    return OK;

    }

    void main()

    {

    SqList L;

    int m,n;

    int location,element;

    if(!InitList_Sq(L))

    {

    printf("初始化顺序表失败!\n");

    exit(ERROR);

    }

    Create_SqList(L);

    for(m=0;m<3;m++)

    {

    printf("输入插入位置:");

    scanf("%d",&location);

    while(location>L.length+1||location<1)

    {

    printf("输入位置错误,请重新输入!\n");

    scanf("%d",&location);

    }

    printf("插入元素:");

    scanf("%d",&element);

    if(!ListInsert(L,location,element))

    {

    printf("顺序表插入失败!\n");

    exit(ERROR);

    }

    printf("插入顺序表为:\n");

    for(int i=0;i<=L.length -1;i++)

    {

    printf("%d ",L.elem[i]);

    }

    printf("\n新顺序表一共有%d个元素。\n",L.length);

    }

    for(n=0;n<3;n++)

    {

    printf("输入删除位置:");

    scanf("%d",&location);

    while(location>L.length||location<1)

    {

    printf("输入位置错误,请重新输入!\n");

    scanf("%d",&location);

    }

    if(!ListDelete_Sq(L,location,&element))

    {

    printf("删除错误!\n");

    exit(ERROR);

    }

    printf("被删除的元素为:%d \n",element);

    printf("被删除后的顺序表为:\n");

    for(int j=0;j<=L.length-1;j++)

    {

    printf("%d ",L.elem[j]);

    }

    printf("\n新顺序表一共有%d个元素。\n",L.length);

    }

    }

    这个是我最近编写的 顺序表也是线性表的

    这里还有链表的程序 用的话再传给你

    展开全文
  • 单链表的逆序输出分为两种情况,一种是只逆序输出,实际上不逆序;另一种是把链表逆序。本文就分别实例讲述一下两种方法。具体如下:1.逆序输出实例代码如下:#include#include#includeusing namespace std;typedef ...

    单链表的逆序输出分为两种情况,一种是只逆序输出,实际上不逆序;另一种是把链表逆序。本文就分别实例讲述一下两种方法。具体如下:

    1.逆序输出

    实例代码如下:

    #include

    #include

    #include

    using namespace std;

    typedef struct node{

    int data;

    node * next;

    }node;

    //尾部添加

    node * add(int n, node * head){

    node * t = new node;

    t->data = n;

    t->next = NULL;

    if (head == NULL){

    head = t;

    }

    else if (head->next == NULL){

    head->next = t;

    }

    else{

    node * p = head->next;

    while (p->next != NULL){

    p = p->next;

    }

    p->next = t;

    }

    return head;

    }

    //顺序输出

    void print(node * head){

    node * p = head;

    while (p != NULL){

    cout << p->data << " ";

    p = p->next;

    }

    cout << endl;

    }

    //递归

    void reversePrint(node * p){

    if (p != NULL){

    reversePrint(p->next);

    cout << p->data << " ";

    }

    }

    //栈

    void reversePrint2(node * head){

    stack s;

    while (head != NULL){

    s.push(head->data);

    head = head->next;

    }

    while (!s.empty()){

    cout << s.top() << " ";

    s.pop();

    }

    }

    int main(){

    node * head = NULL;

    for (int i = 1; i <= 5; i++){

    head = add(i, head);

    }

    print(head);

    reversePrint(head);

    reversePrint2(head);

    system("pause");

    return 0;

    }

    逆序输出可以用三种方法: 递归,栈,逆序后输出。最后一种接下来讲到。

    2.单链表逆序

    实例代码如下:

    #include

    #include

    #include

    using namespace std;

    typedef struct node{

    int data;

    node * next;

    }node;

    node * add(int n, node * head){

    node * t = new node;

    t->data = n;

    t->next = NULL;

    if (head == NULL){

    head = t;

    }

    else if (head->next == NULL){

    head->next = t;

    }

    else{

    node * p = head->next;

    while (p->next != NULL){

    p = p->next;

    }

    p->next = t;

    }

    return head;

    }

    //循环

    node * reverse(node * head){

    if (head == NULL || head->next == NULL){

    return head;

    }

    node * p1 = head;

    node * p2 = head->next;

    node * p3 = NULL;

    head->next = NULL;

    while (p2 != NULL){

    p3 = p2;

    p2 = p2->next;

    p3->next = p1;

    p1 = p3;

    }

    head = p1;

    return head;

    }

    void print(node * head){

    node * p = head;

    while (p != NULL){

    cout << p->data << " ";

    p = p->next;

    }

    cout << endl;

    }

    //递归

    node * reverse2(node * p){

    if (p == NULL || p->next == NULL){

    return p;

    }

    node * newHead = reverse2(p->next);

    p->next->next = p;

    p->next = NULL;

    return newHead;

    }

    int main(){

    node * head = NULL;

    for (int i = 1; i <= 5; i++){

    head = add(i, head);

    }

    print(head);

    head = reverse(head);

    print(head);

    head = reverse2(head);

    print(head);

    system("pause");

    return 0;

    }

    这里链表逆序用了两种方法:循环,递归。读者最容易理解的方法就是在纸上自己画一下。

    希望本文所述实例对大家的数据结构与算法学习能有所帮助。

    展开全文
  • 线性表的链式存储结构

    线性表的链式存储结构

    特点

    • 结点除自身的信息域外,还有表示关联信息的指针域。因此,链式存储结构的存储密度小、存储空间利用率低。
    • 在逻辑上相邻的结点在物理上不必相邻,因此,不可以随机存取,只能顺序存取。
    • 插入和删除操作方便灵活,不必移动结点只需修改结点中的指针域即可。

    为什么叫链表

    为了表示每个数据元素ai与其后继元素之间的逻辑关系,对ai来说,除了存储其本身信息外,还需要一个存储直接后继的位置信息。我们把数据元素信息的域叫做数据域,把存储直接后继位置的域称为指针域。指针域中存储的信息称为指针或者链。这两部分信息组成元素ai的存储映像,称为结点。

    带结点的单链表实现

    • S_LinkList.h文件
    #ifndef S_LinkList
    #define S_LinkList
    /*---------LinkList storage structure----------------*/
    typedef int ElemType;
    typedef struct Node
    {
        ElemType data;/*data field*/
        struct Node * next;/*ptr next*/
    } Node;
    typedef struct Node * LinkList;/*define the LinkList*/
    /*-----------------Init the LinkList------------------*/
    void InitLinkList(LinkList *);
    /*---------------Create the LinkList------------------*/
    void CreateLinkList(LinkList*);
    /*---------------Print the LinkList-------------------*/
    void PrintLinkList(LinkList);
    /*---------------Clear the LinkList-------------------*/
    void ClearLinkList(LinkList);
    /*-------------the length of the LinkList-------------*/
    int LinkListLength(LinkList);
    int IsEmpty(LinkList);
    ElemType GetElem1(LinkList,int);
    int Modify(LinkList *,int,ElemType);
    int ListInsert1(LinkList*,int,ElemType);
    int ListDelete1(LinkList*,int,ElemType*);
    void Reverse(LinkList*);
    #endif
    • .c 文件
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include "S_LinkList.h"
    
    /*implement*/
    void InitLinkList(LinkList *lp)
    {
        *lp=NULL;
        printf("-------->链表初始化<---------\n");
    }
    void CreateLinkList(LinkList *ph)
    {
        LinkList p,r;
        int i,n;
        (*ph)=(LinkList)malloc(sizeof(Node));
        r=(*ph);
        printf("输入创建链表的结点的个数:\n");
        scanf("%d",&n);
        for(i=0;i<n;i++)
        {
            p=(Node*)malloc(sizeof(Node));
            scanf("%d",&p->data);
            r->next=p;//表尾部结点指向新结点
            r=p;//将当前的新节点定义为表尾部结点,实时跟踪
        }
        r->next=NULL;//表示当前链表结束
    }
    
    void PrintLinkList(LinkList ph)
    {
        LinkList tmp=ph->next;
        if(tmp==NULL){
            printf("链表为空!");}
        else
        {
            while (tmp!=NULL)
            {
                printf("%d\t",tmp->data);
                tmp=tmp->next;
            }
            printf("\n打印完成!\n");
        }
    }
    
    void ClearLinkList(LinkList *ph)
    {
        LinkList p,q;
        p=(*ph)->next;
        while (p)
        {
            q=p->next;
            free(p);
            p=q;
        }
        (*ph)->next=NULL;
    }
    
    int LinkListLength(LinkList ph)
    {
        LinkList tmp=ph;
        int length=0;
        if(tmp->next=NULL)
        {
            length=0;
        }
        else
        {
            while (tmp->next->next!=NULL)
            {
                length++;
            }
            length+=1;
        }
        printf("链表长度%d\n", length);  
        return length;
    }
    int IsEmpty(LinkList ph)
    {
        int status;
    
        if(ph->next==NULL)
        {
            status=1;
            printf("链表为空!\n");
        }
        else
        {
            status=0;
            printf("链表非空!\n");
        }
        return status;
    }
    ElemType GetElem1(LinkList ph,int pos)
    {
        int index=0;
        LinkList tmp=ph->next;//First index nummber.
        if(pos<1)
        {
            printf("pos值不合法!\n");
            return 0;
        }
        if(tmp==NULL)
        {
            printf("链表为空!\n");
            return 0;
        }
        while (tmp!=NULL)
        {
            ++index;
            if(index==pos)
            {
                break;
            }
            tmp=tmp->next;
        }
        if(index<pos)
        {
            printf("超出索引范围!");
            return 0;
        }
        return tmp->data;
    }
    int Modify(LinkList *ph,int pos,ElemType e)
    {
        LinkList tmp;
        int index;
        tmp=(*ph)->next;
        if(pos<1)
        {
            printf("这个位置不合法!\n");
            return 0;
        }
        if(tmp==NULL)
        {
            printf("链表为空!\n");
            return 0;
        }
        while(tmp!=NULL)
        {
            ++index;
            if(index==pos)
            {
                break;
            }
            tmp=tmp->next;
        }
        if(index<pos)
        {
            printf("这个位置不合法!\n");
            return 0;
        }
    
        tmp->data=e;
        printf("Modify后第%个数修改为%d!\n",index,tmp->data);
        return 1;
    }
    int ListInsert1(LinkList *ph,int pos,ElemType e)
    {
        int index;
        LinkList p,s;//p signed as HeadLink and s is a new Link that will be added.
        p=(*ph);
        index=1;
        while (p&&index<pos)
        {
            p=p->next;
            index++;
        }
        if(!p||index>pos)
        {
            return 0;
        }
        s=(LinkList)malloc(sizeof(Node));
        s->data=e;
        s->next=p->next;
        p->next=s;
        printf("成功插入元素%d与%位置!\n",s->data,index);
        return 1;
    }
    int ListDelete1(LinkList *ph,int pos,ElemType *e)
    {
        int index;
        LinkList p,q;
        p=(*ph);
        index=1;
        while (p->next&&index<pos)
        {
            p=p->next;
            index++;
        }
        if(!(p->next)||index>pos)
        {
            return 0;
        }
        q=p->next;
        p->next=q->next;
        *e=q->data;
        free(q);
        printf("删除的第%d个结点%d成功!\n",pos,*e);
        return 1;
    }
    void Reverse(LinkList *ph)
    {
        //assign it has the head node.
        LinkList q,current,p;
        q=(*ph);
        current=(*ph)->next;
        while (current->next!=NULL)
        {
            p=current->next;
            current->next=p->next;
            p->next=q->next;
            q->next=p;
        }
        printf("逆序链表完成!\n");
    }
    • 调试结果
    #include <stdlib.h>
    #include <stdio.h>
    #include "S_LinkList.h"
    
    int main()
    {
        LinkList p;
        InitLinkList(&p);
        CreateLinkList(&p);
        PrintLinkList(p);
        system("pause");
        return 0;
    }

    如果有什么可以交流的欢迎大家留言一起探讨。

    展开全文
  • C语言实现--逆序创建链表(头插法)
  • /********************************************************************** ... 编写程序,实现线性表的就地逆置(习题集P18 2.21, 2.22)。 最后修改日期:2019年10月19日 *********************************
  • 链表基础3(超简单)–单链表的逆序 链表基础4(超简单)–创建一个长度为n的双向链表(代码可运行) 链表基础5(超简单)–链表写入文件 链表:是一种链式存储结构,链表每个节点的空间并不是连续的,而是通过指针把...
  • 某个数】 排序:升序/降序/逆序排列 统计个数(分类处理) 删除某个元素 首字母大写 插入(增)某个元素 字符串函数功能实现题目 说明:对于很多题目可能并不需要改变内存中存储情况,只通过控制输出方法就可以AC...
  • } // 随机产生n个元素的值,建立带表头结点的单链线性表L(尾插法) void createlisttail(linklist *l,int n) { int i; linklist p=*l,q;//p实际上记录的是尾节点 srand(time(0)); for(i=0;i { q=(linklist)malloc...
  • 线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素(这些存储单元可以是连续的,也可以不连续)。 因此为了表示每个数据元素与其后继元素之间的逻辑关系,对于数据元素来说,除了储存其本身的...
  • C语言的链表知识做了一个简单的数据库,原理简单,请大佬指导 #include"consts.h" #include<sys\stat.h> #include<io.h> int length = 1; int fangwen = 0; int visit[110] = { 0 }; //定义标记数组...
  • 我们首先用一个结构体定义链表的储存结构,代码如下。.../*-------------线性表的链式储存结构-----------------*/typedefstructLNode{ElemTypedata;structLNode*next;}LNode,*LinkList;typedefintStatus;在链表L...
  • 问题:试写一算法,实现顺序表的就地逆置,即利用原表的存储空间将线性表(a1,a2,...,an)逆置为(an,an-1,...,a1) 算法思想:观察原表和新表顺序,逆置后的线性表是将原表相应位置的元素进行交换,即交换第一个和...
  • /* 链式存储:不要求逻辑上相邻的元素在物理位置上也相邻, 摒弃顺序存储结构上的缺点,但也失去了顺序表...//--------线性表的单链表存储结构--------- #include #include #define OK 1 #define ERROR 0 typedef
  • 2.线性表的就地逆置

    2021-05-23 05:51:47
    #include #include using namespace std; typedef struct node { int num; node* next; }node; int n; int ray[1005]; void array(){ int i; cout<=0;i--){ cout<num=ray[i]; q->... } q-...
  • 一、正确的学习方法 ...2、(1)画图理解(2)记忆核心代码实现 面试常考 二、 3、单链表的逆序输出分为两种情况,一种是只逆序输出,实际上不逆序;另一种是把链表逆序。本文就分别实例讲述一下两种方法。具体...
  • 编写一个函数,取整数值并返回将数字反序的数值。例如,输入7631,函数返回1367。
  • C语言:字符逆序

    2020-12-24 10:30:41
    任务描述 题目描述:输入一个字符串,输出反序后的字符串。 相关知识(略) ...逆序后的字符串 测试说明 样例输入: 123456abcdef 样例输出: fedcba654321 1.gets()函数 #include<stdio.h> ...
  • 链表逆序输出元素,采用单、双向链表实现  逆序输出方法又好几种,个人认为,在不开辟其他空间的条件下,实现的原理都是差不多的(使用链表的情况),其根本就是改变链表头,下面的代码在不开辟其他空间的条件实现...
  • printf("随机数逆序:"); for(i=0;i insertFirstList(&p,a[i]); } traverseList(p); printf("单链表长度:%5d ",sizeList(p)); for(h=p;h!=NULL;h=h->next){ while(deleteValueList(&(h->next),h->data)){ ; } } ...
  • 数据结构C语言实现系列——线性表(单向链表) #include <stdio.h> #include <stdlib.h> #define NN 12 #define MM 20 typedef int elemType ; /********************************...
  • 本文是关于线性表的介绍以及c代码实现(全文仅供参考) 线性表: 定义:有相同属性的数据元素的一个有限序列 结构类型:顺序、链式(单链表,双链表)、索引、散列 顺序存储结构:把线性表中所有元素按照逻辑顺序...
  • /* 基本算法(逆序建表) 循环单链表*/ LoopLinkList CreatLinkList1(int *a) { LoopLinkList L = (LNode*)malloc(sizeof(LNode));//申请一个链表头(空头) L->data = a[0];//给这个表头赋值 L->next = NULL;//...
  • 线性表中的顺序表的实现 也是数据结构中最基础的 1 线性表结构 主要是一个基地址,相当于一个指针,也可以设为一个数组,效果是一样的。 typedef struct List { ElemType *list; //存储空间基地址 int size; //...
  • 双向循环链表的C语言实现 头文件 #include<stdio.h> #include<stdlib.h> //结果函数状态代码 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define ...
  • 线性表逆序链表使用Java实现实现思路和C语言中的实现思路一模一样,不赘述;和顺序链表不同的是,逆序链表不需要“尾指针”,这样就少了tail节点的定义;另外逆序链表中的head节点不能存储数据,它用来引导每个...
  • linklist.c //函数的具体实现,可根据自己的需要适当的添加 或 修改函数 #include "linklist.h" linklist list_create() //单链表的创建 { linklist H; if((H=(linklist)malloc(sizeof(listnode)))==NULL) { ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,168
精华内容 467
关键字:

c语言实现线性表逆序