《算法与数据结构 （C++语言版）》算法设计题目总结——线性表

1. 已知线性表按序存于内存中，每个元素都是整数，设计用最少时间把所有值为负数的元素移到全部正数值元素前面的算法。

 思路：利用快速排序的思想，以最左侧记录作为枢轴，“j”从右向左扫描小于0的元素，“i”从左向右扫描大于等于0的元素。

算法代码如下：

SeqList Rearrange(SeqList a)
{	
    int i,j,t;
	i=0;
    j=a.Last-1; // i,j为工作指针(下标)	
	t=a.data[0]; // 暂存枢轴元素。
	while(i<j)
	{	
        while(i<j && a.data[j]>=0) 
            j--; // j指针前移找小于0的元素
		if(i<j) 
            a.data[i++]=a.data[j]; // 将负数前移
		while(i<j && a.data[i]<0)
            i++; // i指针后移找大于等于0的元素
		if(i<j) 
            a.data[j--]=a.data[i]; // 正数后移
	}
	a.data[i]=t; // 将原第一元素放到最终位置
	return a;
} 

2. 去除一个递增有序的链表中的重复元素。

思路：利用tra(遍历指针)遍历链表、com(比较指针)判断是否为相同数值、del(起删除作用的指针)越过相同元素直接指向下一个元素，以起到删除作用。算法时间复杂度为O(n)。

算法代码如下：

template<class elemType>
void linkList<elemType>::del_same()
 {
    if (head == NULL)
        return;
    Node * tra, * com, * del;
    tra = head;
    while (tra != NULL) 
    { 
        del = tra;
        com = tra->next;

        while (com != NULL) 
        { 
            if (tra->data == com->data) 
            {
                del->next = com->next;
                com = com->next;
            }
            else 
            {
                del = com;
                com = com->next;
            }
        }
        tra = tra->next;
    }
    cout << "已删除重复元素" << endl;
}

3. 设la是一个双向循环链表，其中元素递增有序，设计算法插入元素x，使表中元素依然递增有序。

重点——将新结点链入双向循环链表的四个步骤：

1. 新结点的前驱指针 指向 后结点的前驱指针；
2. 新结点的后继指针 指向 后结点；
3. 后结点的前驱指针指向的前结点的后继指针 指向 新结点；
4. 后结点的前驱指针 指向 新结点。

DLinkedList DInsert(DLinkedList la, ElemType x)
{	
    p=la->next; // p指向第一元素
	la->data=MaxElemType; // MaxElemType是和x同类型的机器最大值，用做监视哨
	while(p->data < x) // 寻找插入位置
		p=p->next;
	s=(DLNode *)malloc(sizeof(DLNode)); // 申请结点空间
	s->data=x;

    // 将插入的结点链入链表
	s->prior=p->prior; 
	s->next=p;
	p->prior->next=s; 
	p->prior=s;
}

4. 假定采用带头结点的单链表保存单词，当两个单词有相同的后缀时，可共享相同的存储空间，例如"loading"和"being"的相同部分为"ing"，设str1和str2分别指向两个单词所在链表的头结点，设计算法找出两个链表共同后缀的起始位置。

思路：

①分别求出str1和str2所指的两个链表的长度m和n；

②将两个链表以表尾对齐：即长的链表将指针移到|m-n+1|,短链表的指针指向链表的第一个字母；

③两个链表进行模式匹配：对应字母比较，从最后遇到两个链表结点值相等，直至到表尾对应结点值都相等为止。要注意处理虽然首次遇到对应结点值相等，但有后续结点值不等的情况,即在匹配中，并非一遇到对应字母相等，就结论后边是共同后缀。

typedef struct Node
{	
    ElemType data;
    struct Node *next;  
} LNode,*LinkedList；

int ListLength(LNode * la)
{
    // 求链表la的长度
    int i=0;
    LNode *p=la->next; // p指向链表的第一个元素结点
    while(p)
    {    
        i++; // 元素个数加1
        p=p->next; // 链表指针后移 
    }
    return i; // 返回链表的长度
}

LNode * ComPostfix(LNode * str1, LNode * str2)
{
    // str1和str2分别是单词以单链表存储的头指针，本算法返回两个单词共同后缀的起始位置
    p=null; // p指向两个链表共同后缀的起始位置
    m=ListLength(str1); 
    n=ListLength(str2); // 求链表str1和str2的长度
    if(m>n) 
    {		
        s=str1->next; // s指向长链表的第一个元素
       	q=srt2->next; // q指向短链表的第一个元素
       	len=m-n+1; // 两个链表开始比较时，长链表应移到的位置
    }
    else
    {		
        s=str2->next; // s指向长链表的第一个元素
        q=srt1->next; // q指向短链表的第一个元素
        len=n-m+1; // 两个链表比较时，长链表应移到的位置
    }
    i=1;
    while(i<len)
    {    
         i++; 
         s=s->next;  
    } // 长链表要移到两个链表尾部对齐的位置
    while(s)
    {     
        while(s && s->data != q->data) // 对应字母不等，后移指针
	        {	
                s=s->next; 
                q=q->next; 
            }
        p=s; // p指向两个链表共同后缀的起始位置
        while(s && s->data==q->data) // 如对应字母相等，后移指针
            {	
                s=s->next; 
                q=q->next; 
            }
    }
    return p; // 返回两个链表共同后缀的起始位置
}

算法中求了两个链表的长度，接着将长链表的指针移到两链表的比较处，进行对应元素的比较，记住可能共同后缀的开始位置，直到链表尾。总的时间复杂度为O(m+n)。

5. 用单链表保存m个整数（|data|<n），设计算法，对于链表中绝对值相等的结点，仅保留第一次出现的结点而删除其余绝对值相等的结点。

思路：定义一个大小为N的数组，初始化为0。在遍历链表的同时将数组中索引值为节点的值的绝对值的元素置1。如果此元素已经为1，说明此节点之前已经有与此节点的值的绝对值相等的节点，需将此节点删除。

int a[n]; // 全局数组,标志节点的绝对值的值是否出现过
typedef struct Node // 节点的数据结构定义
{
    int data;
    Struct Node * next;
}Node;

void DeleteABSEqualNode(Node * head)
{	
    memset(a,0,n); // 初始化为0 
	if (head == NULL) 
        return NULL;	
	Node * p = head;	
    Node * r = head;
	while (p != NULL)
	{	
        if (a[abs(p->data)] == 1) // 如果此绝对值已经在数组中出现过，则删除
		{	
            r->next = p->next;  
            delete p;   
            p = r->next;  
        }
		else // 否则，将数组中对应的元素置1
		{	
            a[abs(p->data)] = 1;  
            r = p;  
            p = p->next;  
        }
	}
	return head;
}

只遍历一次链表，所以时间复杂度为O(n)；因为申请了大小为n的数组，所以空间复杂度为O(n)（n为节点绝对值的最大值）。