算法笔试题

 

10月的某个周六在真维斯楼参加了一场笔试。有两个题目有点意思，记述如下。

 

1. 有n个范围是0~n*n-1的整数，对这n个数进行排序，要求时空间复杂度都尽量优化。

一看题目就知道是桶式排序或者基数排序，但是由于没有复习这方面的内容，考试的时候居然没有想到如何下手。

算法思想：基数排序。把这些数看成是n进制的，根据数的范围可知，每个数最多2位。申请n个桶，依次对高位和低位进行两次桶式排序即可。

代码如下：

//基于数组的基数排序

void RadixSort(int *data, int n)
{
 int *dup = (int*)malloc(sizeof(int)*(n+1));
 int *count = (int*)malloc(sizeof(int)*(n+1));

 int i;
 int r,k;
 for (r=1; r<=10; r=r*10)
 {
  //把桶清空
  for (i = 0; i < n;i++)
  {
   count[i] = 0;
  }
  //记录落到每个桶的数的个数
  for (i = 0; i < n; i++)
  {
   k = data[i]/r;
   k = k % 10;
   ++count[k];
  }
  //计算位置
  for (i = 1; i < n; i++)
  {
   count[i] += count[i-1];
  }
  //下标从0开始
  for ( i = 0; i < n; i++)
  {
   --count[i];
  }
  //完成本趟排序
  for ( i = n - 1; i >= 0; i--)
  {
   k = data[i]/r;
   k = k % 10;
   dup[count[k]] = data[i];
   count[k]--;
  }
  //复制回原数组
  for ( i = 0; i < n; i++)
  {
   data[i] = dup[i];
  }

 }

 delete dup;
 delete count;

 return;
}

 

2. 复制链表。链表中的每个结点有两个指针，一个指针指向下一个结点，一个指针指向链表中的任意结点。

算法思想：分3步走。

(1)生成每个结点的新结点，插入对应结点之后

(2)原结点的pAny指针指向的结点的下一个结点就是新结点的pAny指针应指向的结点

(3)解链

代码如下：

struct Node
{
 int value;
 Node *pNext;
 Node *pAny;
};

Node* copyList(Node *pHead)
{
 if ( !pHead )
 {
  return NULL;
 }

 Node *pCur = pHead;
 Node *pCopy;
 Node *pNewHead;

 //生成每个结点的新结点，插入对应结点之后
 while(pCur)
 {
  pCopy = new Node;
  pCopy->value = pCur->value;
  pCopy->pNext = pCur->pNext;
  pCur->pNext = pCopy;
  pCur = pCopy->pNext;
 }

 pCur = pHead;
 //原结点的pAny指针指向的结点的下一个结点就是新结点的pAny指针应指向的结点
 while(pCur)
 {
  pCopy = pCur->pNext;
  pCopy->pAny = pCur->pAny->pNext;
  pCur = pCopy->pNext;
 }

 //解链
 pCur = pHead;
 pNewHead = pCur->pNext;
 while(pCur)
 {
  pCopy = pCur->pNext;
  pCur->pNext = pCopy->pNext;
  pCur = pCopy->pNext;
  pCopy->pNext = pCur->pNext;
 }

 return pNewHead;
}