数据结构与算法练习题

题目1：将2个递增的有序链表合并为一个有序链表；要求结果链表仍然使用两个链表的存储空间，不另外占用其他的存储空间，表中不允许有重复的数据。

解题思路：
1、新链表C使用A链表的头结点做为起始；
2、比较AB链表中的数据，若A中的数据元素比B小，则将C的next指向A的数据元素，链表A指针向下一个数据元素移动；
3、若A中的数据元素比B大，则将C的next指向B的数据元素，链表B指针向下一个数据元素移动；
4、若AB中数据元素相同，则将C的next指向A的数据元素，链表A指针向下一个数据元素移动，同时将B中的数据元素释放；
5、若AB链表长度不相同，则将A或B中剩下的数据元素直接添加到C链表中；

void MergeList(LinkList *La, LinkList *Lb, LinkList *Lc){
    LinkList pa, pb, pc, temp;
    pa = (*La)->next;
    pb = (*Lb)->next;
    pc = (*Lc) = (*La);
    
    while(pa && pb){
        if(pa->data < pb->data){
            pc->next = pa;
            pc = pc->next;
            pa = pa->next;
        }
        else if(pa->data > pb->data){
            pc->next = pb;
            pc = pc->next;
            pb = pb->next;
        }
        else{
            pc->next = pa;
            pc = pc->next;
            pa = pa->next;
            temp = pb->next;
            free(pb);
            pb = temp;
        }
    }
    if(pa){
        pc->next = pa;
    }
    else{
        pc->next = pb;
    }
    free(*Lb);
}

题目2：已知两个链表A和B分别表示两个集合，其元素递增排列，设计一个算法，用于求出A与B的交集，并存储在A链表中。

解题思路：
与题目1类似，题目1是求并集，题目2是求交集。
1、新链表C使用A链表的头结点做为起始，并将链表C中头结点的next指向null；
2、比较AB链表中的数据，若A中的数据元素比B小，将链表A中当前数据元素删除（即释放），指针指向下一个数据元素；
3、若A中的数据元素比B大，将链表B中当前数据元素删除（即释放），指针指向下一个数据元素；
4、若A中的数据元素与B相同，将链表A的当前元素添加至链表C的next，并将链表B中当前数据元素删除（即释放），AB链表指针都指向下一个数据元素；
5、若AB链表长度不一致，则将A或B链表剩下的数据元素释放。并将链表C的最后一个next指向null；

void Intersection(LinkList *La, LinkList *Lb, LinkList *Lc){
    LinkList pa, pb, pc, temp;
    pa = (*La)->next;
    pb = (*Lb)->next;
    (*Lc) = pc = (*La);
    while(pa && pb){
        if(pa->data == pb->data){
            pc->next = pa;
            pc = pa;
            pa = pa->next;
            temp = pb;
            pb = pb->next;
            free(temp);
        }
        else if(pa->data > pb->data){
            temp = pb;
            pb = pb->next;
            free(temp);
        }
        else if(pa->data < pb->data){
            temp = pa;
            pa = pa->next;
            free(temp);
        }
    }
    
    pc->next = NULL;
    
    while(pa){
        temp = pa->next;
        free(pa);
        pa = temp;
    }
    while(pb){
        temp = pb->next;
        free(pb);
        pb = temp;
    }
    free(*Lb);
}

题目3：设计一个算法,将链表中所有节点的链接方向"原地旋转"，即要求仅仅利用原表的存储空间。换句话说，要求算法空间复杂度为O(1)；

解题思路：
重点：头插法是一个逆序的链表。如将{1，2，3，4，5}进行头插法插入链表，得到的链表为{5，4，3，2，1}。利用此技巧，可将链表进行原地旋转。

void Inverse(LinkList *La){
    LinkList p = (*La)->next;
    (*La)->next = NULL;
    while(p){
        LinkList temp = p->next;
        p->next = (*La)->next;
        (*La)->next = p;
        p = temp;
    }
}

题目4：设计一个算法，删除递增有序链表中值大于等于mink且小于等于maxk(mink，maxk是给定的两个参数，其值可以和表中的元素相同，也可以不同)的所有元素；
示例：链表A{2，3，4， 5， 6，8， 10}，mink = 4， maxk = 8。结果为{2，3，10}

解题思路：
1、找到并记录链表中mink位置（data 2、找到mark（data<=mark）结点的后一个结点，记录该结点为pMark；
3、将pre的next指向pMark的next；
4、遍历pMink和pMark中间的数据元素，并将其删除；

void DeleteMinMax(LinkList *L, int mink, int maxk){
    if(*L == NULL) return;
    LinkList pre, pMink, pMaxk, temp;
    pre = (*L);
    while(pre->next && pre->next->data < mink){
        pre = pre->next;
    }
    pMink = pre->next;
    pMaxk = pMink;
    while(pMaxk && pMaxk->data <= maxk){
        pMaxk = pMaxk->next;
    }
    
    pre->next = pMaxk;
    while(pMink != pMaxk){
        temp = pMink;
        pMink = pMink->next;
        free(temp);
    }
}

题目5：设将n(n>1)个整数存放到一维数组R中，试设计一个在时间和空间两方面都尽可能高效的算法;将R中保存的序列循环左移p个位置(0 示例：pre[10] = {0,1,2,3,4,5,6,7,8,9}，n = 10，p = 3；结果为pre[10] = {3,4,5,6,7,8,9,0,1,2}

解题思路：
1、记录数组0位置的元素，将数组的所有元素全部往前移动一个位置；
2、将记录的数据写入到数组的末尾；
3、循环p次；
4、算法复杂度为O（n*p）；

//算法复杂度O(p*n)
void LeftShift(int *pre,int n,int p){
    for(int i= 1; i<=p;i++){
        int p = pre[0];
        for(int j = 1; j

老师的解题思路：
1、先将n个数据原地逆置 9,8,7,6,5,4,3,2,1,0；
2、将n个数据拆解成[9,8,7,6,5,4,3] [2,1,0]；
3、将前n-p个数据和后p个数据分别原地逆置; [3,4,5,6,7,8,9] [0,1,2]；
4、算法复杂度O（n）

void Reverse(int *pre,int left ,int right){
    int i = left, j = right;
    while(i <= j){
        int temp = pre[j];
        pre[j] = pre[i];
        pre[i] = temp;
        i ++;
        j --;
    }
}

void LeftShift(int *pre,int n,int p){
    Reverse(pre, 0, n-1);
    Reverse(pre, 0, n-p-1);
    Reverse(pre, n-p, n-1);
}

题目6：已知一个整数序列A = (a0,a1,a2,...an-1)，其中(0<= ai <=n)，(0<= i<=n)。若存在ap1= ap2 = ...= apm = x，且m>n/2(0<=pk

解题思路：
重点思想：判断一个数是否为主元素，则这个数据元素在链表中至少有1次是重复出现的。否则不满足大于n/2这个条件。
1、选取候选主元素，从前向后依次扫描数组中的每个整数，假定第一个整数为主元素，将其保存在Key中，计数为1，若遇到下一个整数仍然等于key，则计数加1，否则计数减1，当计数减到0时，将遇到的下一个整数保存到key中，计数重新记为1，开始新一轮计数，即可从当前位置开始重上述过程，直到将全部数组元素扫描一遍；
2、判断key中的元素是否是真正的主元素，再次扫描数组，统计key中元素出现的次数，若大于n/2，则为主元素，否则序列中不存在主元素；

int MainElement(int *A, int n){
    int i = 0;
    int key = A[0];
    int count = 1;
    for(i = 1; i  n/2){
        return key;
    }
    return -1;
}

题目7：用单链表保存m个整数，结点的结构为(data,link)，且|data|<=n(n为正整数)。现在要去设计一个时间复杂度尽可能高效的算法。对于链表中的data 绝对值相等的结点，仅保留第一次出现的结点,而删除其余绝对值相等的结点。例如：链表A = {21,-15,15,-7,15}，删除后的链表A={21,-15,-7}；

解题思路：
多个数据查重高效的办法类似于key=value的形式。将需要查重的值设置为key值，如果出现，将value值设置为1。若后续继续出现，则可通过该key的value值进行判断。

void DeleteEqualNode(LinkList *L,int n){
    LinkList p = (*L);
    int *flag = (int*)calloc(n, sizeof(int));
    while (p->next != NULL) {
        NSLog(@"%d", p->next->data);
        if(flag[abs(p->next->data)] == 1){
            LinkList temp = p->next;
            p->next = p->next->next;
            free(temp);
        }
        else{
            flag[abs(p->next->data)] = 1;
            p = p->next;
        }
    }
}

总结：自己对算法的解题思路了解的太少，拿到题目之后完全不知道如何下手，不懂如何分析题目，拆解题目，定位题目中的关键字。例如原地旋转那题，如果不是老师点醒头插法，可能现在仍然还在想各种算法复杂度很高的办法。后期需要培养这种算法思路，通过多去刷刷题，看看大神的解题思路。