C++博客-ljfpudding-文章分类-Examination

指针链表

JackLi — Sat, 03 Feb 2007 02:20:00 GMT

1) 函数merge(intNode *a, intNode *b)将两个升序链表a和b合并成一个升序链表并返回指针。

typedef struct element

{

int val;

struct element *next;

}intNode;

intNode *merge(intNode *a, intNode *b)

{

intNode * h= a; *p, *q;

while(b)

{

for(p=h;p&&p->valval; q=p; p=p->next);

if(p==h)__(1)____;

else __(2)_____;

q=b; b=b->next;

___(3)___;

}

return h;

}

提示：将b的每个元素依次插入a中

答案:

1 h=b;

2 q->next = b;

3 q->next = p;

JackLi 2007-02-03 10:20 发表评论

树与图

JackLi — Sat, 03 Feb 2007 02:19:00 GMT

1) 树的左遍历

void LeftWalkTree(node *root)

{

if(root)

printf(" %d \n", root->data);

else

return;

LeftWalkTree(root->left);

LeftWalkTree(root->right);

}

2)最低公共祖先

已知道二元搜索数上的两个节点的值，请找出他们的最低公共祖先。可以假设这两个值是存在的。函数接口如下：

int FindLowestCommonAncestor(node *root, int value1, int value2)

{

node *curNode = root;

while(1)

{

if(curNode->value > value1 && curNode->value >value2)

curNode = curNode->left;

else if(curNode->value value

curNode = curNode->right;

else

return curNode->node;

}

JackLi 2007-02-03 10:19 发表评论

生产者消费者问题

JackLi — Sat, 03 Feb 2007 02:18:00 GMT

请编写一个Producer线程和一个Consumer线程，两个线程共享着一个固定长度的缓冲区和该缓冲区上的一个读写索引index。 Producer负责把一些随即数放到缓冲区里，Consumer则负责删除这些随即数。请用C语言中的信号量来实现这个问题。

static int index =0;

static int buffer[8];

static Semaphone bufferWrite;

static Semaphone bufferNotFull;

static Semaphone bufferNotEmpty;

void Init()

{

bufferWrite = newSemaphone(1);

bufferNotFull= newSemaphone(8);

bufferNotEmpty= newSemaphone(0);

}

void Producer(void)

{

while(1)

{

wait(bufferNotFull);

wait(bufferWrite);

buffer[index]=rand();

index++;

signal(bufferWrite);

signal(bufferNotEmpty);

}

void Consumer()

{

while(1)

{

wait(bufferNotEmpty);

wait(bufferWrite);

printf("%d \n", buffer[index]);

index--;

signal(bufferWrite);

signal(bufferNotFull);

}

JackLi 2007-02-03 10:18 发表评论

删除特定字符串

JackLi — Sat, 03 Feb 2007 02:16:00 GMT

从字符串中删除指定的字符串，

如"Battle of the Vowels: Hawaii VS Grozny"

删除 "aeiou"

则最终为 "Bttl f th Vwls: Hw Vs Grzny"

void RemoveChars(char str[], char remove[])

{

int src, dst, removeArray[256];

for(src=0; src<256, src++)

removeArray[src] = 0;

src =0;

while(remove[src])

{

removeArray[remove[src]]=1;

src++;

}

src=dst=0;

{

if(!removeArray[str[src]])

str[dst++]=str[src];

}while(str[src++]);

}

JackLi 2007-02-03 10:16 发表评论

颠倒单词顺序

JackLi — Sat, 03 Feb 2007 02:15:00 GMT

如将字符串 "Do or do not, there is no try."

转换为 "try. no is there not,do or Do"

int ReverseWords(char str[])

{

char *buffer;

int tokenReadPos, wordReadPos, wordEnd, writePos = 0;

tokenReadPos = strlen(str)-1;

buffer = (char*)malloc(tokenReadPos+2);

if(!buffer)

return;

while(tokenReadPos>=0)

{

if(str[tokenReadPos] == '')

{

buffer[writePos++] = str[tokenReadPos--];

}

else

{

wordEnd = tokenReadPos;

while(tokenReadPos>=0 && str[tokenReadPos]!='')

{

tokenReadPos--;

}

wordReadPos = tokenReadPos+1;

while(wordReadPos<=wordEnd)

{

buffer[writePos++] = str[wordReadPos++];

}

buffer[writePos]='\0';

strcpy(str, buffer);

free(buffer);

return 1;

}

JackLi 2007-02-03 10:15 发表评论

strToInt 与IntToStr

JackLi — Sat, 03 Feb 2007 02:13:00 GMT

将Str转换成Int

int StrToInt(char str[])

{

int i=0;

int isNeg = 0;

int num =0;

if(str[0]=='-')

{

isNeg = 1;

i =1;

}

while(str[i])

{

num*=10;

num+= (str[i++]-'0');

}

if(isNeg)

num*= -1;

return num;

}

将Int转换成Str

#define MAX_DIGITIS_INT 10

void IntToStr(int num, char str[])

{

int i=0,j=0,isNeg=0;

char temp[MAX_DIGITIS_INT + 2];

if(num<0)

{

num*=-1;

isNeg =1;

}

{

temp[i++] = (num%10)+'0';

num /= 10;

}while(num);

if(isNeg)

temp[i++]= '-';

while(i>0)

str[j++] = temp[--i];

str[j]='\0';

}

JackLi 2007-02-03 10:13 发表评论

几种排序算法

JackLi — Sat, 03 Feb 2007 02:12:00 GMT

1）顺序表选择排序

void ss_sort(int e[], int n)

{

int i,j,k,t;

for(i=0; i

{

for(k=i, j=i+1; j

{

if( e[k] > e[j] )

k=j;

}

if(k!=i)

{

t=e[i]; e[i]=e[k]; e[k]=t;

}

选择排序共比较n(n-1)/2次，不稳定排序，如果相等的数，可能交换位置。

1-1) 堆排序

渗透函数

void sift(int e[], int n, int s)

{

int t,k,j;

t = e[s];

k=s;

j = 2*k +1;

while(j

{

if(j

j++;

if(t

{

e[k]=e[j];

k=j;

j=2*k+1;

}

else

break;

}

e[k]= t;

}

void heapsort(int e[], int n)

{

int i,k,t;

for(i=n/2-1; i>=0; i--)

{

sift(e,n,i);

}

for(k=n-1; k>=1; k--)

{

t=e[0];

e[0]=e[k];

e[k]=t;

sift(e,k,0);

}

2)顺序表直接插入排序

void insert_sort(int e[],int n)

{

int i,j;

int temp;

for(i=1; i

{

temp = e[i];

j =i ;

while( j>0 && temp>e[j-1])

{

e[j] = e[j-1];

j--;

}

e[j] = temp;

}

直接插入排序比较次数最少为n-1次，最多为n(n-1)/2次，稳定排序

对与原来排好的序列排序效率高

2-1) 希尔排序

void shell(int e[], int n)

{

int j, k, h, y;

for(h=n/2; h>0; h=h/2)

{

for(j=h; j

{

y= e[j];

for(k=j-h; k>=0 && y

{

e[k+h] = e[k];

}

e[k+h] = y;

}

3）冒泡排序

void mp_sort(int e[], int n)

{

int j,p,h,t;

for(h=n-1; h>0; h=p)

{

for(p=j=0; j

{

if(e[j]>e[j+1])

{

t = e[j];

e[j]=e[j+1];

e[j+1]= t;

p = j;

}

4)快速排序

void r_quick(int e[], int low, int high)

{

int i, j, t;

if(low

{

i =low; j = high; t= e[low];

while(i

{

while(it ) j--;

if(i

e[i++]=e[j];

while(i

if(i

e[j--]=e[i];

}

e[i]=t;

r_quick(e,low, i-1);

r_quick(e,i+1,high);

}
}

JackLi 2007-02-03 10:12 发表评论

一些试题答案

JackLi — Sat, 03 Feb 2007 02:07:00 GMT

1) 字符串全排列

int Permute(char inString[])
{
    int length = 0;
    int i=0;
    int *used=NULL;
    int *out = NULL;

   length = strlen(inString);

out = (char*)malloc( length+1);
  if(!out)
     return 0;

   out[length] = '\0';
   used = (int*)malloc( sizeof(int) * length );
   if(!used)
      return 0;

    for(i=0; i        used[i]=0;

     DoPermute( inString, out, used, length, 0 );

    free(out);
    free(used);
   return 1;
}

void DoPermute(char in[], char out[], int used[], int length, int recursLev)

{

int i;

if(recursLev == length) // base case

{

printf("%s \n", out);

return;

}

for(i =0; i< length; i++)

{

if(used[i])

continue;

out[recursLev] = in[i];

used[i]=1;

DoPermute(in, out, used, length, recursLev+1);

used[i] = 0;

}

}

2) 字符串全组合

int Combine(char inString[])

{

int length;

char *out;

length = strlen(inString);

out = (char*)malloc(length+1);

if(!out)

return 0;

DoCombine(inString, out, length, 0,0);

free(out);

return 1;

}

void DoCombine(char in[], char out[], int length, int recursLev,int start)

{

int i;

for(i=start, i

{

out[recursLev]=in[i];

out[recursLev+1] = '\0';

printf("%s \n", out);

if(i

DoCombine(in, out, length, recursLev+1, i+1);

}

}

3) 升序降序

int Endianess(void)

{

int tesNum = 1;

char *ptr =NULL;

ptr = (char*)&testNum;

return(*ptr);

}

int Endianess(void)

{

union

{

int theInteger;

char singleByte;

}endianTest;

endianTest.theInteger = 1;

return endianTest.singleByte;

}

JackLi 2007-02-03 10:07 发表评论

一些试题

JackLi — Sat, 03 Feb 2007 01:59:00 GMT

1) 请编写一个函数，用它把字符串中所有的字符的各种排列形式全部都显示出来；换句话说，用给定的字符串里的字符做全排列。

比如给定的字符串是"hat"

则输出 "tha","aht","tah","ath","hta","hat"

字符串中的每一个字符是不相干的，即使有重复出现的，也把他们当成不一样的。

如"aaa" 要输出六个 "aaa"

2）字符串的全组合
编写一个函数，用它把字符串中所有字符的各种形式组合全部都显示出来。各种组合的长度范围从一个字符到字符串的长度。不管排列顺序如何，只要两种组合的字符完全一样，则认为是同一种组合。
如 "123" "12" 和"21" 是同一种组合。

3）字节的升序存储与字节的降序存储

用一个简单函数判断计算机的存储顺序是升序(little-endian) 还是降序(big-endian)

注释：升序--高字节在高位，低字节在低位
降序--高字节在低位，低字节在高位。

JackLi 2007-02-03 09:59 发表评论

C++博客-ljfpudding-文章分类-Examination

指针链表

树与图

生产者消费者问题

删除特定字符串

颠倒单词顺序

strToInt 与IntToStr

几种排序算法

一些试题 答案

一些试题

一些试题答案