Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0613· openaiHugging Face Suzhen/CodeChat

整理此代码#include <iostream> using namespace std; //定义 const int Max = 100; //单链表节点类型…

  1. User

    整理此代码#include using namespace std; //定义 const int Max = 100;

    //单链表节点类型 template struct LinkNode { T data; LinkNode* next; LinkNode():next(NULL){} LinkNode(T d):data(d),next(NULL){} };

    //模板 template class LinkList { public: LinkNode* head;

    void CreateListF(T a[],int n)
    {
        for (int i =0;i<n;i++)
        {
            LinkNode<T>*s=new LinkNode<T>(a[i]);
            s->next=head->next;
            head->next=s;
        }
    }
    //返回特定节点
    LinkNode<T>*geti(int i)
    {
        if(i<-1)return NULL;
        LinkNode<T>*p=head;
        int j=-1;
        while(j<i&&p!=NULL)
        {
            j++;
            p=p->next;
        }
        return p;
    }
    //空链表
    LinkList()
    {
        head=new LinkNode<T>();
    }
    //析构函数,销毁单链表
    ~LinkList()
    {
        LinkNode<T>* pre,*p;
        pre=head;p=pre->next;
        while (p!=NULL){
    
            delete pre;
            pre=p;p=p->next;
        }
        delete pre;
    }
    //末尾添加特定节点
    void Add(T e)
    {
        LinkNode<T>* s=new LinkNode<T>(e);
        LinkNode<T>* p=head;
        while(p->next!=NULL)
            p=p->next;
        p->next=s;
    }
    //求个数
    int Getlength()
    {
        LinkNode<T>* p=head;
        int cnt=0;
        while (p->next!=NULL)
        {
            cnt++;
            p=p->next;
        }
        return cnt;
    }
    
    //求为特定序号的节点值
    bool GetElem(int i,T& e)
    {
        if (i<0) return false;
        LinkNode<T>* p=geti(i);
        if (p!=NULL)
        {
            e=p->data;
            return true;
        }
        else
            return false;
    }
    //设定特定节点值
    bool SetElem(int i,T e)
    {
        if(i<0)return false;
        LinkNode<T>*p=geti(i);
        if(p!=NULL)
        {
            p->data=e;
            return true;
        }
        else
            return false;
    }
    //删除特定节点
    bool Delete(int i)
    {
        if(i<0) return false;
        LinkNode<T>*p=geti(i-1);
        if (p!=NULL)
        {
            LinkNode<T>*q=p->next;
            if(q!=NULL)
            {
                p->next=q->next;
                delete q;
                return true;
            }
            else
                return false;
        }
        else
            return false;
    }
    //输出所有节点值
    void DispList()
    {
        LinkNode<T>*p;
        p=head->next;
        while(p!=NULL)
        {
            cout<<p->data<<"";
            p=p->next;
        }
        cout<<endl;
    };
    

    };

  2. Assistant

    这段代码实现了一个单链表类LinkList,包括以下功能:

    1. 创建链表:通过CreateListF函数从数组中创建链表,将数组中的元素逐个插入到链表的头部。
    2. 获取特定位置的节点:通过geti函数可以获取链表中特定位置的节点。
    3. 添加节点:通过Add函数在链表的末尾添加新的节点。
    4. 获取链表长度:通过Getlength函数获取链表中节点的个数。
    5. 获取特定位置节点的值:通过GetElem函数获取链表中特定位置节点的值。
    6. 设置特定位置节点的值:通过SetElem函数设置链表中特定位置节点的值。
    7. 删除特定位置节点:通过Delete函数删除链表中特定位置的节点。
    8. 输出所有节点值:通过DispList函数将链表中所有节点的值输出。

    具体实现细节见代码注释。

  3. User

    整理这个代码的排版#include using namespace std; //定义 template struct ListNode { T data; ListNode* next; ListNode(): next(NULL) {} ListNode(T d): data(d), next(NULL) {} }; template class LinkedList { public: ListNode* head; LinkedList(): head(NULL) {} // 析构函数 ~LinkedList() { if (head) { ListNode* v = head->next; while (v != head) { ListNode* temp = v; v = v->next; delete temp; } delete head; } } // 输出链表元素 void DisplayList() { if (head) { ListNode* v = head; do { cout << v->data << " "; v = v->next; } while (v != head); cout << endl; } } // 创建链表 void CreateListR(T a[], int n) { if (a && n > 0) { head = new ListNode(a[0]); ListNode* tail = head; for (int i = 1; i < n; i++) { ListNode* newNode = new ListNode(a[i]); tail->next = newNode; tail = newNode; } tail->next = head; } } // 连接两个链表 void ConnectLists(LinkedList& list2) { if (list2.head) { if (!head) { head = list2.head; } else { ListNode* tail1 = head; while (tail1->next != head) { tail1 = tail1->next; } ListNode* tail2 = list2.head; while (tail2->next != list2.head) { tail2 = tail2->next; } tail1->next = list2.head; tail2->next = head; list2.head = NULL; } } } }; //主函数 int main() { LinkedList linkedList1; cout << “输入第一个循环单链表的结点个数:”; int no1, no2; cin >> no1; int arr1[no1]; cout << “输入第一个循环单链表各个结点的值:”; for(int i = 0; i < no1; ++i){ cin >> arr1[i]; } linkedList1.CreateListR(arr1, no1); cout << “输入第一个循环单链表各个结点的值是:”; linkedList1.DisplayList(); LinkedList linkedList2; cout << “输入第二个循环单链表的结点个数:”; cin >> no2; int arr2[no2]; cout << “输入第二个循环单链表各个结点的值:”; for(int i = 0; i < no2; ++i) { cin >> arr2[i]; } linkedList2.CreateListR(arr2, no2); cout << “输入第二个循环单链表的值为:”; linkedList2.DisplayList(); linkedList1.ConnectLists(linkedList2); cout << “合并后的循环单链表是:”; linkedList1.DisplayList(); cout << “23 胡博文”; return 0; }

  4. Assistant

    这段代码实现了一个循环单链表类LinkedList,包括以下功能:

    1. 创建链表:通过CreateListR函数从数组中创建链表,将数组中的元素逐个插入到链表的尾部,并将尾节点指向头节点,形成循环。
    2. 连接两个链表:通过ConnectLists函数将两个循环链表连接在一起,即将第二个链表的尾节点连接到第一个链表的尾节点,形成一个新的循环链表。
    3. 输出链表元素:通过DisplayList函数将链表中的所有元素按顺序输出。
    4. 析构函数:在链表对象销毁时,释放链表中的所有节点内存。

    具体实现细节见代码注释。

  5. User

    还原这个代码的排版#include using namespace std; //定义 template struct ListNode { T data; ListNode* next; ListNode(): next(NULL) {} ListNode(T d): data(d), next(NULL) {} }; template class LinkedList { public: ListNode* head; LinkedList(): head(NULL) {} // 析构函数 ~LinkedList() { if (head) { ListNode* v = head->next; while (v != head) { ListNode* temp = v; v = v->next; delete temp; } delete head; } } // 输出链表元素 void DisplayList() { if (head) { ListNode* v = head; do { cout << v->data << " "; v = v->next; } while (v != head); cout << endl; } } // 创建链表 void CreateListR(T a[], int n) { if (a && n > 0) { head = new ListNode(a[0]); ListNode* tail = head; for (int i = 1; i < n; i++) { ListNode* newNode = new ListNode(a[i]); tail->next = newNode; tail = newNode; } tail->next = head; } } // 连接两个链表 void ConnectLists(LinkedList& list2) { if (list2.head) { if (!head) { head = list2.head; } else { ListNode* tail1 = head; while (tail1->next != head) { tail1 = tail1->next; } ListNode* tail2 = list2.head; while (tail2->next != list2.head) { tail2 = tail2->next; } tail1->next = list2.head; tail2->next = head; list2.head = NULL; } } } }; //主函数 int main() { LinkedList linkedList1; cout << “输入第一个循环单链表的结点个数:”; int no1, no2; cin >> no1; int arr1[no1]; cout << “输入第一个循环单链表各个结点的值:”; for(int i = 0; i < no1; ++i){ cin >> arr1[i]; } linkedList1.CreateListR(arr1, no1); cout << “输入第一个循环单链表各个结点的值是:”; linkedList1.DisplayList(); LinkedList linkedList2; cout << “输入第二个循环单链表的结点个数:”; cin >> no2; int arr2[no2]; cout << “输入第二个循环单链表各个结点的值:”; for(int i = 0; i < no2; ++i) { cin >> arr2[i]; } linkedList2.CreateListR(arr2, no2); cout << “输入第二个循环单链表的值为:”; linkedList2.DisplayList(); linkedList1.ConnectLists(linkedList2); cout << “合并后的循环单链表是:”; linkedList1.DisplayList(); cout << “23 胡博文”; return 0; }

  6. Assistant

    这段代码的排版已经还原,代码如下:

    #include <cstdlib>
    using namespace std;
    
    // 定义
    template<typename T>
    struct ListNode {
        T data;
        ListNode<T>* next;
        ListNode(): next(NULL) {}
        ListNode(T d): data(d), next(NULL) {}
    };
    
    template <typename T>
    class LinkedList {
    public:
        ListNode<T>* head;
    
        LinkedList(): head(NULL) {}
    
        // 析构函数
        ~LinkedList() { 
            if (head) {
                ListNode<T>* v = head->next;
                while (v != head) {
                    ListNode<T>* temp = v;
                    v = v->next;
                    delete temp;
                }
                delete head;
            }
        }
    
        // 输出链表元素
        void DisplayList() { 
            if (head) {
                ListNode<T>* v = head;
                do {
                    cout << v->data << " ";
                    v = v->next;
                } while (v != head);
                cout << endl;
            }
        }
    
        // 创建链表
        void CreateListR(T a[], int n) { 
            if (a && n > 0) {
                head = new ListNode<T>(a[0]);
                ListNode<T>* tail = head;
                for (int i = 1; i < n; i++) {
                    ListNode<T>* newNode = new ListNode<T>(a[i]);
                    tail->next = newNode;
                    tail = newNode;
                }
                tail->next = head; 
            }
        }
    
        // 连接两个链表
        void ConnectLists(LinkedList<T>& list2) { 
            if (list2.head) {
                if (!head) {
                    head = list2.head;
                } else {
                    ListNode<T>* tail1 = head;
                    while (tail1->next != head) {
                        tail1 = tail1->next;
                    }
                    ListNode<T>* tail2 = list2.head;
                    while (tail2->next != list2.head) {
                        tail2 = tail2->next;
                    }
                    tail1->next = list2.head;
                    tail2->next = head;
                    list2.head = NULL;
                }
            }
        }
    };
    
    // 主函数
    int main() {
        LinkedList<int> linkedList1;
        cout << "输入第一个循环单链表的结点个数:";
        int no1, no2;
        cin >> no1;
        int arr1[no1];
        cout << "输入第一个循环单链表各个结点的值:";
        for(int i = 0; i < no1; ++i){
            cin >> arr1[i];
        }
        linkedList1.CreateListR(arr1, no1);
        cout << "输入第一个循环单链表各个结点的值是:";
        linkedList1.DisplayList();
    
        LinkedList<int> linkedList2;
        cout << "输入第二个循环单链表的结点个数:";
        cin >> no2;
        int arr2[no2];
        cout << "输入第二个循环单链表各个结点的值:";
        for(int i = 0; i < no2; ++i) {
            cin >> arr2[i];
        }
        linkedList2.CreateListR(arr2, no2);
        cout << "输入第二个循环单链表的值为:";
        linkedList2.DisplayList();
    
        linkedList1.ConnectLists(linkedList2);
        cout << "合并后的循环单链表是:";
        linkedList1.DisplayList();
        
        cout << "23 胡博文";
        return 0;
    }
    

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.