JSRUN 用代码说话
涁维
brainstorm
JSRUN的第31908位用户
加入于 2020-07-03
上次活跃 2020-08-11



/*
3.给出两个 非空 的链表用来表示两个非负的整数。其中,它们各自的位数是按照 逆序 的方式存储的,并且它们的每个节点只能存储 一位 数字。如果,我们将这两个数相加起来,则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外,这两个数都不会以 0 开头。

示例:
输入:(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出:7 -> 0 -> 8
原因:342 + 465 = 807

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };

struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2){

}
*/

#include<stdio.h>
#include<stdlib.h>
int main(){//主程序开始

    //设定链表
    struct ListNode{
        int val;
        struct ListNode *next;
    };

    struct ListNode Head1,Head2,*p2;

    //输入程序开始
    struct ListNode* input(struct ListNode* head){
        //输出“需要输入多少个数字”
        printf("需要输入多少个数字:");
        //输入需要多少个数字
        int n;
        scanf("%d",&n);
        printf("\n请输入反序后的数字(间隔输入):");
        //循环开始
        for(int i=1;i<=n;i++){//for循环语句
            //分配新空间给后指针
            p2=(struct ListNode*)malloc(sizeof(struct ListNode*));
            //把现指针指向后指针
            head->next=p2;
            //输入现指针的数值
            scanf("%d",head->val);
            //把现指针指向的指针变成现指针
            head=head->next;
        }//循环结束
        //把最后一个指向空指针
        head->next=NULL;
        printf("\n");
    }//输入程序结束
    
    //输出函数开始
    struct ListNode* output(struct ListNode* head){
        //如果现指针是空指针就中止函数
        if(head==NULL)return 0;
        //循环开始
        while(head->next!=NULL){//判断后指针是不是空指针,如果是就停止循环
            //输出现指针数值
            printf("%d->",head->val);
            //把现指针指向的指针变成现指针
            head=head->next;
        }//循环结束
        //输出最后一个数值
        printf("%d",head->next);
    }//输出函数结束

    struct ListNode* carryaddition(struct ListNode* head){
        head
        p2=(struct ListNode*)malloc(sizeof(struct ListNode*));
        head->next=p2;
    }

    //相加函数开始
    struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2){
        //如果现指针都是空指针就终止函数,如果其中一个是空指针就分配新空间给空指针,如果都不是空指针就继续函数
        if(l1==NULL||l2==NULL){
            if(l1==NULL){
                l1=(struct ListNode*)malloc(sizeof(struct ListNode*));
            }
            if(l2==NULL){

            }
        }
        //现指针数字相加如果大于等于10或大于9,如果现指针指向空指针,就分配新空间给后指针就下一个数字加一这一个数字减10,
        if(l1->val+l2->val>=10){
            if(l1->next==NULL){

            }
            else 
        }
        //把现指针指向的指针变成现指针
        l1=l1->next;l2=l2->next;
    }//相加函数结束

    //输入
    printf("现在输入第一个链表\n");input(&Head1);printf("现在输入第二个链表\n");input(&Head2);
    //输出
    printf("(");output(&Head1);printf(")+(");output(&Head2);printf(")");
}//主程序结束
brainstorm (涁维 )- 2020-08-11 0 人
3.给出两个 非空 的链表用来表示两个非负的整数。...
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
int main(){//主函数开始
    //设定单链表
    struct ListNode {
        int val;
        struct ListNode *next;
    };

    struct ListNode Head,*p0,*p1,*p2;//head是头指针,p0是前指针,p1是现指针,p2是后指针

    Head.val=-1;
    Head.next=NULL;
    //deleteDuplicate函数开始
    struct ListNode* deleteDuplicates(struct ListNode* head){
        //最多n次循环,冒泡对比,有一个是内层的循环,有一个外层循环,外层循环执行的是录入n次,内层执行的是检测和前指向后
        //把头指针变成前指针和现指针
        p0=head;
        p1=head;
        //循环开始
        while(1){
            while(1){//内循环开始
                //如果现指针的数值与头指针一样就把前指针指向现指针指向的指针,前指针不变
                if(head->val==p1->val){
                    p0->next=p1->next;
                    //printf("Testsame\n");

                }
                //如果不一样就把现指针变成前指针,
                else{
                    p0=p1;
                    //printf("Testinsame\n");
                }
                //如果现指针指向的指针是空指针就终止内层循环
                if(p1->next==NULL){//printf("Testbreak\n");
                break;}
                //把现指针指向的指针变成现指针
                p1=p1->next;
                /**
                //把现指针指向的指针变成现指针
                p1=p1->next;
                //如果现指针是空指针就终止内层循环
                if(p1==NULL){//printf("Testbreak\n");
                break;}
                **/

            }//内循环结束
            //如果头指针指向的指针是空指针就终止循环
            if(head->next==NULL){break;}
            //把头指针指向的指针变成头指针
            head=head->next;

        }//循环结束
    }//deleteDuplicates函数结束

    //inputList函数开始
    struct ListNode* inputList(struct ListNode* head){
        //需要输入n个数字
        int n=0;
        printf("Please enter how many number do you want to:");
        scanf("%d",&n);
        //循环n-1次
        for(int i=1;i<=n-1;i++){
            //分配新空间给后指针
            p2=(struct ListNode*)malloc(sizeof(struct ListNode));
            //让现指针指向后指针
            head->next=p2;//printf("->");
            //输入现指针的数值
            scanf("%d ",&head->val);//printf("->");
            //让现指针指向的指针变成现指针
            head=head->next;
            //printf("->");
        }
        //最后一次输入数字
        scanf("%d",&head->val);
        head->next=NULL;
    }//inputList函数结束

    //outputList函数开始
    struct ListNode* outputList(struct ListNode* head){
        while(1){
            //判断现指针指向的指针是不是空指针,如果是就终止循环
            if(head->next==NULL)break;
            //输出现指针的数字
            printf("%d->",head->val);
            //把现指针指向的指针变成现指针
            head=head->next;
        }
        //输出最后一个数值
        printf("%d\n",head->val);
    }
    //outputList函数结束

    inputList(&Head);outputList(&Head);
    deleteDuplicates(&Head);outputList(&Head);

}//主函数结束
brainstorm (涁维 )- 2020-08-08 0 人
2.给定一个排序链表,删除所有重复的元素,使得每个...
//2020年8月6日22点45分
#include<stdio.h>
#include<stdlib.h>
int main(){//主函数开始
    struct ListNode{
        int num;
        struct ListNode*next;
    }Head,*p0,*p1,*p2;//Head是头地址,p0是前指针,p1是现指针,p2是后指针
    
    Head.num=0;
    Head.next=NULL;

    //create list函数开始
    struct ListNode* createList(struct ListNode* p1, int n){
        //进行n个循环
        for(int i=1;i<=n;i++){
            //赋值给现指针
            p1->num=i;
            //分配新空间给后指针
            p2=(struct ListNode*)malloc(sizeof(struct ListNode*));
            //把现指针指向后指针
            p1->next=p2;
            //把后指针变成现指针
            if(i<=4)p1=p2;            
        }//循环结束

        //最后一个指针指向空
        p1->next=NULL;//现指针指向后指针后把后指针变成空指针不会让现指针指向空指针而是会输出0
    }//函数结束

    //reverse list函数开始
    struct ListNode* reverseList(struct ListNode* head){
        //把空指针变成前指针,head指针变成现指针,现指针指向的指针变成后指针
        p0=NULL;
        p1=head;
        p2=head->next;

        //循环开始
        while(1){
            //把现指针指向前指针
            p1->next=p0;

            //检测后指针是不是空指针,如果是就终止循环
            if(p2==NULL){break;}

            //把现指针变成前指针,后指针变成现指针,后指针指向的指针变成后指针
            p0=p1;
            p1=p2;
            p2=p2->next;
        }//循环结束
    }//函数结束

    //output list
    struct ListNode* outputList(struct ListNode* head){
        
        while(1){

            //检测现指针是否为空指针,如果是就终止循环
            if(head==NULL)break;
            //把现指针数值输出
            printf("%d->",head->num);
            //把现指针变为后指针
            head=head->next;
        }
        printf("NULL\n");
    }

    //create and output list
    createList(&Head,5);outputList(&Head);

    //reverse and output list  
    reverseList(&Head);outputList(p1);//把reverseList后的现指针交给outputlist
}//主函数结束
brainstorm (涁维 )- 2020-08-07 0 人
重新测试链表

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

int main(){
    struct List{
        int num;
        struct List *next;
    }*Head,*Last,*p0,*p1,*p2;

    //create list
    for(p1=Head=NULL;p2->number!=5;){
        p2=(struct List *)malloc(sizeof(struct List));
        p1->Next=p2;
        p2->number=p1->number+1;
        p2->Next=NULL;
        Last=p2=p1;
    }
    
    //output
    for(p1=Head,p2=p1->Next;p1->Next!=NULL;){//p2!=NULL
    
        if(p1->Next==NULL){printf("NULL");break;}
        else {printf("%d->",p1->number);}
        p1=p2;
        p2=p2->Next;
    }
}
brainstorm (涁维 )- 2020-08-01 0 人
结构体的测试学习
//带表头结点的单向链表
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <time.h>
struct NODE {
    int          data;
    struct NODE *next;
} H,*head,*p,*q,*s1,*s2,*s3,*s4,*s;
int i,j,k,n,t,m;
int main() {
    srand(time(NULL));

    //填写头节点数据
    H.data=-1;
    H.next=NULL;
    head=&H;

    //创建10个节点的单链表
    p=head;
    for (i=0;i<10;i++) {
        q=(struct NODE *)malloc(sizeof(struct NODE));
        if (NULL==q) return 1;
        q->data=rand()%100;//填写0..99的随机值
        q->next=NULL;
        p->next=q;
        p=q;
    }

    //输出整个单链表
    s=head->next;
    while (1) {
        if (NULL==s) {
            printf("\n");
            break;
        }
        printf("%02d->",s->data);
        s=s->next;
    }

    //将值为5的结点插入到单链表的第k个结点前
    k=3;
    n=0;
    p=head;
    while (1) {
        if (NULL==p) {
            break;
        }
        n++;
        if (k==n) {
            q=(struct NODE *)malloc(sizeof(struct NODE));
            if (NULL==q) return 1;
            q->data=5;
            q->next=p->next;
            p->next=q;
            break;
        }
        p=p->next;
    }

    //输出整个单链表
    s=head->next;
    while (1) {
        if (NULL==s) {
            printf("\n");
            break;
        }
        printf("%02d->",s->data);
        s=s->next;
    }

    //删除第k个节点
    k=5;
    n=0;
    p=head;
    while (1) {
        if (NULL==p) {
            break;
        }
        n++;
        if (k==n) {
            q=p->next;
            if (q) {
                p->next=q->next;
                free(q);
            }
            break;
        }
        p=p->next;
    }

    //输出整个单链表
    s=head->next;
    while (1) {
        if (NULL==s) {
            printf("\n");
            break;
        }
        printf("%02d->",s->data);
        s=s->next;
    }

    //从小到大排序
    for (p=head;p!=NULL && p->next!=NULL;p=p->next) {
        for (q=p->next;q!=NULL && q->next!=NULL;q=q->next) {
            if (p->next->data > q->next->data) {

                //交换data
//              printf("swap %02d %02d\n",p->next->data,q->next->data);
//              t=p->next->data;p->next->data=q->next->data;q->next->data=t;

                //或者

                //交换next
//              printf("swap %02d %02d\n",p->next->data,q->next->data);
                s1=p->next;
                s2=p->next->next;
                s3=q->next;
                s4=q->next->next;

                if (s2!=s3) {
                     p->next=s3;
                    s3->next=s2;
                     q->next=s1;
                    s1->next=s4;
                } else {
                     p->next=s3;
                    s3->next=s1;
                           q=s3;
                    s1->next=s4;
                }

                //输出整个单链表
//              s=head->next;
//              while (1) {
//                  if (NULL==s) {
//                      printf("\n");
//                      break;
//                  }
//                  printf("%02d->",s->data);
//                  s=s->next;
//              }
//              getchar();
            }
        }
    }

    //输出整个单链表
    s=head->next;
    while (1) {
        if (NULL==s) {
            printf("\n");
            break;
        }
        printf("%02d->",s->data);
        s=s->next;
    }

    //将单链表中前 m 个结点和后 n 个结点进行互换,m+n为链表总长10
    m=4;
    n=6;
    k=0;
    p=head;
    while (1) {
        if (NULL==p) {
            break;
        }
        k++;
        if (m+1==k) {
            q=p;
        }
        s=p;
        p=p->next;
    }
    s1=head->next;
    head->next=q->next;
    s->next=s1;
    q->next=NULL;

    //输出整个单链表
    s=head->next;
    while (1) {
        if (NULL==s) {
            printf("\n");
            break;
        }
        printf("%02d->",s->data);
        s=s->next;
    }

    //释放所有节点
    p=head->next;
    while (1) {
        if (NULL==p) {
            break;
        }
        q=p->next;
        free(p);
        p=q;
    }

    return 0;
}
//18->94->58->17->27->20->43->57->75->78->
//18->94->05->58->17->27->20->43->57->75->78->
//18->94->05->58->27->20->43->57->75->78->
//05->18->20->27->43->57->58->75->78->94->
//43->57->58->75->78->94->05->18->20->27->
//
brainstorm (涁维 )- 2020-08-06 0 人
反转一个单链表。原学习
//带表头结点的单向链表
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>=
struct NODE {
    int          data;
    struct NODE *next;
} H,*head,*p,*q,*s1,*s2,*s3,*s4,*s;
int i,j,k,n,t,m;
int main() {

    //填写头节点数据
    H.data=-1;
    H.next=NULL;
    p=head=&H;

    //创建10个节点的单链表
    //p=head;
    for (i=0;i<5;i++) {
        q=(struct NODE *)malloc(sizeof(struct NODE));
        if (NULL==q) return;
        q->data=i+1;
        q->next=NULL;
        p->next=q;
        p=q;
    }

    //输出整个单链表
    s=head->next;
    while (1) {
        if (NULL==s) {
            printf("NULL");
            break;
        }
        printf("%d->",s->data);
        s=s->next;
    }

    return 0;
}
brainstorm (涁维 )- 2020-07-28 0 人
//带表头结点的单向链表
没有了
1/2 下一页