精华内容
下载资源
问答
  • 单链表ADT

    2019-09-27 05:56:34
    当前单链表的第一个节点 PreviousPos = NULL; // 指向新链表的第一个节点,假设开始为空 while (CurrentPos != NULL) { NextPos = CurrentPos->Next; // 取得当前节点的下一个节点位置 CurrentPos->Next ...

    本博客第一篇学术性博客,所以还是写点什么东西;

    首先这篇博客以及以后的博客中的代码尽量百分之90是自己写过的;

    可能有部分图片和代码是我认为别人更好的故摘抄下来,

    本人三观正确,所以一定会表明来源;

    —————————华丽的分割线——————————————

    参考书籍——《数据结构于算法分析(C语言描述)

    链表是最基本的数据结构之一,当我们学习完C语言后就会涉及到一点点链表的知识;

    本篇博客主要记录链表的一些简单思路以及它的一些主要例程;

    按照c的约定我们先将链表的函数原型以及一些typedef定义都放在一个Lish.h头文件里

    List.h:

    #ifndef LIST_H
    #define LIST_H
    
    typedef char ElementType;
    
    struct Node;
    typedef struct Node *PtrToNode;
    typedef PtrToNode Position;
    typedef PtrToNode List;
    
    List MakeEmpty(List L);
    int IsLast(Position P, List L);
    int IsEmpty(List L);
    Position FindPrevious(List L, ElementType x);
    Position Find(List L, ElementType x);
    void Delete(List L, ElementType x);
    void Insert(List L, ElementType x, Position P);
    void InsertToTail(List L, ElementType x);
    void InsertToHead(List L, ElementType x);
    void PrintList(List L);
    void DeleteList(List L);
    void Reverse(List L);
    
    #endif

    本篇中的代码所建立的链表都是带有头节点的链表,而使用表头属于个人习惯,我们不再这里做深究

    下面的函数尽量满足ADT的想法,没有写CreateList函数是因为该函数功能是对一个已经创建好了的链表的操作而不是一个纯练习的文件,这是个人对此的理解如有更好的解释请大方私信我!谢谢!

    添加了两个Insert函数分别是InsertToTail和InsertToHead,从字面上来看就是尾插法和头插法,考虑到M.A.W的Insert例程需要传入位置P,而此举往往很麻烦,于是加上了一个直接插入到尾部和头部的函数

    使整个ADT的想法更加完善。

    操作图示:

    这里主要将链表的一些主要例程写出来,并将这些函数封装在一个.c文件里增强复用性!

     SingleLinkedList.c:

    #include"List.h"
    #include<stdio.h>
    #include<stdlib.h>
    
    struct Node{
        ElementType Element;
        PtrToNode Next;
    };
    
    List MakeEmpty(List L)
    {
        if(NULL != L)
        {
            L->Next = NULL;
        }
        return L;
    }
    
    int IsLast(Position P, List L)//L is unused
    {
        return P->Next == NULL;
    }
    
    int IsEmpty(List L)
    {
        return L->Next == NULL;
    }
    
    Position FindPrevious(List L, ElementType x)
    {
        Position P;
        P = L;
        while(P->Next && P->Next->Element != x)
            P = P->Next;
        return P;
    }
    
    Position Find(List L, ElementType x)
    {
        Position P;
        P = L->Next;
        while(P && P->Element != x)
            P = P->Next;
        return P;
    }
    
     void Delete(List L, ElementType x)
    {
        Position Pre, Tmpcell;
        
        Pre = FindPrevious(L, x);//we need find the previous of deleted element
        if(!IsLast(Pre, L))
        {
            Tmpcell = Pre->Next;
            Pre->Next = Tmpcell->Next;
            free(Tmpcell);
        }
    }
    
    //we insert the element after the position p
    void Insert(List L, ElementType x, Position P)
    {
        Position NewCell;
        TmpCell = (List)malloc(sizeof(struct Node));
        if(NULL == NewCell)
            printf("No space for allocation!!");
        else
        {
            NewCell->Element = x;
            NewCell->Next = P->Next;
            P->Next = NewCell;
        }
    }
    //插入链表尾部(尾插法)
    void InsertToTail(List L, ElementType x)
    {
        Position Last, NewCell;
        Last = L;
        /*遍历链表找到最后一个结点*/
        while(NULL != Last->Next)
            Last = Last->Next;
        Insert(L, x, Last);
    }
    //插入链表头部(头插法)
    void InsertToHead(List L, ElementType x)
    {
        Insert(L, x, L);
    }
    
    void PrintList(List L)
    {
        PtrToNode Tmp;
        Tmp = L->Next;
        while(Tmp->Next)
        {
            printf("%c-", Tmp->Element);
            Tmp = Tmp->Next;
        }
        printf("%c\n", Tmp->Element);
    }
    
    void DeleteList(List L)
    {
        Position Tmp, P;
        P = L->Next;
        L->Next = NULL;
        while(P != NULL)
        {
            Tmp = P->Next;
            free(P);
            P = Tmp;
        }
        free(L);
    }
    
    void Reverse(List L)
    {
        Position CurrentPos, NextPos, PreviousPos;
        
        CurrentPos = L->Next;//当前单链表的第一个节点
        PreviousPos = NULL;//指向新链表的第一个节点,假设开始为空
        while(CurrentPos != NULL)
        {
            NextPos = CurrentPos->Next;//取得当前节点的下一个节点位置
            CurrentPos->Next = PreviousPos;//当前节点连接成新的链表
            PreviousPos = CurrentPos;
            CurrentPos = NextPos;//遍历到下一个节点
        }
        L->Next = PreviousPos;//哑元节点连接新链表的头节点
    }
    //与上述思想差不多,主要在返回上
    /*Asumming(假如)is no header and L is not empty*/
    //List Reverse(List L)
    //{
    //    Position CurrentPos, NextPos, PreviousPos;
    //    
    //    CurrentPos = L;
    //    PreviousPos = NULL;
    //    while(CurrentPos != NULL)
    //    {
    //        NextPos = CurrentPos->Next;
    //        CurrentPos->Next = PreviousPos;
    //        PreviousPos = CurrentPos;
    //        CurrentPos = NextPos;
    //    }
    //    return PreviousPos;
    //}
    //下面是复杂记忆写法
    //void Reverse(List L)//含有头节点
    //{
    //    Position Tmp, P;
    //    Tmp = L->Next;
    //    L->Next = NULL;
    //    while(Tmp != NULL)
    //    {
    //        P = Tmp->Next;
    //        Tmp->Next = L->Next;
    //        L->Next = Tmp;
    //        Tmp = P;
    //    }
    //}
    //List Reverse(List L)//不含头节点
    //{
    //    PtrToNode Tmp, P;
    //    P = L;
    //    L = NULL;
    //    while(P != NULL){
    //        Tmp = P->Next;
    //        P->Next = L;
    //        L = P;
    //        P = Tmp;
    //    }
    //    return L;
    //}

     

    下面贴出自己写的一组测试代码

    Test.c:

    #include"List.h"
    #include<stdio.h>
    #include<stdlib.h>
    
    int main()
    {
        ElementType Elem, De, PreElem, Ins;
        Position Tmp;
        List L;
        L = (List)malloc(sizeof(struct Node));
        if(NULL == L)
            printf("Allocation failure!!!");
        L = MakeEmpty(L);
        printf("Please enter the element until the end of '#':");
        while((Elem = getchar()) != '#')
        {
            InsertToTail(L, Elem);
        }
        getchar();
        PrintList(L);
        //删除并输出
        printf("Please enter the element you want to delete:");
        scanf("%c", &De);
        getchar();
        
        Delete(L, De);
        PrintList(L);
        //插入并输出
        printf("After which element do you want to insert:");
        scanf("%c", &PreElem);
        getchar();
        Tmp = Find(L, PreElem);
        
        printf("What element do you want to insert:");
        scanf("%c", &Ins);
        getchar();
        
        Insert(L, Ins, Tmp);
        PrintList(L);
        //将整个表倒置
        Reverse(L);
        printf("Now the reverse list is:");
        PrintList(L);
        //删除整个表
        DeleteList(L);
        return 0;
    }

     

     

    转载于:https://www.cnblogs.com/Crel-Devi/p/9438662.html

    展开全文
  • 单链表ADT和双链表ADT

    2020-04-02 16:53:58
    数据结构中的链表,有单链表和双链表,这一篇里实现了单链表ADT和双链表ADT。

    下面是单链表ADT和双链表ADT

    1. 单链表ADT:
    #include<stdio.h>
    #include<stdlib.h>
    #include<windows.h>
    
    typedef int ElemType;
    typedef struct LNode
    {
        ElemType data;
        struct LNode *next;
    } LNode, *LinkedList;
    typedef enum Status{
        error,
        success
    } Status;
    
    //函数的声明
    Status InitList(LinkedList *L);
    void DestroyList(LinkedList *L);
    Status InsertList(LNode *p, ElemType data);
    Status DeleteList(LNode *p, ElemType e);
    void TraverseList(LinkedList L);
    Status SearchList(LinkedList L, ElemType e);
    Status ReverseList(LinkedList *L);
    Status IsLoopList(LinkedList L);
    LNode* FindMidNode(LinkedList L);
    void show(void);
    int judge_int(void);
    
    Status InitList(LinkedList *L) {
        LinkedList list;
    
        list = (LinkedList)malloc(sizeof(LNode));
        if(list == NULL)
        {
        	printf("内存分配失败\n");
            return error;
        }
        list->next = NULL;
        *L = list;
    
        return success;
    }
    
    void DestroyList(LinkedList *L) {
        LinkedList temp;
    
        while(*L != NULL)
        {
            temp = *L;
            *L = (*L)->next;
            free(temp);
        }
    }
    
    Status InsertList(LNode *p, ElemType data) {
        LinkedList current = p;
        LinkedList newNode = (LinkedList)malloc(sizeof(LNode));
    
        if(newNode == NULL)
        {
            printf("内存分配失败\n");
            return error;
        }
        newNode->data = data;
        newNode->next = NULL;
        while(current->next != NULL)
        {
            current = current->next;
        }
        current->next = newNode;
        return success;
    }
    
    Status DeleteList(LNode *p, ElemType e) {
        LinkedList posNode = p->next;
        LinkedList posNodeFront = p;
        if(posNode == NULL)
        {
            printf("链表为空,无法删除\n");
        }
        else
        {
            while(posNode->data != e)
            {
                posNodeFront = posNode;
                posNode = posNode->next;
                if(posNode == NULL)
                {
                    printf("没有该数据\n");
                    return error;
                }
            }
            posNodeFront->next = posNode->next;
            free(posNode);
            return success;
        }
    }
    
    void TraverseList(LinkedList L) {
        LinkedList temp;
    
        temp = L->next;
        while(temp != NULL)
        {
            printf("%d\t", temp->data);
            temp = temp->next;
        }
        printf("\n");
    }
    
    Status SearchList(LinkedList L, ElemType e) {
        while(L != NULL)
        {
            if(L->data == e)
            {
                return success;
            }
            L = L->next;
        }
        return error;
    }
    
    /*
    void ReverseList(LinkedList L) {
        LinkedList current, next, pre;
        current = L->next;
        pre = NULL;
        while(current != NULL)
        {
            next = current->next;
            current->next = pre;
            pre = current;
            current = next;
        }
        L->next = pre;
    }
    */
    
    Status ReverseList(LinkedList *L) {
        LNode *newHead;		//储存每次反转后的第一个节点 
        LNode *p1;			//每次都指向前一个节点	
        LNode *p2;			// 储存未反转前的下一个节点 
        p1=(*L)->next;
        p2=p1->next;
        p1->next=NULL;
        newHead=p1;
        while (p2!= NULL) {
            p1=p2;
            p2=p1->next;
            p1->next=newHead;
            newHead=p1;
        }
        (*L)->next=newHead;
    }
    
    LNode* FindMidNode(LinkedList L) {
        LinkedList slow = L, fast = L;
        while(fast != NULL && slow != NULL)
        {
            fast = fast->next->next;
            slow = slow->next;
        }
        return slow;
    }
    
    Status IsLoopList(LinkedList L) {
        LinkedList fast = L, slow = L;
        while(fast->next != NULL && slow->next != NULL)
        {
            slow = slow->next;
            if((fast = fast->next->next) == NULL)
            return error;
            if(fast == slow)
            return success;
        }
        return error;
    }
    
    void show(void)
    {
        printf("\n\n\n\n单链表ADT\n\n");
        printf("1.创建空链表\n");
        printf("2.销毁链表\n");
        printf("3.插入结点\n");
        printf("4.删除结点\n");
        printf("5.遍历链表\n");
        printf("6.查找数据\n");
        printf("7.反转链表\n");
        printf("8.判断链表是否成环\n");
        printf("9.反转链表中的偶数结点/无此功能\n");
        printf("10.查找中间结点\n");
        printf("11.退出\n");
        printf("\n请输入对应的数字(1-11):");
    }
    
    int judge_int(void)  //防止用户乱输入其他的字符
    {
        int len, num = 0, arg = 1;
        char word[10];  
        int m, j= 1, k;
        while(j)
        {
            scanf("%s", word);
            len = strlen(word);
            for(m = 0;m<len;m++)
            {
                if(word[m]<'0' || word[m]>'9')  //检验是否有乱输入其他字符
                {
                    printf("请输入整数:");
                    break;
                }
                else 
                {
                    if(m == len-1)
                        j = 0;
                }
            }
        }
        j = len-1;
        for(m=0;m<len;m++)  // 将字符重新转换为数字
        {
            for(k=0;k<j;k++)
                arg *= 10;
            num += (word[m]-'0')*arg;
            arg = 1;
            j--;
        }
        return num;
    } 
    
    int main(void)
    {
        int choice, num = 0;
        LinkedList head = NULL;
    
        do
        {
            show();
            choice = judge_int();
            system("cls");
            switch(choice)
            {
                case 1://创建空链表
                {
                    if(InitList(&head))
                    {
                        printf("空链表创建成功\n");
                    }
                    else
                    {
                        printf("空链表创建失败\n");
                    }
                    break;
                }
                case 2://销毁链表
                {
                    DestroyList(&head);
                    printf("链表销毁完成\n");
                    break;
                }
                case 3://插入数据
                {
                    if(head == NULL)
                    {
                        printf("链表为空, 请先创建链表\n");
                    }
                    else
                    {
                        printf("请输入数据:");
                        scanf("%d", &num);
                        if(InsertList(head, num))
                        {
                            printf("数据插入成功\n");
                        }
                        else
                        {
                            printf("数据插入失败\n");
                        }
                    }
                    break;
                }
                case 4://删除数据
                {
                    printf("你想删除哪个数据:");
                    scanf("%d", &num);
                    if(DeleteList(head, num))
                    {
                        printf("数据删除成功\n");
                    }
                    else
                    {
                    	printf("数据删除失败\n");
                    }
                    break;
                }
                case 5://遍历链表
                {
                    if(head == NULL || head->next == NULL)
                    {
                        printf("链表不存在或者只存在一个空的头结点\n");
                    }
                    else
                    {
                        TraverseList(head);
                    }
                    break;
                }
                case 6://查找数据
                {
                    printf("请输入你要查找的数据:");
                    scanf("%d", &num);
                    if(SearchList(head, num))
                    {
                        printf("该数存在\n");
                    }
                    else
                    {
                        printf("该数不存在\n");
                    }
                    break;
                }
                case 7://反转链表
                {
                    if(head == NULL || head->next == NULL)
                    {
                        printf("链表为空或者链表只含有两个结点\n");
                        printf("链表反转失败\n");
                    }
                    else
                    {
                        if(ReverseList(&head))
                        {
                            printf("链表反转成功\n");
                        }
                        else
                        {
                            printf("链表反转失败\n");
                        }
                        
                    }
                    break;
                }
                case 8://判断链表是否成环
                {
                    if(head == NULL || head->next == NULL)
                    {
                        printf("链表为空\n");
                    }
                    else
                    {
                        if(IsLoopList(head))
                        {
                            printf("链表成环\n");
                        }
                        else
                        {
                            printf("链表没有成环\n");
                        }
                    }
                    break;
                }
                case 9://反转链表中的偶数结点
                {
                    break;
                }
                case 10://查找中间结点
                {
                    if(head == NULL || head->next == NULL)
                    {
                        printf("这是空链表\n");
                    }
                    else
                    {
                        printf("链表中间储存的值为%d\n", (FindMidNode(head))->data);
                    }
                    break;
                }
                case 11://销毁链表
                {
                    DestroyList(&head);
                    break;
                }
                default:
                {
                    printf("请重新输入数字!(1-11)\n");
                    break;
                }
            }
        } while (choice != 11);
        
        return 0;
    }
    
    1. 双链表ADT
    #include<stdio.h>
    #include<stdlib.h>
    #include<windows.h>
    
    typedef int ElemType;
    typedef struct DuLNode {
    	ElemType data;
      	struct DuLNode *prior,  *next;
    } DuLNode, *DuLinkedList;
    typedef enum Status {
    	error,
    	success,
    } Status;
    
    //函数的声明
    Status InitList_DuL(DuLinkedList *L);
    void DestroyList_DuL(DuLinkedList *L);
    Status InsertBeforeList_DuL(DuLNode *p, DuLNode *q);
    Status InsertAfterList_DuL(DuLNode *p, DuLNode *q);
    Status DeleteList_DuL(DuLNode *p, ElemType *e);
    void TraverseList_DuL(DuLinkedList L);
    void show(void);
    int judge_int(void);
    
    Status InitList_DuL(DuLinkedList *L) {
        DuLinkedList List;
        List = (DuLinkedList)malloc(sizeof(DuLNode));
        if(List == NULL)
        {
    	    printf("内存分配失败\n");
            return error;
        }
        List->next = NULL;
        List->prior = NULL;
        *L = List;
        return success;
    }
    
    void DestroyList_DuL(DuLinkedList *L) {
        DuLinkedList temp;
    
        while(*L != NULL)
        {
            temp = *L;
            *L = (*L)->next;
            free(temp);
        }
    }
    
    Status InsertBeforeList_DuL(DuLNode *p, DuLNode *q) {
        if(p->next == NULL)//当链表为空时,直接连接p、q
        {
            p->next = q;
            q->prior = p;
        }
        else
        {
            DuLinkedList temp;
            temp = p->next;
            p->next = q;
            q->next = temp;
            temp->prior = q;
            q->prior = p;
            return success;
        }
    }
    
    Status InsertAfterList_DuL(DuLNode *p, DuLNode *q) {
        while(p->next != NULL)
        {
            p = p->next;
        }
        p->next = q;
        q->prior = p;
    }
    
    Status DeleteList_DuL(DuLNode *p, ElemType *e) {
        if(p->next == NULL)
        {
            printf("链表为空,无法删除\n");
            return error;
        }
        else
        {
            DuLinkedList posNode = p->next, posNodeFront = p;
            //找到删除结点的位置
            while(posNode->data != *e)
            {
                posNodeFront = posNode;
                posNode = posNode->next;
                if(posNode == NULL)
                {
                    printf("找不到该数据\n");
                    return error;
                }
            }
            if(posNode->next != NULL)
            {
                posNodeFront->next = posNode->next;
                posNode->next->prior = posNodeFront;
            }
            else
            {
                posNodeFront->next = NULL;
            }
            free(posNode);
            return success;
        }
    }
    
    void TraverseList_DuL(DuLinkedList L) {
        if(L == NULL)
        {
            printf("链表未创建,请先创建链表\n");
        }  
    	else if(L->next == NULL)
    	{
    		printf("当前链表为空\n");
    	}  
        else
        {
            DuLinkedList temp = L->next;
            while(temp != NULL)
            {
                printf("%d\t", temp->data);
                temp = temp->next;
            }
            printf("\n");
        }
    }
    
    void show(void)
    {
        printf("\n\n\n\n双链表ADT\n\n");
        printf("1.创建空链表\n");
        printf("2.销毁链表\n");
        printf("3.头插法插入数据\n");
        printf("4.尾插法插入数据\n");
        printf("5.删除数据\n");
        printf("6.遍历链表\n");
        printf("7.退出\n");
        printf("\n请输入对应的数字(1-7):");
    }
    
    int judge_int(void)  //防止用户乱输入其他的字符
    {
        int len, num = 0, arg = 1;
        char word[10];  
        int m, j= 1, k;
        while(j)
        {
            scanf("%s", word);
            len = strlen(word);
            for(m = 0;m<len;m++)
            {
                if(word[m]<'0' || word[m]>'9')  //检验是否有乱输入其他字符
                {
                    printf("请输入整数:");
                    break;
                }
                else 
                {
                    if(m == len-1)
                        j = 0;
                }
            }
        }
        j = len-1;
        for(m=0;m<len;m++)  // 将字符重新转换为数字
        {
            for(k=0;k<j;k++)
                arg *= 10;
            num += (word[m]-'0')*arg;
            arg = 1;
            j--;
        }
        return num;
    } 
    
    int main(void)
    {
        int choice, num = 0;
        DuLinkedList head;
        head = NULL;
    
        do
        {
            show();
            choice = judge_int();
            system("cls");
            switch(choice)
            {
                case 1://创建空链表
                {
                    if(InitList_DuL(&head))
                    {
                        printf("空链表创建成功\n");
                    }
                    else
                    {
                        printf("空链表创建失败\n");
                    }
                    break;
                }
                case 2://销毁链表
                {
                    DestroyList_DuL(&head);
                    printf("链表销毁成功\n");
                    break;
                }
                case 3://头插法插入数据
                {
                    if(head == NULL)
                    {
                        printf("链表未创建,请先创建链表\n");
                    }
                    else
                    {
                        DuLinkedList newNode;
                        if(InitList_DuL(&newNode))
                        {
                            printf("请输入数据:");
                            scanf("%d", &newNode->data);
                            if(InsertBeforeList_DuL(head, newNode))
                            {
                                printf("数据插入成功\n");
                            }
                            else
                            {
                                printf("数据插入失败\n");
                            }
                        }
                        else
                        {
                            printf("数据插入失败\n");
                        }
                    }
                    break;
                }
                case 4://尾插法插入数据
                {
                    if(head == NULL)
                    {
                        printf("链表未创建,请先创建链表\n");
                    }
                    else
                    {
                        DuLinkedList newNode;
                        if(InitList_DuL(&newNode))
                        {
                            printf("请输入数据:");
                            scanf("%d", &newNode->data);
                            if(InsertAfterList_DuL(head, newNode))
                            {
                                printf("数据插入成功\n");
                            }
                            else
                            {
                                printf("数据插入失败\n");
                            }
                        }
                        else
                        {
                            printf("数据插入失败\n");
                        }
                    }
                    break;
                }
                case 5://删除数据
                {
                    if(head == NULL)
                    {
                        printf("链表未创建,请先创建链表\n");
                    }
                    else
                    {
                        printf("你想删除哪个数据:");
                        scanf("%d", &num);
                        if(DeleteList_DuL(head, &num))
                        {
                            printf("数据删除成功\n");
                        }
                        else
                        {
                            printf("数据删除失败\n");
                        }
                    }
                    break;
                }
                case 6://遍历链表
                {
                    TraverseList_DuL(head);
                    break;
                }
                case 7://退出程序 
                {
                    DestroyList_DuL(&head);
                    break;
                }
                default:
                {
                    printf("请重新输入数字!(1-7)\n");
                    break;
                }
            }
        } while (choice != 7);
    
        return 0;
    }
    
    展开全文
  • 并在此基础上,使用单链表ADT的基本操作,设计并实现单链表的简单算法设计。 内容: (1)请使用模板设计单链表的抽象数据类型。(由于该环境目前仅支持单文件的编译,故将所有内容都集中在一个源文件内。在实际的...

    问题描述 :

    目的:使用C++模板设计单链表的抽象数据类型(ADT)。并在此基础上,使用单链表ADT的基本操作,设计并实现单链表的简单算法设计。

    内容:

    (1)请使用模板设计单链表的抽象数据类型。(由于该环境目前仅支持单文件的编译,故将所有内容都集中在一个源文件内。在实际的设计中,推荐将抽象类及对应的派生类分别放在单独的头文件中。参考网盘中的ADT原型文件。)

    (2)ADT的简单应用:使用该ADT设计并实现单链表应用场合的一些简单算法设计。

    应用2:假设线性表A=(a1,a2,...,am),线性表B=(b1,b2,...,bn),现要求设计一个算法,使用带头结点的单链表存储结构,将这两个链表连接在一起(即令单链表B的首元结点连在单链表A的尾结点之后),且使用A和B的原存储空间。单链表B不再单独存在。输入中的单链表的长度仅作为建表使用,不得在该算法中利用。

    参考函数原型:

    template<class ElemType>

    void Linklist_Contact( LinkList<ElemType> &A, LinkList<ElemType> &B );

     

     

    输入说明 :

    第一行:顺序表A的数据元素的数据类型标记(0:int,1:double,2:char,3:string)

    第二行:单链表A的数据元素(数据元素之间以空格分隔)

    第三行:单链表B的数据元素(数据元素之间以空格分隔)

     

    输出说明 :

    如第一行输入值为0、1、2、3之外的值,直接输出“err”

    否则:

     

    第一行:单链表A的遍历结果(数据元素之间以"->"分隔)

    第二行:单链表B的遍历结果(数据元素之间以"->"分隔)

    空行

    第三行:连接后单链表A的遍历结果(数据元素之间以"->"分隔)

     

     

    输入范例 :

    0
    13 5 27 9 32 123 76 98 54 87
    1 3 7 8 11

    输出范例 :

    13->5->27->9->32->123->76->98->54->87
    1->3->7->8->11

    13->5->27->9->32->123->76->98->54->87->1->3->7->8->11

    解题代码: 

    #include <iostream>
    #include <cstdio>
    #include <cstdlib>
    #include <algorithm>
    #include <cmath>
    #include <cstring>
    #include <string>
    #include <vector>
    #include <queue>
    #include <sstream>
    #include <stack>
    #include <map>
    #include <ctime>
    #include <array>
    #include <set>
    using namespace std;
    //单链表ADT
    /* 单链表的结点定义 */
    template<class ElemType>
    struct LinkNode
    {
    	ElemType data;//元素
    	LinkNode<ElemType>* next;//next指针
    	LinkNode(LinkNode<ElemType>* ptr = NULL)
    	{
    		//创建节点的时候可以传入next指针
    		next = ptr;
    	}
    	LinkNode(const ElemType& item, LinkNode<ElemType>* ptr = NULL)
    	{
    		//创建节点的时候可以传入一个元素或者:元素+next指针。
    		next = ptr;
    		data = item;
    	}
    };
    //带头结点的单链表
    template<class ElemType>
    class LinkList
    {
    private:
    	LinkNode<ElemType>* head;   // 头指针
    	LinkNode<ElemType>* tail;   // 尾指针
    	void empty_push(ElemType num)//空链表插入第一个节点
    	{
    		head = new LinkNode<ElemType>;//头指针指向新建节点
    		tail = head;//尾指针指向头指针
    		head->data = num;//赋值
    		//head->next = NULL;
    		return;
    	}
    	bool check_P(int n)//检查下标是否合法:0-n
    	{
    		if (0 <= n && n < size())
    			return true;
    		return false;
    	}
    public:
    	/*
    	
    	int size(void)获取长度
    	LinkNode<ElemType>* get_address(int i)//获取指定下标的地址
    	void have_look(void)   //输出
    	void push_back(ElemType num) //尾部插入
    	void insert_head(ElemType num) 头部插入
    	bool insert_back(int place, ElemType num) 插入到指定位置之后
    
    	*/
    	LinkList()
    	{
    		//无参数的构造函数
    		//head = new LinkNode<ElemType>;//头指针指向新建节点
    		//tail = head;//尾指针指向头指针
    		head = NULL;
    		tail = NULL;
    	}
    	LinkList(const ElemType& item)
    	{
    		//带参数的构造函数 我觉得没几个人会用吧
    		head = new LinkNode<ElemType>(item);
    		tail = head;
    	}
    	LinkList(LinkList<ElemType>& List)
    	{
    		//拷贝构造函数
    		;
    	}
    	~LinkList()
    	{
    		//析构函数
    		
    	}
    	LinkNode<ElemType>* get_address(int i)//获取指定下标的地址
    	{
    		LinkNode<ElemType>* pla=head;
    		while (i--)
    		{
    			pla = pla->next;
    		}
    		return pla;
    	}
    	void have_look(void)
    	{
    		LinkNode<ElemType>* p = head;
    		while (p->next!= NULL)
    		{
    			cout << p->data;
    			cout << "->";
    			p = p->next;
    		}
    		cout << p->data << endl;
    		return;
    	}
    	int size(void)//finish 返回数组的长度
    	{
    		int len = 0;
    		if (head == NULL && tail == NULL)
    			return 0;
    		LinkNode<ElemType>* p;
    		p = head;
    		while (p != NULL)
    		{
    			len++;
    			p = p->next;
    		}
    		return len;
    	}
    	void push_back(ElemType num)
    	{
    		if (size()==0)//空链表特判
    		{
    			empty_push(num);
    			return;
    		}
    		LinkNode<ElemType>* p = new LinkNode<ElemType>;//新建节点
    		p->data = num;//赋值
    		tail->next = p;//尾指针指向节点next赋值为p
    		tail = p;//尾指针指向p
    		return;
    	}
    	void insert_head(ElemType num)
    	{
    		if (size() == 0)//空链表特判
    		{
    			empty_push(num);
    			return;
    		}
    		LinkNode<ElemType>* p = new LinkNode<ElemType>;//新建节点
    		p->data = num;//赋值
    		p->next = head;//链接
    		head = p;
    		return;
    	}
    	bool insert_back(int place, ElemType num)
    	{
    		if (size() == 0 && place==0)//空链表特判
    		{
    			empty_push(num);
    			return true;
    		}
    		if (check_P(place) == false)//位置合法性判断
    			return false;
    		if (place == size() - 1)//尾部插入特判
    		{
    			push_back(num);
    			return true;
    		}
    		LinkNode<ElemType>* p=get_address(place);
    		LinkNode<ElemType>* p2 = new LinkNode<ElemType>;//新建
    		p2->data = num;//赋值
    		p2->next = p->next;//定位
    		p->next = p2;//链接
    		return true;
    	}
    	LinkNode<ElemType>* get_front(LinkNode<ElemType>* p)//获取一个指针的上一个,头指针和非法指针会报错.
    	{
    		LinkNode<ElemType>* p1;
    		p1 = head;
    		while (p1->next != NULL)
    		{
    			if (p1->next == p)
    				return p1;
    			p1=p1->next;
    		}
    	}
    	bool del(int i)//删除指定位置元素  。注意,没有写非法请求检查(0->n-1)
    	{
    		return del_p(get_address(i));
    	}
    	bool del_p(LinkNode<ElemType>* p)
    	{
    		if (size() == 0)
    			return false;
    		if (head == tail)
    		{
    			if (p == head)
    			{
    				delete head;
    				head = NULL;
    				tail = NULL;
    				return true;
    			}
    			else
    				return false;
    		}
    		if (p == head)
    		{
    			LinkNode<ElemType>* p1 = head->next;
    			delete head;
    			head = p1;
    			return true;
    		}
    		if (p == tail)
    		{
    			LinkNode<ElemType>* p1 = get_front(p);
    			delete p;
    			p1->next=NULL;
    			tail = p1;
    			return true;
    		}
    		LinkNode<ElemType>* p1 = get_front(p);
    		p1->next = p->next;
    		delete p;
    		return true;
    	}
    	ElemType at(int i)
    	{
    		LinkNode<ElemType>* p=get_address(i);
    		return p->data;
    	}
    	void reverse(int m, int n)//反转m->n区间
    	{
    		m++, n++;
    		LinkNode<ElemType>* newHead = new LinkNode<ElemType>;
    		newHead->next = head;
    		LinkNode<ElemType>* p = newHead;
    		for (int i = 0; i < m - 1; i++)
    			p = p->next;
    		LinkNode<ElemType>* start = p->next;
    		LinkNode<ElemType>* t = start->next;
    		if (n == size())
    		{
    			tail = start;
    		}
    		for (int i = m; i < n; i++)
    		{
    			start->next = t->next;
    			t->next = p->next;
    			p->next = t;
    			t = start->next;
    		}
    		head = newHead->next;
    		return;
    	}
    	LinkList<ElemType>* get_head(void)
    	{
    		return head;
    	}
    	LinkList<ElemType>* get_tail(void)
    	{
    		return head;
    	}
    	void pick(LinkList<ElemType> &lis)
    	{
    		tail->next=lis.head;
    		tail = lis.tail;
    		return;
    	}
    };
    //LinkList<int> a;
    //===============================================================
    vector<int> departString_int(string data)
    {
    	vector<int> back_part;//output type
    	int i, j;
    	vector<string> part;
    	string A_part;
    	stringstream room;
    	room.str(data);
    	while (room >> A_part)
    		part.push_back(A_part);
    	for (i = 0; i < part.size(); i++)
    	{
    		int num_cahe;
    		num_cahe = atoi(part[i].c_str());
    		back_part.push_back(num_cahe);
    	}
    	return back_part;
    }
    vector<double> departString_double(string data)
    {
    	vector<double> back_part;//output type
    	int i, j;
    	vector<string> part;
    	string A_part;
    	stringstream room;
    	room.str(data);
    	while (room >> A_part)
    		part.push_back(A_part);
    	for (i = 0; i < part.size(); i++)
    	{
    		double num_cahe;
    		num_cahe = atof(part[i].c_str());
    		back_part.push_back(num_cahe);
    	}
    	return back_part;
    }
    vector<char> departString_char(string data)
    {
    	vector<char> back_part;//output type
    	int i, j;
    	vector<string> part;
    	string A_part;
    	stringstream room;
    	room.str(data);
    	while (room >> A_part)
    		part.push_back(A_part);
    	for (i = 0; i < part.size(); i++)
    	{
    		char num_cahe;
    		num_cahe = part[i].at(0);
    		back_part.push_back(num_cahe);
    	}
    	return back_part;
    }
    vector<string> departString_string(string data)
    {
    	vector<int> back_part;//output type
    	int i, j;
    	vector<string> part;
    	string A_part;
    	stringstream room;
    	room.str(data);
    	while (room >> A_part)
    		part.push_back(A_part);
    	return part;
    }
    //===================================================
    
    template<class ElemType>
    void Linklist_Contact(LinkList<ElemType>& A, LinkList<ElemType>& B)
    {
    	A.pick(B);
    	A.have_look();
    }
    
    //===================================================
    int main()
    {
    	int i, j;
    	int kinds;
    	string s1, s2;
    	int m;
    	//数值类型输入判断
    	cin >> kinds;
    	if (kinds != 0 && kinds != 1 && kinds != 2 && kinds != 3)
    	{
    		cout << "err" << endl;
    		return 0;
    	}
    	cin.get();
    	vector<int> I_1, I_2;
    	vector<double> D_1, D_2;
    	vector<char> C_1, C_2;
    	vector<string> S_1, S_2;
    	
    	LinkList<int> LI_1, LI_2;
    	LinkList<double> LD_1, LD_2;
    	LinkList<char> LC_1, LC_2;
    	LinkList<string> LS_1, LS_2;
    	//---------------
    	getline(cin, s1);
    	if (kinds == 0)
    		I_1 = departString_int(s1);
    	if (kinds == 1)
    		D_1 = departString_double(s1);
    	if (kinds == 2)
    		C_1 = departString_char(s1);
    	if (kinds == 3)
    		S_1 = departString_string(s1);
    	//--------------
    	getline(cin, s2);
    	if (kinds == 0)
    		I_2 = departString_int(s2);
    	if (kinds == 1)
    		D_2 = departString_double(s2);
    	if (kinds == 2)
    		C_2 = departString_char(s2);
    	if (kinds == 3)
    		S_2 = departString_string(s2);
    	//--------------
    	if (kinds == 0)
    	{
    		for (i = 0; i < I_1.size(); i++)
    			LI_1.push_back(I_1[i]);
    	}
    	if (kinds == 1)
    	{
    		for (i = 0; i < D_1.size(); i++)
    			LD_1.push_back(D_1[i]);
    	}
    	if (kinds == 2)
    	{
    		for (i = 0; i < C_1.size(); i++)
    			LC_1.push_back(C_1[i]);
    	}
    	if (kinds == 3)
    	{
    		for (i = 0; i < S_1.size(); i++)
    			LS_1.push_back(S_1[i]);
    	}
    	//--------------
    	if (kinds == 0)
    	{
    		for (i = 0; i < I_2.size(); i++)
    			LI_2.push_back(I_2[i]);
    	}
    	if (kinds == 1)
    	{
    		for (i = 0; i < D_2.size(); i++)
    			LD_2.push_back(D_2[i]);
    	}
    	if (kinds == 2)
    	{
    		for (i = 0; i < C_2.size(); i++)
    			LC_2.push_back(C_2[i]);
    	}
    	if (kinds == 3)
    	{
    		for (i = 0; i < S_2.size(); i++)
    			LS_2.push_back(S_2[i]);
    	}
    	//--------------
    	if (kinds == 0)
    		LI_1.have_look();
    	if (kinds == 1)
    		LD_1.have_look();
    	if (kinds == 2)
    		LC_1.have_look();
    	if (kinds == 3)
    		LS_1.have_look();
    	//--------------
    	if (kinds == 0)
    		LI_2.have_look();
    	if (kinds == 1)
    		LD_2.have_look();
    	if (kinds == 2)
    		LC_2.have_look();
    	if (kinds == 3)
    		LS_2.have_look();
    	//--------------
    	cout << endl;
    	//+++++++++++++++++++++++++
    	if (kinds == 0)
    		Linklist_Contact(LI_1, LI_2);
    	if (kinds == 1)
    		Linklist_Contact(LD_1, LD_2);
    	if (kinds == 2)
    		Linklist_Contact(LC_1, LC_2);
    	if (kinds == 3)
    		Linklist_Contact(LS_1, LS_2);
    	return 0;
    }
    //===============================================================
    

     

    展开全文
  • 并在此基础上,使用单链表ADT的基本操作,设计并实现单链表的简单算法设计。 内容: (1)请使用模板设计单链表的抽象数据类型。(由于该环境目前仅支持单文件的编译,故将所有内容都集中在一个源文件内。在实际的...

    问题描述 :

    目的:使用C++模板设计单链表的抽象数据类型(ADT)。并在此基础上,使用单链表ADT的基本操作,设计并实现单链表的简单算法设计。

    内容:

    (1)请使用模板设计单链表的抽象数据类型。(由于该环境目前仅支持单文件的编译,故将所有内容都集中在一个源文件内。在实际的设计中,推荐将抽象类及对应的派生类分别放在单独的头文件中。参考网盘中的ADT原型文件。)

     

    (2)ADT的简单应用:使用该ADT设计并实现单链表应用场合的一些简单算法设计。

     

    应用5:试设计一个算法,删除有序单链表A中的冗余元素,即使得操作之后的单链表中只保留操作之前表中所有值都不相同的元素,并保持其有序性。要求利用原表中的结点,并释放A表中冗余的结点空间。

    参考函数原型:

    template<class ElemType>

    void Purge_Lk_OL( LinkList<ElemType> &A ); //测试数据限定为整数。实际应用时,不受其限制

     

    输入说明 :

    第一行:顺序表A的数据元素的数据类型标记(0:int,1:double,2:char,3:string)

    第二行:单链表A的数据元素(数据元素之间以空格分隔)

    输出说明 :

    如第一行输入值为0、1、2、3之外的值,直接输出“err”

    否则:

     

    第一行:单链表A的遍历结果

    空行

    第三行:提纯后单链表A的遍历结果

    输入范例 :

    0
    3 3 5 5 8 11 11

    输出范例 :

    3->3->5->5->8->11->11

    3->5->8->11

    解题代码: 

    #include <iostream>
    #include <cstdio>
    #include <cstdlib>
    #include <algorithm>
    #include <cmath>
    #include <cstring>
    #include <string>
    #include <vector>
    #include <queue>
    #include <sstream>
    #include <stack>
    #include <map>
    #include <ctime>
    #include <array>
    #include <set>
    using namespace std;
    //单链表ADT
    /* 单链表的结点定义 */
    template<class ElemType>
    struct LinkNode
    {
    	ElemType data;//元素
    	LinkNode<ElemType>* next;//next指针
    	LinkNode(LinkNode<ElemType>* ptr = NULL)
    	{
    		//创建节点的时候可以传入next指针
    		next = ptr;
    	}
    	LinkNode(const ElemType& item, LinkNode<ElemType>* ptr = NULL)
    	{
    		//创建节点的时候可以传入一个元素或者:元素+next指针。
    		next = ptr;
    		data = item;
    	}
    };
    //带头结点的单链表
    template<class ElemType>
    class LinkList
    {
    private:
    	LinkNode<ElemType>* head;   // 头指针
    	LinkNode<ElemType>* tail;   // 尾指针
    	void empty_push(ElemType num)//空链表插入第一个节点
    	{
    		head = new LinkNode<ElemType>;//头指针指向新建节点
    		tail = head;//尾指针指向头指针
    		head->data = num;//赋值
    		//head->next = NULL;
    		return;
    	}
    	bool check_P(int n)//检查下标是否合法:0-n
    	{
    		if (0 <= n && n < size())
    			return true;
    		return false;
    	}
    public:
    	/*
    	
    	int size(void)获取长度
    	LinkNode<ElemType>* get_address(int i)//获取指定下标的地址
    	void have_look(void)   //输出
    	void push_back(ElemType num) //尾部插入
    	void insert_head(ElemType num) 头部插入
    	bool insert_back(int place, ElemType num) 插入到指定位置之后
    
    	*/
    	LinkList()
    	{
    		//无参数的构造函数
    		//head = new LinkNode<ElemType>;//头指针指向新建节点
    		//tail = head;//尾指针指向头指针
    		head = NULL;
    		tail = NULL;
    	}
    	LinkList(const ElemType& item)
    	{
    		//带参数的构造函数 我觉得没几个人会用吧
    		head = new LinkNode<ElemType>(item);
    		tail = head;
    	}
    	LinkList(LinkList<ElemType>& List)
    	{
    		//拷贝构造函数
    		;
    	}
    	~LinkList()
    	{
    		//析构函数
    		
    	}
    	LinkNode<ElemType>* get_address(int i)//获取指定下标的地址
    	{
    		LinkNode<ElemType>* pla=head;
    		while (i--)
    		{
    			pla = pla->next;
    		}
    		return pla;
    	}
    	void have_look(void)
    	{
    		LinkNode<ElemType>* p = head;
    		while (p->next!= NULL)
    		{
    			cout << p->data;
    			cout << "->";
    			p = p->next;
    		}
    		cout << p->data << endl;
    		return;
    	}
    	int size(void)//finish 返回数组的长度
    	{
    		int len = 0;
    		if (head == NULL && tail == NULL)
    			return 0;
    		LinkNode<ElemType>* p;
    		p = head;
    		while (p != NULL)
    		{
    			len++;
    			p = p->next;
    		}
    		return len;
    	}
    	void push_back(ElemType num)
    	{
    		if (size()==0)//空链表特判
    		{
    			empty_push(num);
    			return;
    		}
    		LinkNode<ElemType>* p = new LinkNode<ElemType>;//新建节点
    		p->data = num;//赋值
    		tail->next = p;//尾指针指向节点next赋值为p
    		tail = p;//尾指针指向p
    		return;
    	}
    	void insert_head(ElemType num)
    	{
    		if (size() == 0)//空链表特判
    		{
    			empty_push(num);
    			return;
    		}
    		LinkNode<ElemType>* p = new LinkNode<ElemType>;//新建节点
    		p->data = num;//赋值
    		p->next = head;//链接
    		head = p;
    		return;
    	}
    	bool insert_back(int place, ElemType num)
    	{
    		if (size() == 0 && place==0)//空链表特判
    		{
    			empty_push(num);
    			return true;
    		}
    		if (check_P(place) == false)//位置合法性判断
    			return false;
    		if (place == size() - 1)//尾部插入特判
    		{
    			push_back(num);
    			return true;
    		}
    		LinkNode<ElemType>* p=get_address(place);
    		LinkNode<ElemType>* p2 = new LinkNode<ElemType>;//新建
    		p2->data = num;//赋值
    		p2->next = p->next;//定位
    		p->next = p2;//链接
    		return true;
    	}
    	LinkNode<ElemType>* get_front(LinkNode<ElemType>* p)//获取一个指针的上一个,头指针和非法指针会报错.
    	{
    		LinkNode<ElemType>* p1;
    		p1 = head;
    		while (p1->next != NULL)
    		{
    			if (p1->next == p)
    				return p1;
    			p1=p1->next;
    		}
    	}
    	bool del(int i)//删除指定位置元素  。注意,没有写非法请求检查(0->n-1)
    	{
    		return del_p(get_address(i));
    	}
    	bool del_p(LinkNode<ElemType>* p)
    	{
    		if (size() == 0)
    			return false;
    		if (head == tail)
    		{
    			if (p == head)
    			{
    				delete head;
    				head = NULL;
    				tail = NULL;
    				return true;
    			}
    			else
    				return false;
    		}
    		if (p == head)
    		{
    			LinkNode<ElemType>* p1 = head->next;
    			delete head;
    			head = p1;
    			return true;
    		}
    		if (p == tail)
    		{
    			LinkNode<ElemType>* p1 = get_front(p);
    			delete p;
    			p1->next=NULL;
    			tail = p1;
    			return true;
    		}
    		LinkNode<ElemType>* p1 = get_front(p);
    		p1->next = p->next;
    		delete p;
    		return true;
    	}
    	ElemType at(int i)
    	{
    		LinkNode<ElemType>* p=get_address(i);
    		return p->data;
    	}
    	void reverse(int m, int n)//反转m->n区间
    	{
    		m++, n++;
    		LinkNode<ElemType>* newHead = new LinkNode<ElemType>;
    		newHead->next = head;
    		LinkNode<ElemType>* p = newHead;
    		for (int i = 0; i < m - 1; i++)
    			p = p->next;
    		LinkNode<ElemType>* start = p->next;
    		LinkNode<ElemType>* t = start->next;
    		if (n == size())
    		{
    			tail = start;
    		}
    		for (int i = m; i < n; i++)
    		{
    			start->next = t->next;
    			t->next = p->next;
    			p->next = t;
    			t = start->next;
    		}
    		head = newHead->next;
    		return;
    	}
    	LinkList<ElemType>* get_head(void)
    	{
    		return head;
    	}
    	LinkList<ElemType>* get_tail(void)
    	{
    		return head;
    	}
    	void pick(LinkList<ElemType> &lis)
    	{
    		tail->next=lis.head;
    		tail = lis.tail;
    		return;
    	}
    };
    //LinkList<int> a;
    //===============================================================
    vector<int> departString_int(string data)
    {
    	vector<int> back_part;//output type
    	int i, j;
    	vector<string> part;
    	string A_part;
    	stringstream room;
    	room.str(data);
    	while (room >> A_part)
    		part.push_back(A_part);
    	for (i = 0; i < part.size(); i++)
    	{
    		int num_cahe;
    		num_cahe = atoi(part[i].c_str());
    		back_part.push_back(num_cahe);
    	}
    	return back_part;
    }
    vector<double> departString_double(string data)
    {
    	vector<double> back_part;//output type
    	int i, j;
    	vector<string> part;
    	string A_part;
    	stringstream room;
    	room.str(data);
    	while (room >> A_part)
    		part.push_back(A_part);
    	for (i = 0; i < part.size(); i++)
    	{
    		double num_cahe;
    		num_cahe = atof(part[i].c_str());
    		back_part.push_back(num_cahe);
    	}
    	return back_part;
    }
    vector<char> departString_char(string data)
    {
    	vector<char> back_part;//output type
    	int i, j;
    	vector<string> part;
    	string A_part;
    	stringstream room;
    	room.str(data);
    	while (room >> A_part)
    		part.push_back(A_part);
    	for (i = 0; i < part.size(); i++)
    	{
    		char num_cahe;
    		num_cahe = part[i].at(0);
    		back_part.push_back(num_cahe);
    	}
    	return back_part;
    }
    vector<string> departString_string(string data)
    {
    	vector<int> back_part;//output type
    	int i, j;
    	vector<string> part;
    	string A_part;
    	stringstream room;
    	room.str(data);
    	while (room >> A_part)
    		part.push_back(A_part);
    	return part;
    }
    //===================================================
    
    template<class ElemType>
    void Purge_Lk_OL(LinkList<ElemType>& A)
    {
    	int i=0, j=0;
    	for (i = 0; i < A.size()-1;)
    	{
    		if (A.at(i) == A.at(i + 1))
    			A.del(i);
    		else
    			i++;
    	}
    	A.have_look();
    }
    
    //===================================================
    int main()
    {
    	int i, j;
    	int kinds;
    	string s1, s2;
    	int m;
    	//数值类型输入判断
    	cin >> kinds;
    	if (kinds != 0 && kinds != 1 && kinds != 2 && kinds != 3)
    	{
    		cout << "err" << endl;
    		return 0;
    	}
    	cin.get();
    	vector<int> I_1, I_2;
    	vector<double> D_1, D_2;
    	vector<char> C_1, C_2;
    	vector<string> S_1, S_2;
    	
    	LinkList<int> LI_1, LI_2;
    	LinkList<double> LD_1, LD_2;
    	LinkList<char> LC_1, LC_2;
    	LinkList<string> LS_1, LS_2;
    	//---------------
    	getline(cin, s1);
    	if (kinds == 0)
    		I_1 = departString_int(s1);
    	if (kinds == 1)
    		D_1 = departString_double(s1);
    	if (kinds == 2)
    		C_1 = departString_char(s1);
    	if (kinds == 3)
    		S_1 = departString_string(s1);
    	//--------------
    	/*getline(cin, s2);
    	if (kinds == 0)
    		I_2 = departString_int(s2);
    	if (kinds == 1)
    		D_2 = departString_double(s2);
    	if (kinds == 2)
    		C_2 = departString_char(s2);
    	if (kinds == 3)
    		S_2 = departString_string(s2);*/
    	//--------------
    	if (kinds == 0)
    	{
    		for (i = 0; i < I_1.size(); i++)
    			LI_1.push_back(I_1[i]);
    	}
    	if (kinds == 1)
    	{
    		for (i = 0; i < D_1.size(); i++)
    			LD_1.push_back(D_1[i]);
    	}
    	if (kinds == 2)
    	{
    		for (i = 0; i < C_1.size(); i++)
    			LC_1.push_back(C_1[i]);
    	}
    	if (kinds == 3)
    	{
    		for (i = 0; i < S_1.size(); i++)
    			LS_1.push_back(S_1[i]);
    	}
    	//--------------
    	/*if (kinds == 0)
    	{
    		for (i = 0; i < I_2.size(); i++)
    			LI_2.push_back(I_2[i]);
    	}
    	if (kinds == 1)
    	{
    		for (i = 0; i < D_2.size(); i++)
    			LD_2.push_back(D_2[i]);
    	}
    	if (kinds == 2)
    	{
    		for (i = 0; i < C_2.size(); i++)
    			LC_2.push_back(C_2[i]);
    	}
    	if (kinds == 3)
    	{
    		for (i = 0; i < S_2.size(); i++)
    			LS_2.push_back(S_2[i]);
    	}*/
    	//--------------
    	if (kinds == 0)
    		LI_1.have_look();
    	if (kinds == 1)
    		LD_1.have_look();
    	if (kinds == 2)
    		LC_1.have_look();
    	if (kinds == 3)
    		LS_1.have_look();
    	//--------------
    	//if (kinds == 0)
    	//	LI_2.have_look();
    	//if (kinds == 1)
    	//	LD_2.have_look();
    	//if (kinds == 2)
    	//	LC_2.have_look();
    	//if (kinds == 3)
    	//	LS_2.have_look();
    	//--------------
    	cout << endl;
    	//+++++++++++++++++++++++++
    	/*if (kinds == 0)
    		Merge_L_Order(LI_1, LI_2);
    	if (kinds == 1)
    		Merge_L_Order(LD_1, LD_2);
    	if (kinds == 2)
    		Merge_L_Order(LC_1, LC_2);
    	if (kinds == 3)
    		Merge_L_Order(LS_1, LS_2);*/
    	if (kinds == 0)
    		Purge_Lk_OL(LI_1);
    	if (kinds == 1)
    		Purge_Lk_OL(LD_1);
    	if (kinds == 2)
    		Purge_Lk_OL(LC_1);
    	if (kinds == 3)
    		Purge_Lk_OL(LS_1);
    	return 0;
    }
    //===============================================================
    

     

    展开全文
  • 并在此基础上,使用单链表ADT的基本操作,设计并实现单链表的简单算法设计。 内容:(1)请使用模板设计单链表的抽象数据类型。(由于该环境目前仅支持单文件的编译,故将所有内容都集中在一个源文件内。在实际的...
  • 并在此基础上,使用单链表ADT的基本操作,设计并实现单链表的简单算法设计。 内容: (1)请使用模板设计单链表的抽象数据类型。(由于该环境目前仅支持单文件的编译,故将所有内容都集中在一个源文件内。在实际的...
  • 并在此基础上,使用单链表ADT的基本操作,设计并实现单链表的简单算法设计。 内容:(1)请使用模板设计单链表的抽象数据类型。(由于该环境目前仅支持单文件的编译,故将所有内容都集中在一个源文件内。在实际的...
  • 并在此基础上,使用单链表ADT的基本操作,设计并实现单链表的简单算法设计。 内容: (1)请使用模板设计单链表的抽象数据类型。(由于该环境目前仅支持单文件的编译,故将所有内容都集中在一个源文件内。在实际的...
  • 并在此基础上,使用单链表ADT的基本操作,设计并实现单链表的简单算法设计。 内容:(1)请使用模板设计单链表的抽象数据类型。(由于该环境目前仅支持单文件的编译,故将所有内容都集中在一个源文件内。在实际的...
  • 并在此基础上,使用单链表ADT的基本操作,设计并实现单链表的简单算法设计。 内容: (1)请使用模板设计单链表的抽象数据类型。(由于该环境目前仅支持单文件的编译,故将所有内容都集中在一个源文件内。在实际的...
  • 并在此基础上,使用单链表ADT的基本操作,设计并实现单链表的简单算法设计。 内容:(1)请使用模板设计单链表的抽象数据类型。(由于该环境目前仅支持单文件的编译,故将所有内容都集中在一个源文件内。在实际的...
  • 并在此基础上,使用单链表ADT的基本操作,设计并实现单链表的简单算法设计。 内容:(1)请使用模板设计单链表的抽象数据类型。(由于该环境目前仅支持单文件的编译,故将所有内容都集中在一个源文件内。在实际的...
  • 并在此基础上,使用单链表ADT的基本操作,设计并实现单链表的应用算法设计。 内容:(1)请使用模板设计单链表的抽象数据类型。(由于该环境目前仅支持单文件的编译,故将所有内容都集中在一个源文件内。在实际的...
  • 并在此基础上,使用单链表ADT的基本操作,设计并实现单链表的简单算法设计。 内容:(1)请使用模板设计单链表的抽象数据类型。(由于该环境目前仅支持单文件的编译,故将所有内容都集中在一个源文件内。在实际的...
  • 并在此基础上,使用单链表ADT的基本操作,设计并实现单链表的应用算法设计。 内容: (1)请使用模板设计单链表的抽象数据类型。(由于该环境目前仅支持单文件的编译,故将所有内容都集中在一个源文件内。在实际的...
  • 4 单链表ADT模板简单应用算法设计:单链表中前 m 个元素和后 n 个元素的互换 作者: 冯向阳时间限制: 1S章节: DS:线性表 问题描述 : 目的:使用C++模板设计单链表的抽象数据类型(ADT)。并在此基础上,使用单链表ADT...
  • 并在此基础上,使用单链表ADT的基本操作,设计并实现单链表的简单算法设计。 内容:(1)请使用模板设计单链表的抽象数据类型。(由于该环境目前仅支持单文件的编译,故将所有内容都集中在一个源文件内。在实际的...
  • 并在此基础上,使用单链表ADT的基本操作,设计并实现单链表的简单算法设计。 内容:(1)请使用模板设计单链表的抽象数据类型。(由于该环境目前仅支持单文件的编译,故将所有内容都集中在一个源文件内。在实际的...
  • 单链表ADT实现

    千次阅读 2018-10-29 00:13:48
    单链表的定义: 单链表的实现: 链表使用: 单链表的定义: LinkedList.h文件 #ifndef LINKEDLIST_H_ #define LINKEDLIST_H_ #include <iostream> #define OK 1 #define ERROR 0 typedef int ElemType; ...
  • 并在此基础上,使用单链表ADT的基本操作,设计并实现单链表的简单算法设计。 内容:(1)请使用模板设计单链表的抽象数据类型。(由于该环境目前仅支持单文件的编译,故将所有内容都集中在一个源文件内。在实际的...
  • 并在此基础上,使用单链表ADT的基本操作,设计并实现单链表的简单算法设计。 内容:(1)请使用模板设计单链表的抽象数据类型。(由于该环境目前仅支持单文件的编译,故将所有内容都集中在一个源文件内。在实际的...
  • 并在此基础上,使用单链表ADT的基本操作,设计并实现单链表的简单算法设计。 内容:(1)请使用模板设计单链表的抽象数据类型。(由于该环境目前仅支持单文件的编译,故将所有内容都集中在一个源文件内。在实际的...
  • 并在此基础上,使用单链表ADT的基本操作,设计并实现单链表的简单算法设计。 内容:(1)请使用模板设计单链表的抽象数据类型。(由于该环境目前仅支持单文件的编译,故将所有内容都集中在一个源文件内。在实际的...
  • /* * Created by Dev-c++5.11 ...* @description: 单链表操作 */#include <stdio.h> #include <stdlib.h> /*函数状态码*/ #define TRUE 1 //成功 #define OK 1 #define FALSE 0 //失败 #defin
  • #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include <time.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int Status;...type...

空空如也

空空如也

1 2 3 4 5 ... 13
收藏数 255
精华内容 102
关键字:

单链表adt