C++，数据结构-CSDN博客

1.用C++写个程序，如何判断一个操作系统是16位还是32位的？不能用sizeof()函数

A1:
16位的系统下，
int i = 65536;
cout << i; // 输出0；
int i = 65535;
cout << i; // 输出-1；

32位的系统下，
int i = 65536;
cout << i; // 输出65536；
int i = 65535;
cout << i; // 输出65535；

A2:

int a = ~0;
if( a>65536 )
{
cout<<"32 bit"<<endl;
}
else
{
cout<<"16 bit"<<endl;

}

2.在不用第三方参数的情况下，交换两个参数的值
#include <stdio.h>

void main()
{
int i=60;
int j=50;
i=i+j;
j=i-j;
i=i-j;
printf("i=%d\n",i);
printf("j=%d\n",j);
}

方法二：
i^=j;
j^=i;
i^=j;

方法三：
// 用加减实现，而且不会溢出
a = a+b-(b=a)

3.struct A
{
char t:4;
char k:4;
unsigned short i:8;
unsigned long m;
}
sizeof(A)=?（不考虑边界对齐）

这题各种答案都有，有的说是6，有的说是7，我自己在VC++6.0上跑了一下是8；

union a {
int a_int1;
double a_double;
int a_int2;
};

typedef struct
{
a a1;
char y;
} b;

class c
{
double c_double;
b b1;
a a2;

};

输出cout<<sizeof(c)<<endl;的结果?

注意结构体的边界对齐。

答:
VC6环境下得出的结果是32

.程序改错
class mml
{
private:
static unsigned int x;
public:
mml(){ x++; }
mml(static unsigned int &) {x++;}
~mml{x--;}
pulic:
virtual mon() {} = 0;
static unsigned int mmc(){return x;}
......

};
class nnl:public mml
{
private:
static unsigned int y;
public:
nnl(){ x++; }
nnl(static unsigned int &) {x++;}
~nnl{x--;}
public:
virtual mon() {};
static unsigned int nnc(){return y;}
......
};

代码片断:
mml* pp = new nnl;
..........
delete pp;

A:
基类的析构函数应该为虚函数
virtual ~mml{x--;}

strncpy()和memcpy()的区别：

strncpy()字符串，memcpy()拷贝内存内容.

strncpy
原型：extern char *strncpy(char *dest, char *src, int n);

用法：#include <string.h>

功能：把src所指由NULL结束的字符串的前n个字节复制到dest所指的数组中。

说明：
如果src的前n个字节不含NULL字符，则结果不会以NULL字符结束。
如果src的长度小于n个字节，则以NULL填充dest直到复制完n个字节。
src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。
返回指向dest的指针。

memcpy
原型：extern void *memcpy(void *dest, void *src, unsigned int count);

用法：#include <string.h>

功能：由src所指内存区域复制count个字节到dest所指内存区域。

说明：src和dest所指内存区域不能重叠，函数返回指向dest的指针。

单链表逆序的递归与非递归算法（转）

#include <iostream>

using namespace std;

struct Node
{
int data ;
Node *next ;
};
typedef struct Node Node ;

Node* ReverseList(Node* head)
{
if (!head || !head->next)
{
return head;
}
Node* p1 = head;
Node* p2 = p1->next;
head->next = NULL;
while (p2)
{

p1 = p2;
p2 = p2->next;
p1->next = head;
head = p1;
}
return head;
}

Node* RecReverseList(Node* head) //递归方法
{
if (!head || !head->next)
{
return head;
}
Node *newhead = RecReverseList(head->next);
head->next->next = head;
head->next = NULL;
return newhead;
}

void main()
{
Node a, b, c;
a.data = 1, a.next = &b;
b.data = 2, b.next = &c;
c.data = 3, c.next = NULL;
Node* tmp = &a;
while(tmp)
{
cout<<tmp->data<<" ";
tmp = tmp->next;
}
cout<<endl;
tmp = RecReverseList(&a);
while(tmp)
{
cout<<tmp->data<<" ";
tmp = tmp->next;
}
cout<<endl;
}

一. 链表

1. 链表中的倒数第m个元素

给定一个单向链表，请设计一个既节省时间又节省空间的算法来找出该链表中的倒数第m个元素。实现这个算法。
“倒数第m个元素”是这样规定的：当m=0时，链表的最后一个元素（尾元素）将被返回。

前进m步后启动一个“后指针”

2. 空链表和循环链表

给定一个链表，它可能是一个以"NULL"结尾的非循环链表，也可能是一个循环结构结尾的循环链表。写一个函数来判断该链表是一个循环链表还是一个非循环链表，该函数不得对链表本身做任何修改。

用两个指针，一快一慢，如果是循环链表，快的指针迟早会超过慢指针，时间复杂度：O(n)，最多也是3n .

int DetermineTermination(node *head)
{
node *fast, *slow;
fast = slow = head;
while(1){
if(!fast || !fast->next){
return 0;
}
else if(fast == slow || fast->next == slow){
return 1;
}
else {
slow = slow->next;
fast = fast->next->next;
}
}
}

二、其他

1. 字节的升序存储和降序存储方式
请编写一个函数还判断某计算机的字节存储顺序是升序(little-endian)还是降序(big-endian)。

“字节的存储顺序”指的是多字节数据的各个字节在计算机里的存储顺序。比如说用来表示整数的那4个字节的顺序，其包括两种，一是按从最低位字节（LSB）到最高位字节（MSB）的顺序进行存储；另一种是从MSB到LSB的顺序进行存储。这里说的“高位字节”指的是字（word）中的高位字节。如果字节表示的是字的低值部分，我们就说它是这个字的LSB。比如说，数值“5A6C”中的LSB就是"6C"。反过来说，“5A6C”中的MSB是 “5A”。
在一台采用字节降序存储方案的计算机里，MSB将被保存在最低位的地址里；在一台采用字节升序存储方案的计算机里，LSB将被保存在最低位的地址里。比如说，采用字节降序存储方案的计算机把十六进制值“A45C”中的"A4"保存在第一个字节里，把"5C"保存在第二个字节里；而一台采用字节升序存储方案的计算机将把“5C”保存在第一个字节里，把"A4"保存在第二个字节里。

具体到本题中，可以使用字符指针来获取某个字节中的内容。

/* Return 1 if the machine is little-endian, 0 if the
* machine is big-endian
*/
int Endianness(void)
{
int testNum;
char *ptr;

testNum = 1;
ptr = (char *)&testNum;
return (*ptr);
}

有一种更精妙的解法，利用了“union”类型：这种类型与 “struct”类似，
只是它的所有数据成员都是从内存中的同一个位置开始存储的。
这样使你能够把同样的数据当做不同的变量类型来使用。

/* Return 1 if the machine is little-endian, 0 if the
* machine is big-endian
*/
int Endianness(void)
{
union{
int theInteger;
char singleByte;
} endianTest;
endianTest.theInteger = 1;
return endianTest.singleByte;
}