zoukankan      html  css  js  c++  java

  • 15个算法题目

    　　1:合并排序，将两个已经排序的数组合并成一个数组，其中一个数组能容下两个数组的所有元素;

    　　2:合并两个单链表;

    　　3:倒序打印一个单链表;

    　　4:给定一个单链表的头指针和一个指定节点的指针，在O(1)时间删除该节点;

    　　5:找到链表倒数第K个节点;

    　　6:反转单链表;

    　　7:通过两个栈实现一个队列;

    　　8:二分查找;

    　　9:快速排序;

    　　10:获得一个int型的数中二进制中的个数;

    　　11:输入一个数组，实现一个函数，让所有奇数都在偶数前面;

    　　12:判断一个字符串是否是另一个字符串的子串;

    　　13:把一个int型数组中的数字拼成一个串，这个串代表的数字最小;

    　　14:输入一颗二叉树，输出它的镜像（每个节点的左右子节点交换位置）;

    　　15:输入两个链表，找到它们第一个公共节点;

    　　下面简单说说思路和代码实现。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    //链表节点
    struct NodeL
    {
        int value;
        NodeL* next;
        NodeL(int value_=0,NodeL* next_=NULL):value(value_),next(next_){}
    };
    //二叉树节点
    struct NodeT
    {
        int value;
        NodeT* left;
        NodeT* right;
        NodeT(int value_=0,NodeT* left_=NULL,NodeT* right_=NULL):value(value_),left(left_),right(right_){}
    };

    　　1:合并排序，将两个已经排序的数组合并成一个数组，其中一个数组能容下两个数组的所有元素;

    　　合并排序一般的思路都是创建一个更大数组C，刚好容纳两个数组的元素，先是一个while循环比较，将其中一个数组A比较完成，将另一个数组B中所有 的小于前一个数组A的数及A中所有的数按顺序存入C中，再将A中剩下的数存入C中，但这里是已经有一个数组能存下两个数组的全部元素，就不用在创建数组 了，但只能从后往前面存，从前往后存，要移动元素很麻烦。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    //合并排序，将两个已经排序的数组合并成一个数组，其中一个数组能容下两个数组的所有元素
    void MergeArray(int a[],int alen,int b[],int blen)
    {
        int len=alen+blen-1;
        alen--;
        blen--;
        while (alen>=0 && blen>=0)
        {
            if (a[alen]>b[blen])
            {
                a[len--]=a[alen--];
            }else{
                a[len--]=b[blen--];
            }
        }
     
        while (alen>=0)
        {
            a[len--]=a[alen--];
        }
        while (blen>=0)
        {
            a[len--]=b[blen--];
        }
    }
     
    void MergeArrayTest()
    {
        int a[]={2,4,6,8,10,0,0,0,0,0};
        int b[]={1,3,5,7,9};
        MergeArray(a,5,b,5);
        for (int i=0;i<sizeof(a)/sizeof(a[0]);i++)
        {
            cout<<a[i]<<" ";
        }
    }

    　　2:合并两个单链表;

    　　合并链表和合并数组，我用了大致相同的代码，就不多少了，那本书用的是递归实现。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    //链表节点
    struct NodeL
    {
        int value;
        NodeL* next;
        NodeL(int value_=0,NodeL* next_=NULL):value(value_),next(next_){}
    };
     
    //合并两个单链表
    NodeL* MergeList(NodeL* head1,NodeL* head2)
    {
        if (head1==NULL)
            return head2;
        if (head2==NULL)
            return head1;
     
        NodeL* head=NULL;
        if (head1->value<head2->value)
        {
            head=head1;
            head1=head1->next;
        }else{
            head=head2;
            head2=head2->next;
        }
        NodeL* tmpNode=head;
        while (head1 && head2)
        {
            if (head1->value<head2->value)
            {
                head->next=head1;
                head1=head1->next;
            }else{
                head->next=head2;
                head2=head2->next;
            }
            head=head->next;
        }
        if (head1)
        {
            head->next=head1;
        }
        if (head2)
        {
            head->next=head2;
        }
        return tmpNode;
    }
     
    void MergeListTest()
    {
        NodeL* head1=new NodeL(1);
        NodeL* cur=head1;
        for (int i=3;i<10;i+=2)
        {
            NodeL* tmpNode=new NodeL(i);
            cur->next=tmpNode;
            cur=tmpNode;
        }
        NodeL* head2=new NodeL(2);
        cur=head2;
        for (int i=4;i<10;i+=2)
        {
            NodeL* tmpNode=new NodeL(i);
            cur->next=tmpNode;
            cur=tmpNode;
        }
        NodeL* head=MergeList(head1,head2);
        while (head)
        {
            cout<<head->value<<" ";
            head=head->next;
        }
    }

    　　3:倒序打印一个单链表;

    　　递归实现，先递归在打印就变成倒序打印了，如果先打印在调用自己就是顺序打印了。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    //倒序打印一个单链表
    void ReversePrintNode(NodeL* head)
    {
        if (head)
        {
            ReversePrintNode(head->next);
            cout<<head->value<<endl;
        }
    }
    void ReversePrintNodeTest()
    {
        NodeL* head=new NodeL();
        NodeL* cur=head;
        for (int i=1;i<10;i++)
        {
            NodeL* tmpNode=new NodeL(i);
            cur->next=tmpNode;
            cur=tmpNode;
        }
        ReversePrintNode(head);
    }

    　　4:给定一个单链表的头指针和一个指定节点的指针，在O(1)时间删除该节点;

    　　删除节点的核心还是将这个节点的下一个节点，代替当前节点。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    //给定一个单链表的头指针和一个指定节点的指针，在O(1)时间删除该节点
    void DeleteNode(NodeL* head,NodeL* delNode)
    {
        if (!head || !delNode)
        {
            return;
        }
     
        if (delNode->next!=NULL)//删除中间节点
        {
            NodeL* next=delNode->next;
            delNode->next=next->next;
            delNode->value=next->value;
            delete next;
            next=NULL;
        }else if (head==delNode)//删除头结点
        {
            delete delNode;
            delNode=NULL;
            *head=NULL;
        }else//删除尾节点，考虑到delNode不在head所在的链表上的情况
        {
            NodeL* tmpNode=head;
            while (tmpNode && tmpNode->next!=delNode)
            {
                tmpNode=tmpNode->next;
            }
            if (tmpNode!=NULL)
            {
                delete delNode;
                delNode=NULL;
                tmpNode->next=NULL;
            }
        }
    }
     
    void DeleteNodeTest()
    {
        int nodeCount=10;
        for (int K=0;K<nodeCount;K++)
        {
            NodeL* head=NULL;
            NodeL* cur=NULL;
            NodeL* delNode=NULL;
            for (int i=0;i<nodeCount;i++)
            {
                NodeL* tmpNode=new NodeL(i);
                if (i==0)
                {
                    cur=head=tmpNode;
                }else{
                    cur->next=tmpNode;
                    cur=tmpNode;
                }
                if (i==K)
                {
                    delNode=tmpNode;
                }
            }
            DeleteNode(head,delNode) ;
        }
    }

    　　5:找到链表倒数第K个节点;

    　　通过两个指针，两个指针都指向链表的开始，一个指针先向前走K个节点，然后再以前向前走，当先走的那个节点到达末尾时，另一个节点就刚好与末尾节点相差K个节点。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    //找到链表倒数第K个节点
    NodeL* FindKthToTail(NodeL* head,unsigned int k)
    {
        if(head==NULL || k==0)
            return NULL;
        NodeL* tmpNode=head;
        for (int i=0;i<k;i++)
        {
            if (tmpNode!=NULL)
            {
                tmpNode=tmpNode->next;
            }else{
                return NULL;
            }
        }
        NodeL* kNode=head;
        while (tmpNode!=NULL)
        {
            kNode=kNode->next;
            tmpNode=tmpNode->next;
        }
        return kNode;
    }
     
    void FindKthToTailTest()
    {
        int nodeCount=10;
        for (int K=0;K<nodeCount;K++)
        {
            NodeL* head=NULL;
            NodeL* cur=NULL;
            for (int i=0;i<nodeCount;i++)
            {
                NodeL* tmpNode=new NodeL(i);
                if (i==0)
                {
                    cur=head=tmpNode;
                }else{
                    cur->next=tmpNode;
                    cur=tmpNode; 
                }
            }
            NodeL* kNode=FindKthToTail(head,K+3) ;
            if (kNode)
            {
                cout<<"倒数第 "<<K+3<<" 个节点是："<<kNode->value<<endl;
            }else{
                cout<<"倒数第 "<<K+3<<" 个节点不在链表中" <<endl;
            }
        }
    }

    　　6:反转单链表;

    　　按顺序一个个的翻转就是了。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    //反转单链表
    NodeL* ReverseList(NodeL* head)
    {
        if (head==NULL)
        {
            return NULL;
        }
        NodeL* reverseHead=NULL;
        NodeL* curNode=head;
        NodeL* preNode=NULL;
        while (curNode!=NULL)
        {
            NodeL* nextNode=curNode->next;
            if (nextNode==NULL)
                reverseHead=curNode; 
     
            curNode->next=preNode;
            preNode=curNode;
            curNode=nextNode;
        }
        return reverseHead;
    }
     
    void ReverseListTest()
    {
        for (int K=0;K<=10;K++)
        {
            NodeL* head=NULL;
            NodeL* cur=NULL;
            for (int i=0;i<K;i++)
            {
                NodeL* tmpNode=new NodeL(i);
                if (i==0)
                {
                    cur=head=tmpNode;
                }else{
                    cur->next=tmpNode;
                    cur=tmpNode; 
                }
            }
     
            cur=ReverseList( head);
            while (cur)
            {
                cout<<cur->value<<" ";
                cur=cur->next;
            }
            cout<<endl;
        }
        cout<<endl;
    }

    　　7:通过两个栈实现一个队列;

    　　直接上代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    //通过两个栈实现一个队列
    template<typename T>
    class CQueue
    {
    public:
        void push(const T& val)
        {
            while (s2.size()>0)
            {
                s1.push(s2.top());
                s2.pop();
            }
            s1.push(val);
        }
        void pop()
        {
            while (s1.size()>0)
            {
                s2.push(s1.top());
                s1.pop();
            }
            s2.pop();
        }
     
        T& front()
        {
            while (s1.size()>0)
            {
                s2.push(s1.top());
                s1.pop();
            }
            return s2.top();
        }
        int size()
        {
            return s1.size()+s2.size();
        }
    private:
        stack<T> s1;
        stack<T> s2;
    };
     
    void CQueueTest()
    {
        CQueue<int> q;
        for (int i=0;i<10;i++)
        {
            q.push(i);
        }
        while (q.size()>0)
        {
            cout<<q.front()<<" ";
            q.pop();
        }
    }

    　　8:二分查找;

    　　二分查找记住几个要点就行了，代码也就那几行，反正我现在是可以背出来了，start=0，end=数组长度-1，while(start<=end)，注意溢出

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    //二分查找
    int binarySearch(int a[],int len,int val)
    {
        int start=0;
        int end=len-1;
        int index=-1;
        while (start<=end)
        {
            index=start+(end-start)/2;
            if (a[index]==val)
            {
                return index;
            }else if (a[index]<val)
            {
                start=index+1;
            }else
            {
                end=index-1;
            }
        }
        return -1;
    }

    　　9:快速排序;

    　　来自百度百科，说不清楚

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    //快速排序
    //之前有个面试叫我写快排，想都没想写了个冒泡,思路早忘了，这段代码来自百度百科
    void Qsort(int a[],int low,int high)
    {
        if(low>=high)
        {
            return;
        }
        int first=low;
        int last=high;
        int key=a[first];//用字表的第一个记录作为枢轴
        while(first<last)
        {
            while(first<last && a[last]>=key )--last;
            a[first]=a[last];//将比第一个小的移到低端
            while(first<last && a[first]<=key )++first;
            a[last]=a[first];//将比第一个大的移到高端
        }
        a[first]=key;//枢轴记录到位
        Qsort(a,low,first-1);
        Qsort(a,last+1,high);
    }
     
    void QsortTest()
    {
        int a[]={1,3,5,7,9,2,4,6,8,0};
        int len=sizeof(a)/sizeof(a[0])-1;
        Qsort(a,0,len);
        for(int i=0;i<=len;i++)
        {
            cout<<a[i]<<" ";
        }
        cout<<endl;
    }

    　　10:获得一个int型的数中二进制中的个数;

    　　核心实现就是while (num= num & (num-1))，通过这个数和比它小1的数的二进制进行&运算，将二进制中1慢慢的从后往前去掉，直到没有。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    //获得一个int型的数中二进制中1的个数
    int Find1Count(int num)
    {
        if (num==0)
        {
            return 0;
        }
        int count=1;
        while (num= num & (num-1))
        {
            count++;
        }
        return count;
    }

    　　11:输入一个数组，实现一个函数，让所有奇数都在偶数前面;

    　　两个指针，一个从前往后，一个从后往前，前面的指针遇到奇数就往后走，后面的指针遇到偶数就往前走，只要两个指针没有相遇，就奇偶交换。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    //输入一个数组，实现一个函数，让所有奇数都在偶数前面
    void RecordOddEven(int A[],int len)
    {
        int i=0,j=len-1;
        while (i<j)
        {
            while (i<len && A[i]%2==1)
                i++;
     
            while (j>=0 && A[j]%2==0)
                j--;
     
            if (i<j)
            {
                A[i]^=A[j]^=A[i]^=A[j];
            }
        }
    }
     
    void RecordOddEvenTest()
    {
        int A[]={1,2,3,4,5,6,7,8,9,0,11};
        int len=sizeof(A)/sizeof(A[0]);
        RecordOddEven( A , len);
        for (int i=0;i<len;i++)
        {
            cout<<A[i]<<" ";
        }
        cout<<endl;
        for (int i=0;i<len;i++)
        {
            A[i]=2;
        }
        RecordOddEven( A , len);
        for (int i=0;i<len;i++)
        {
            cout<<A[i]<<" ";
        }
        cout<<endl;
        for (int i=0;i<len;i++)
        {
            A[i]=1;
        }
        RecordOddEven( A , len);
        for (int i=0;i<len;i++)
        {
            cout<<A[i]<<" ";
        }
    }

    　　12:判断一个字符串是否是另一个字符串的子串;

    　　我这里就是暴力的对比

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    //判断一个字符串是否是另一个字符串的子串
    int substr(const char* source,const char* sub)
    {
        if (source==NULL || sub==NULL)
        {
            return -1;
        }
        int souLen=strlen(source);
        int subLen=strlen(sub);
        if (souLen<subLen)
        {
            return -1;
        }
     
        int cmpCount=souLen-subLen;
        for (int i=0;i<=cmpCount;i++)
        {
            int j=0;
            for (;j<subLen;j++)
            {
                if (source[i+j]!=sub[j])
                {
                    break;
                }
            }
            if (j==subLen)
            {
                return i ;
            }
        }
        return -1;
    }

    　　13:把一个int型数组中的数字拼成一个串，这个串代表的数字最小;

    　　先将数字转换成字符串存在数组中，在通过qsort排序，在排序用到的比较函数中，将要比较的两个字符串进行组合，如要比较的两个字符串分别是 A,B，那么组合成，A+B，和B+A，在比较A+B和B+A，返回strcmp(A+B, B+A)，经过qsort这么一排序,数组就变成从小到大的顺序了，组成的数自然是最小的。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    //把一个int型数组中的数字拼成一个串，是这个串代表的数组最小
    #define MaxLen 10
    int Compare(const void* str1,const void* str2)
    {
        char cmp1[MaxLen*2+1];
        char cmp2[MaxLen*2+1];
        strcpy(cmp1,*(char**)str1);
        strcat(cmp1,*(char**)str2);
     
        strcpy(cmp2,*(char**)str2);
        strcat(cmp2,*(char**)str1);
        return strcmp(cmp1,cmp2);
    } 
    void GetLinkMin(int a[],int len)
    {
        char** str=(char**)new int[len];
        for (int i=0;i<len;i++)
        {
            str[i]=new char[MaxLen+1];
            sprintf(str[i],"%d",a[i]);
        }
     
        qsort(str,len,sizeof(char*),Compare);
        for (int i=0;i<len;i++)
        {
            cout<<str[i]<<" ";
            delete[] str[i] ;
        }
        delete[] str;
    }
    void GetLinkMinTest()
    {
        int arr[]={123,132,213,231,321,312};
        GetLinkMin(arr,sizeof(arr)/sizeof(int));
    }

    　　14:输入一颗二叉树，输出它的镜像（每个节点的左右子节点交换位置）;

    　　递归实现，只要某个节点的两个子节点都不为空，就左右交换，让左子树交换，让右子树交换。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    struct NodeT
    {
        int value;
        NodeT* left;
        NodeT* right;
        NodeT(int value_=0,NodeT* left_=NULL,NodeT* right_=NULL):value(value_),left(left_),right(right_){}
    };
     
    //输入一颗二叉树，输出它的镜像（每个节点的左右子节点交换位置）
    void TreeClass(NodeT* root)
    {
        if( root==NULL || (root->left==NULL && root->right==NULL) )
            return;
        NodeT* tmpNode=root->left;
        root->left=root->right;
        root->right=tmpNode;
        TreeClass(root->left);
        TreeClass(root->right);
    }
     
    void PrintTree(NodeT* root)
    {
        if(root)
        {
            cout<<root->value<<" ";
            PrintTree(root->left);
            PrintTree(root->right);
        }
    }
     
    void TreeClassTest()
    {
        NodeT* root=new NodeT(8);
        NodeT* n1=new NodeT(6);
        NodeT* n2=new NodeT(10);
        NodeT* n3=new NodeT(5);
        NodeT* n4=new NodeT(7);
        NodeT* n5=new NodeT(9);
        NodeT* n6=new NodeT(11);
        root->left=n1;
        root->right=n2;
        n1->left=n3;
        n1->right=n4;
        n2->left=n5;
        n2->right=n6;
        PrintTree(root);
        cout<<endl;
        TreeClass( root );
        PrintTree(root);
        cout<<endl;
    }

    　　15:输入两个链表，找到它们第一个公共节点;

    　　如果两个链表有公共的节点，那么第一个公共的节点及往后的节点都是公共的。从后往前数N个节点（N=短链表的长度节点个数）,长链表先往前走K个节点 （K=长链表的节点个数-N），这时两个链表都距离末尾N个节点，现在可以一一比较了，最多比较N次，如果有两个节点相同就是第一个公共节点，否则就没有 公共节点。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    //输入两个链表，找到它们第一个公共节点
    int GetLinkLength(NodeL* head)
    {
        int count=0;
        while (head)
        {
            head=head->next;
            count++;
        }
        return count;
    }
     
    NodeL* FindFirstEqualNode(NodeL* head1,NodeL* head2)
    {
        if (head1==NULL || head2==NULL)
            return NULL;
        int len1=GetLinkLength(head1);
        int len2=GetLinkLength(head2);
        NodeL* longNode;
        NodeL* shortNode;
        int leftNodeCount;
        if (len1>len2)
        {
            longNode=head1;
            shortNode=head2;
            leftNodeCount=len1-len2;
        }else{
            longNode=head2;
            shortNode=head1;
            leftNodeCount=len2-len1;
        }
        for (int i=0;i<leftNodeCount;i++)
        {
            longNode=longNode->next;
        }
        while (longNode && shortNode && longNode!=shortNode)
        {
            longNode=longNode->next;
            shortNode=shortNode->next;
        }
        if (longNode)//如果有公共节点，必不为NULL
        {
            return longNode;
        }
        return NULL; 
    }
     
    void FindFirstEqualNodeTest()
    {
        NodeL* head1=new NodeL(0);
        NodeL* head2=new NodeL(0);
        NodeL* node1=new NodeL(1);
        NodeL* node2=new NodeL(2);
        NodeL* node3=new NodeL(3);
        NodeL* node4=new NodeL(4);
        NodeL* node5=new NodeL(5);
        NodeL* node6=new NodeL(6);
        NodeL* node7=new NodeL(7);
     
        head1->next=node1;
        node1->next=node2;
        node2->next=node3;
        node3->next=node6;//两个链表相交于节点node6
     
        head2->next=node4;
        node4->next=node5;
        node5->next=node6;//两个链表相交于节点node6
        node6->next=node7;
     
        NodeL* node= FindFirstEqualNode(head1,head2);
        if (node)
        {
            cout<<node->value<<endl;
        }else{
            cout<<"没有共同节点"<<endl;
        }
    }
  • 相关阅读:
    多变的鸭子策略模式
    反序列化和序列化
    UBUNTU eclipse必须是 jdk5.0以上
    Ubuntu Linux：MySQL安装指南
    phpMyAdmin下载、安装和使用入门
    读者－写者问题
    wget用法2
    在linux下安装mysql
    linux下数字转成字符串
    [SQLServer]必须知道的SQL
  • 原文地址：https://www.cnblogs.com/zhaoshuireshui/p/3793837.html
Copyright © 2011-2022 走看看