数据结构第二次作业

最新推荐文章于 2021-12-10 10:03:53 发布
最新推荐文章于 2021-12-10 10:03:53 发布
阅读量654 收藏 5
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yhralxq/article/details/52557973
版权
数据结构第二次作业

p143/27

//反转链表的操作
(a)

template <class T>
void chain<T>::reverse()
{
    if (!head)
        return;
    chainNode<T>* p = nullptr;
    chainNode<T>* q = head;
    chainNode<T>* r = head->next;
    while (r)
    {
        q->next = p;
        p = q;
        q = r;
        r = r->next;
    }
    q->next = p;
    head = q;
}

(b)

*复杂度分析

space complexity：
this program needs three extra store space,so its compelxity is O(1).
需要三个额外的存储空间，所以空间复杂度为O(1)

time complexity:
suppose the length of the list is n,fliping each node needs four operations. So the total times is 4*n,therefore the space complexity is O(n)
假设链表的长度为n，反转每一个节点需要操作四次（根据while循环中的代码），所以反转整个链表的操作次数是4*n，所以空间复杂度是O(n)

(c)
测试见最后整个的代码

p143/28
(a)

template <class T>
void reverse2(chain<T>& A, chain<T>& B)
{

    while (B.gethead())
    {
        B.erase(1);
    }
    chainNode<T>* pp = A.gethead();

    while (pp)
    {
        chainNode<T>* pp3 = new chainNode<T>;
        pp3->data = pp->data;
        pp3->next = B.gethead();
        B.sethead(pp3);
        pp = pp->next;
    }
}

(b)

复杂度分析

根据代码，可知复杂度是O(n)
(c)
最后见总的代码

p143/29
//合并两个链表
(a)

template <class T>
void chain<T>::Alternate(chain<T>& A, chain<T>& B)
{
    while (this->head)
    {
        erase(1);
    }
    //int min = A.size < B.size ? A.size : B.size;

    chainNode<T>* pp1 = A.head;
    chainNode<T>* pp2 = B.head;
    chainNode<T>* pp3;
    int k = 1;
    while (pp1&&pp2)
    {
        pp3 = new chainNode<T>;
        pp3->data = pp1->data;
        pp3->next = nullptr;

        if (k == 1)
        {
            this->head=this->last= pp3;
            k++;
        }
        else
        {
            last->next = pp3;
            last = last->next;
        }

        pp3 = new chainNode<T>;
        pp3->data = pp2->data;
        pp3->next = nullptr;
        last->next = pp3;
        last = last->next;


        pp1 = pp1->next;
        pp2 = pp2->next;
    }
    while (pp1)
    {
        pp3 = new chainNode<T>;
        pp3->data = pp1->data;
        pp3->next = nullptr;

        if (k == 1)
        {
            this->head=this->last = pp3;
            k++;
        }
        else
        {
            last->next = pp3;
            last = last->next;
        }
        pp1 = pp1->next;
    }
    while (pp2)
    {
        pp3 = new chainNode<T>;
        pp3->data = pp2->data;
        pp3->next = nullptr;

        if (k == 1)
        {
            this->head=this->last = pp3;
            k++;
        }
        else
        {
            last->next = pp3;
            last = last->next;
        }
        pp2 = pp2->next;
    }

}

(b)

复杂度分析

space complexity
In this program, we will use four extra variables ,So the space complexity is O(1)
在这个程序中，我们用四个额外的变量，所以程序的空间复杂度为O(1)

time complexity
when deleting the elements in list C,the time complexity is O(1),when traversing the list called A&B,time complexity is O(n)
so the total time comlexity is O(n);
当我们删除链表C中的元素时，时间复杂度是O(n),当我们遍历链表A和B 时，我们需要的时间复杂度仍然是O(n),所以总的时间复杂度是O（n）

(c)
测试见最后给出的总代码

p144/31
(a)

template <class T>
void Merge(chain<T>& A, chain<T>& B,chain<T>& C)
{
    while (C.gethead())
    {
        C.erase(1);
    }
    chainNode<T>* pp1 = A.gethead();
    chainNode<T>* pp2 = A.gethead();
    while (pp1&&pp2)
    {
        if (pp1->data < pp2->data)
        {
            C.append(pp1->data);
            pp1 = pp1->next;
        }
        else
        {
            C.append(pp2->data);
            pp2 = pp2->next;
        }
    }
    while (pp1)
    {
        C.append(pp1->data);
        pp1 = pp1->next;
    }
    while (pp2)
    {
        C.append(pp2->data);
        pp2 = pp2->data;
    }

}

(b)

复杂度分析

空间复杂度为O(n);
时间复杂度为O(n);

p144/32
(a)

template <class T>
void chain<T>::Merge(chain<T>& A, chain<T>& B)
{
    while (this->head)
    {
        erase(1);
    }
    this->head = this->last = nullptr;
    //chainNode<T>* pp = this->head;
    chainNode<T>* pp1 = A.head;
    chainNode<T>* pp2 = B.head;
    chainNode<T>* pp3;
    int k = 1;
    while (pp1&&pp2)
    {
        if (pp1->data < pp2->data)
        {
            pp3 = new chainNode<T>;
            pp3->data = pp1->data;
            pp3->next = nullptr;
            pp1 = pp1->next;
            if (k == 1)
            {
                this->head =this->last= pp3;
                k++;
            }
            else
            {
                last->next = pp3;
                last = last->next;
            }
        }
        else
        {
            pp3 = new chainNode<T>;
            pp3->data = pp2->data;
            pp3->next = nullptr;
            pp2 = pp2->next;
            if (k == 1)
            {
                this->head=this->last = pp3;
                k++;
            }
            last->next = pp3;
            last = last->next;
        }
    }
    while (pp1)
    {
        pp3 = new chainNode<T>;
        pp3->data = pp1->data;
        pp3->next = nullptr;
        pp1 = pp1->next;
        if (k == 1)
        {
            this->head = this->last = pp3;
            k++;
        }
        else
        {
            last->next = pp3;
            last = last->next;
        }
    }
    while (pp2)
    {
        pp3 = new chainNode<T>;
        pp3->data = pp2->data;
        pp3->next = nullptr;
        pp2 = pp2->next;
        if (k == 1)
        {
            this->head = this->last = pp3;
            k++;
        }
        last->next = pp3;
        last = last->next;
    }
}

(b)

复杂度分析

time complexity:
The total time that comparision spends is O(n)
The total time that traversing spends is O(n)
so time complexity is O(n)
比较大小所用时间复杂度是O(n),遍历链表时间复杂度是O(n)
所以总的时间复杂度是O(n)
(c)
测试用例见最后总的代码

p144/33
(a)

template<class T>
void split2(chain<T>&A,chain<T>& B, chain<T>& C)
{
    chainNode<T>* p = A.gethead();
    int k = 1;
    while (p)
    {
        if (k % 2)
        {
            B.append(p->data);
            k++;
        }
        else
        {
            C.append(p->data);
            k++;
        }
        p = p->next;
    }
}

(b)
时间复杂度为O（n）

(c)
测试用例见完整代码实现

p144/34
(a)

template <class T>
void chain<T>::split(chain<T>& B, chain<T>& C)
{
    if (!this->head)
        throw "erroe";
    while (B.head)
    {
        erase(1);
    }
    while (C.head)
    {
        erase(1);
    }
    chainNode<T>* p = this->head;
    chainNode<T>* pp = new chainNode<T>;
    pp->next = nullptr;
    pp->data = p->data;
    B.head = B.last = pp;
    if (head->next)
    {
        p = p->next;
        pp = new chainNode<T>;
        pp->next = nullptr;
        pp->data = p->data;
        C.head = C.last = pp;
        p = p->next;
    }
    int k = 1;
    while (p)
    {
        pp = new chainNode<T>;
        pp->data = p->data;
        pp->next = nullptr;
        if (k % 2)
        {
            B.last->next = pp;
            B.last = B.last->next;
            k++;
        }
        else
        {
            C.last->next = pp;
            C.last = C.last->next;
            k++;
        }
        p = p->next;
    }
}

(b)

复杂度分析

新增变量的个数为常数，所以空间复杂度时O(n),时间复杂度和遍历一遍链表所用的时间是同一量级的，所以时间复杂度是O(n)
(c)
实例见所有代码

完整代码
LinkedList.h文件
#pragma once
#include <iostream>
template <class T>
struct chainNode
{
    //数据成员
    T data;
    chainNode* next;
    //方法成员
    chainNode() {};
    chainNode(const T& element)
    {
        data = element;
    }
    chainNode(const T& element, chainNode<T>* nextp)
    {
        data = element;
        next = nextp;
    }
};

template <class T>
class chain
{
public:
    //构造复制构造析构函数
    chain(int initcapacity = 10);
    chain(const chain<T>&  t);
    ~chain();
    //各种ADT 函数
    bool empty()
    {
        return size == 0;
    }
    int lenght()
    {
        return size;
    }
    T& getIndex(int index)const;
    void erase(int index);
    int indexOf(const T& t)const;
    void insert(int index, const T& t);
    void output(std::ostream& os)const;
    void reverse();
    void split( chain<T>& B, chain<T>& C);
    void append(const T& a)
    {
        chainNode<T>* p = new chainNode<T>;
        p->data = a;
        p->next = nullptr;
        if (head == nullptr)
            head = last = p;
        else
        {
            last->next = p;
            last = last->next;
        }
    }
    chainNode<T>* gethead()
    {
        return head;
    }
    chainNode<T>* getlast()
    {
        return last;
    }
    T& getdata()
    {
        return data;
    }
    void sethead(chainNode<T>* header)
    {

        header->next = head;
        chainNode<T>* pp = head;
        head = header;
        if(!pp)
        delete pp;
    }

    void Alternate(chain<T>& A, chain<T>& B);
    void Merge(chain<T>& A, chain<T>& B);
private:
    int size;
    chainNode<T>* head;
    chainNode<T>* last;
};


//这是一个迭代器，虽然没有什么用没有用！！！！！！
/*
template <class>
class chaininter
{
private:
    chainNode<T>* location;
public:
    T* Init(const chain<T>& c)
    {
        location = c.head;
        if (location)
            return &location;
        return -1;
    }
    T* next()
    {
        if (!location)
            return -1;
        location = location->next;
        if (location)
            return &location;
        return -1;
    }

};
*/


//1构造函数
template <class T>
chain<T>::chain(int initcapacity)
{
    if (initcapacity < 1)
        throw "the lenght is not right";
    head = nullptr;
    size = 0;

}


//2复制构造函数
template <class T>
chain<T>::chain(const chain<T>& t)
{
    size = t.size;
    if (t.head == nullptr)
    {
        head = nullptr;
        return;
    }
    chainNode<T>* p = t.head;
    head = new chainNode<T>;
    head->data = p->data;
    p = p->next;
    chainNode<T>* pp = head;
    while (p != nullptr)
    {
        pp->next = new chainNode<T>
        pp->next->data = p->data;
        p = p->next;
     }
    pp->next = nullptr;
}


//3析构函数
template <class T>
chain<T>::~chain()
{
    while (head!=nullptr)
    {
        chainNode<T>* p = head->next;
        delete head;
        head = p;
    }
}


//4得到索引为index的元素
template <class T>
T&  chain<T>:: getIndex(int index)const
{
    if (index<=0 || index>size)
        throw "there is an error occur";
    chainNode<T>* p = head;
    for (int i = 1; i < index; i++)
        p = p->next;
    return p->data;
}


//5删除链表的某一个元素
template <class T>
void chain<T>::erase(int index)
{
    if (index <= 0 || index > size)
        return;
    if (index == 1)
    {
        chainNode<T>* hh = head;
        head = head->next;
        delete hh;
        size--;
        return;
    }
    chainNode<T>* pp = head;
    for (int i = 1; i < index - 1; i++)
        pp = pp->next;
    chainNode<T>* hh = pp->next;
    pp->next = hh->next;
    delete hh;
    size--;
}

//6找到某个特定元素的次序
template <class T>
int chain<T>::indexOf(const T& t)const
{
    chainNode<T>* hh = head;
    int len = 1;
    while (hh != nullptr&&hh->data != t)
    {   
        hh = hh->next;
        len++;
    }
    if (hh == nullptr)
        return -1;
    return len;
}

//7将t插入到index个元素的后面
template <class T>
void chain<T>::insert(int index, const T& t)
{
    if (index <0 || index > size)
        throw "the index is not correct";
    chainNode<T>* p = new chainNode<T>;
    p->data = t;
    p->next = nullptr;
    if (index == 0)
    {
        p->next = head;
        head = p;

    }
    else
    {
        chainNode<T>* q = head;
        for (int i = 1; i <index; i++)
            q = q->next;
        p->next = q->next;
        q->next = p;
    }
    size++;
}


//输出所有的元素
template <class T>
void chain<T>::output(std::ostream& os)const
{
    for (chainNode<T>* p = head; p != nullptr; p = p->next)
        os << p->data<<" ";
}

//这个是输出所有元素
template <class T>
std::ostream& operator<<(std::ostream& os, chain<T>& aim)
{
    aim.output(os);
    return os;
}


//反转链表的操作
template <class T>
void chain<T>::reverse()
{
    if (!head)
        return;
    chainNode<T>* p = nullptr;
    chainNode<T>* q = head;
    chainNode<T>* r = head->next;
    while (r)
    {
        q->next = p;
        p = q;
        q = r;
        r = r->next;
    }
    q->next = p;
    head = q;
}

template <class T>
void reverse2(chain<T>& A, chain<T>& B)
{

    while (B.gethead())
    {
        B.erase(1);
    }
    chainNode<T>* pp = A.gethead();
    /*
    chainNode<T>* pp2=new chainNode<T>;
    pp2->data = pp->data;
    B.head = pp2;
    B.head->next = nullptr;
    pp = pp->next;
    */
    while (pp)
    {
        chainNode<T>* pp3 = new chainNode<T>;
        pp3->data = pp->data;
        pp3->next = B.gethead();
        B.sethead(pp3);
        pp = pp->next;
    }
}


//这个还是没有完成77
template <class T>
void chain<T>::Alternate(chain<T>& A, chain<T>& B)
{
    while (this->head)
    {
        erase(1);
    }
    //int min = A.size < B.size ? A.size : B.size;

    chainNode<T>* pp1 = A.head;
    chainNode<T>* pp2 = B.head;
    chainNode<T>* pp3;
    int k = 1;
    while (pp1&&pp2)
    {
        pp3 = new chainNode<T>;
        pp3->data = pp1->data;
        pp3->next = nullptr;

        if (k == 1)
        {
            this->head=this->last= pp3;
            k++;
        }
        else
        {
            last->next = pp3;
            last = last->next;
        }

        pp3 = new chainNode<T>;
        pp3->data = pp2->data;
        pp3->next = nullptr;
        last->next = pp3;
        last = last->next;


        pp1 = pp1->next;
        pp2 = pp2->next;
    }
    while (pp1)
    {
        pp3 = new chainNode<T>;
        pp3->data = pp1->data;
        pp3->next = nullptr;

        if (k == 1)
        {
            this->head=this->last = pp3;
            k++;
        }
        else
        {
            last->next = pp3;
            last = last->next;
        }
        pp1 = pp1->next;
    }
    while (pp2)
    {
        pp3 = new chainNode<T>;
        pp3->data = pp2->data;
        pp3->next = nullptr;

        if (k == 1)
        {
            this->head=this->last = pp3;
            k++;
        }
        else
        {
            last->next = pp3;
            last = last->next;
        }
        pp2 = pp2->next;
    }

}
template <class T>
void Merge(chain<T>& A, chain<T>& B,chain<T>& C)
{
    while (C.gethead())
    {
        C.erase(1);
    }
    chainNode<T>* pp1 = A.gethead();
    chainNode<T>* pp2 = A.gethead();
    while (pp1&&pp2)
    {
        if (pp1->data < pp2->data)
        {
            C.append(pp1->data);
            pp1 = pp1->next;
        }
        else
        {
            C.append(pp2->data);
            pp2 = pp2->next;
        }
    }
    while (pp1)
    {
        C.append(pp1->data);
        pp1 = pp1->next;
    }
    while (pp2)
    {
        C.append(pp2->data);
        pp2 = pp2->data;
    }

}


template <class T>
void chain<T>::Merge(chain<T>& A, chain<T>& B)
{
    while (this->head)
    {
        erase(1);
    }
    this->head = this->last = nullptr;
    //chainNode<T>* pp = this->head;
    chainNode<T>* pp1 = A.head;
    chainNode<T>* pp2 = B.head;
    chainNode<T>* pp3;
    int k = 1;
    while (pp1&&pp2)
    {
        if (pp1->data < pp2->data)
        {
            pp3 = new chainNode<T>;
            pp3->data = pp1->data;
            pp3->next = nullptr;
            pp1 = pp1->next;
            if (k == 1)
            {
                this->head =this->last= pp3;
                k++;
            }
            else
            {
                last->next = pp3;
                last = last->next;
            }
        }
        else
        {
            pp3 = new chainNode<T>;
            pp3->data = pp2->data;
            pp3->next = nullptr;
            pp2 = pp2->next;
            if (k == 1)
            {
                this->head=this->last = pp3;
                k++;
            }
            last->next = pp3;
            last = last->next;
        }
    }
    while (pp1)
    {
        pp3 = new chainNode<T>;
        pp3->data = pp1->data;
        pp3->next = nullptr;
        pp1 = pp1->next;
        if (k == 1)
        {
            this->head = this->last = pp3;
            k++;
        }
        else
        {
            last->next = pp3;
            last = last->next;
        }
    }
    while (pp2)
    {
        pp3 = new chainNode<T>;
        pp3->data = pp2->data;
        pp3->next = nullptr;
        pp2 = pp2->next;
        if (k == 1)
        {
            this->head = this->last = pp3;
            k++;
        }
        last->next = pp3;
        last = last->next;
    }
}

template<class T>
void split2(chain<T>&A,chain<T>& B, chain<T>& C)
{
    chainNode<T>* p = A.gethead();
    int k = 1;
    while (p)
    {
        if (k % 2)
        {
            B.append(p->data);
            k++;
        }
        else
        {
            C.append(p->data);
            k++;
        }
        p = p->next;
    }
}

template <class T>
void chain<T>::split(chain<T>& B, chain<T>& C)
{
    if (!this->head)
        throw "erroe";
    while (B.head)
    {
        erase(1);
    }
    while (C.head)
    {
        erase(1);
    }
    chainNode<T>* p = this->head;
    chainNode<T>* pp = new chainNode<T>;
    pp->next = nullptr;
    pp->data = p->data;
    B.head = B.last = pp;
    if (head->next)
    {
        p = p->next;
        pp = new chainNode<T>;
        pp->next = nullptr;
        pp->data = p->data;
        C.head = C.last = pp;
        p = p->next;
    }
    int k = 1;
    while (p)
    {
        pp = new chainNode<T>;
        pp->data = p->data;
        pp->next = nullptr;
        if (k % 2)
        {
            B.last->next = pp;
            B.last = B.last->next;
            k++;
        }
        else
        {
            C.last->next = pp;
            C.last = C.last->next;
            k++;
        }
        p = p->next;
    }
}
main.cpp文件
// LinkedList.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "LinkedList.h"
#include<iostream>
using namespace std;
int main()
{
    chain<int> list2;
    list2.insert(0, 6);
    list2.insert(0, 4);
    list2.insert(0, 2);
    list2.insert(0, 1);
    list2.insert(0, 3);
    list2.insert(0, 5);
    cout << list2 << endl;

    chain<int> list3;
    chain<int> list4;
    split2(list2,list3,list4);
    cout << list3 << endl;
    cout << list4 << endl;

}
yhralxq
关注
专栏目录
数据结构第二次
sgerll的博客
10-16 290
数据结构第二次作业 二分
London_lj的专栏
11-05 1053
首先是我自己的想法，
数据结构作业2版
lihao1875699404的博客
09-05 106
数据结构作业2版 //做到一半就懵了，有bug不想改了 #include<stdio.h> #include<stdlib.h> #include <string.h> //只做了加减，越想越炸，边查边问给搞出来的，懵了已经 typedef struct acc{ int *da; // 第一个为小数部分 后面为整数部分 应该是一个数组 int len; //da的数据个数 }acc; //字符转整数 int chrToInt(char *a,int q
211549229林子斌数据结构第二次作业.rar
09-13
这个名为"211549229林子斌数据结构第二次作业.rar"的压缩文件很可能是林子斌同学在学习数据结构课程时完成的第二次作业。虽然没有具体的标签来指示作业的具体内容，但我们可以根据常见的数据结构课程内容来推测可能...
数据结构上机第二次答案
10-01
在本场景中，我们关注的是大连理工大学数据结构课程的第二次上机实验，重点涉及顺序栈和顺序队列的实现。这些是两种基本的数据结构，对于理解和掌握更复杂的算法至关重要。 顺序栈是一种线性数据结构，其中元素按照...
西南交通大学-zhy-数据结构第5次作业.zip
12-22
数据结构;赵宏宇;一、查找 1. 算法设计题 ：已知n元顺序表a0, a1, … , an-1按关键字递增有序存储。给定关键字值key，编写算法用对分查找求下标i，满足ai-1且aikey。 2. 编程题：输入n个两两互不相等的整数，以...
西南交通大学-数据结构第4次作业
最新发布
10-27
(2) 用先序遍历法建立二叉树二叉链表存储结构(结点数据域类型为char，输入字符序列用字符'#'表示NULL)，实现中序线索化，并用非递归算法输出中序遍历结果的正序和逆序序列。 二、图 1. 已知某无向图如下图所示。画出...
西南交通大学-数据结构第3次作业
10-27
习题集 5.1 5.5 5.7 5.10 上机编程题 习题集5.19 二、二叉树（一） 1. 写算法 (1) 已知二叉树（二叉链表）根结点指针为...(2) 从键盘输入n个数据建立n元完全二叉树顺序存储结构。实现该完全二叉树的先、中、后序遍历。
信号放大器
09-01
信号放大器，可以用于信号传输，扩大信号传输的距离，不失真。
数据结构第二次笔记
qq_43238335的博客
09-28 264
​一、双链表 1.如果希望快速​确定单链表中任一结点的前驱结点，可以在单链表中再设置一个指向其前驱结点的指针域，这样就形成了双链表。 2.在双链表中，每个结点在存储数据元素的同时，还存储了其前驱元素和后继元素所在结点的地址信息。 双链表的结点定义结构: template<class T> struct​ Node { T data; Node...
大二数据结构第二次总结
qq_43550247的博客
10-09 164
数据结构---模板 1.模板是对具有相同特性的函数或类的再抽象，模板是一种参数化的多态性工具。 2.所谓参数化多态性，是指将程序所处理的对象的类型参数化，使一段程序代码可以用于处理多种不同类型的对象。 3.采用模板编程，可以为各种逻辑功能相同而数据类型不同的程序提供一种代码共享的机制。 4.函数模板的定义： ...
第二次作业
qinwy的专栏
09-15 447
1.2*1024*1024/120*60=174.76267kbps=178956.97bps 
颠倒一个链表的顺序 C++
wefun的博客
11-30 1748
首先我们定义一个头结点： struct Node{ int data; Node*next; };接下来我们写一个函数来创建一个链表： //a是一个数组，n代表数组元素的个数 Node*createLinkList(int a[],int n) {     if(a==NULL||n==0)         return NULL;     Node*L,*T=NULL;   
数据结构算法与应用-C++语言描述 chain 单链表2
虾球
12-10 728
chain.cpp #include <iostream> #include <sstream> #include <iterator> using namespace std; //数据结构算法与应用-C++语言描述 chain 单链表 //一个线性表的抽象类 template <class T> class linearList { public: virtual ~linearList(){} //返回true，当且仅当线性表为空 virtu
算法学习十四----逆序输出链表
yipiankongbai的专栏
04-18 1235
题目：输入一个链表的头结点，从尾到头反过来输出每个结点的值。 逆序输出链表，可以采用借用额外空间，使用栈的数据结构，然后遍历一次链表，且每遇到一个节点就将其放入到栈中，直到最后一个节点，最后将栈输出，这样就实现了逆序输出链表。 还有一种方法就是递归实现，每次访问到一个节点的时候，先递归输出它的下一个节点，再输出节点本身，这样就实现了想要的结果。 算法伪代码如下：   
笔试题3：链表的结点结构操作
onlyou2030的博客
07-23 949
一个链表的结点结构： struct Node { int data; Node *next; }; typedef struct Node Node; (1)已知链表的头结点head,写一个函数把这个链表逆序 template void Chain::Reverse() { if (head == NULL || head->Next == NULL) re
reverse函数的编写
也是无奈
01-30 1146
#include <string.h> #include <stdio.h> int main() { void reverse(char s[]); char s[9] = {'1','2','3','4','5','6','7','\0'}; reverse(s); printf("%s",s); return 0; } //本函数的编写能将字符串s的字符
林子斌：数据结构第二次作业解析
资源摘要信息: "***林子斌数据结构第二次作业.rar" 从文件名"***林子斌数据结构第二次作业.rar"中，我们可以提取出以下知识点： 1. 文件命名规范：此文件名遵循一定的命名规范，即"学号+姓名+课程名称+作业次序+...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值