指針和引用的區別
指針指向一塊內存，它的內容是指向內存的地址；引用是某內存的別名
引用使用是無需解引用，指針需解引用
引用不能為空，指針可以為空
引用在定義是被初始化一次，之后不可變；指針可變
程序為指針變量分配內存區域，而引用不需要分配內存區域
memcpy和strcpy的區別
memcpy用來內存拷貝的，它有指定的拷貝數據長度，他可以拷貝任何數據類型的對象
Strcpy它只能去拷貝字符串，它遇到’\0′結束拷貝
new和malloc的區別，free和delete的區別
malloc與free是C++/C語言的標准庫函數，new/delete是C++的運算符。它們都可用於申請動態內存和釋放內存。
對於非內部數據類型的對象而言，光用maloc/free無法滿足動態對象的要求。對象在創建的同時要自動執行構造函數，對象在消亡之前要自動執行析構函數。由於malloc/free是庫函數而不是運算符，不在編譯器控制權限之內，不能夠把執行構造函數和析構函數的任務強加於malloc/free。
因此C++語言需要一個能完成動態內存分配和初始化工作的運算符new，以及一個能完成清理與釋放內存工作的運算符delete。注意new/delete不是庫函數。
struct和class的區別
1.成員變量
結構在默認情況下的成員是公共(public)的,
而類在默認情況下的成員是私有(private)的。
2.存儲
struct保證成員按照聲明順序在內存中存儲。class不保證等等
3.繼承
struct A { }；
class B : A{ }; //private繼承
struct C : B{ }； //public繼承
這是由於class默認是private，struct默認是public。
struct與union的區別.(一般假定在32位機器上)
1．一個union類型的變量，所有成員變量共享一塊內存，該內存的大小有這些成員變量中長度最大的一個來決定，struct中成員變量內存都是獨立的
2．union分配的內存是連續的，而struct不能保證分配的內存是連續的
隊列和棧有什么區別？
隊列先進先出，棧后進先出
指針在16位機、32位機、64位機分別占用多少個字節
16位機 2字節
32位機 4字節
64位機 8字節
如何引用一個已經定義過的全局變量？
extern
可以用引用頭文件的方式，也可以用extern關鍵字，如果用引用頭文件方式來引用某個在頭文件中聲明的全局變理，假定你將那個變寫錯了，那么在編譯期間會報錯，如果你用extern方式引用時，假定你犯了同樣的錯誤，那么在編譯期間不會報錯，而在連接期間報錯
全局變量可不可以定義在可被多個.C文件包含的頭文件中？為什么？
可以，在不同的C文件中以static形式來聲明同名全局變量。
可以在不同的C文件中聲明同名的全局變量，前提是其中只能有一個C文件中對此變量賦初值，此時連接不會出錯
語句for( ；1 ；)有什么問題？它是什么意思？
for( ；1 ；)和while(1)相同。
do……while和while……do有什么區別？
前一個循環一遍再判斷，后一個判斷以后再循環
請寫出下列代碼的輸出內容
#include<stdio.h>
main()
{
int a,b,c,d;
a=10;
b=a++;
c=++a;
d=10*a++;
printf(“b，c，d：%d，%d，%d”，b，c，d）;
return 0;
}
10，12，120
對於一個頻繁使用的短小函數,在C語言中應用什么實現,在C++中應用什么實現?
c用宏定義，c++用inline
main 函數執行以前，還會執行什么代碼？
全局對象的構造函數會在main 函數之前執行。
main 主函數執行完畢后，是否可能會再執行一段代碼，給出說明？
可以，可以用on_exit 注冊一個函數，它會在main 之后執行int fn1(void), fn2(void), fn3(void), fn4 (void);
void main( void )
{
String str(“zhanglin”);
on_exit( fn1 );
on_exit( fn2 );
on_exit( fn3 );
on_exit( fn4 );
printf( “This is executed first.\n” );
}
int fn1()
{
printf( “next.\n” );
return 0;
}
int fn2()
{
printf( “executed ” );
return 0;
}
int fn3()
{
printf( “is ” );
return 0;
}
int fn4()
{
printf( “This ” );
return 0;
}
The on_exit function is passed the address of a function (func) to be called when the program terminates normally. Successive calls to on_exit create a register of functions that are executed in LIFO (last-in-first-out) order. The functions passed to on_exit cannot take parameters.
This is executed next.
局部變量能否和全局變量重名？
能，局部會屏蔽全局。要用全局變量，需要使用”::”
局部變量可以與全局變量同名，在函數內引用這個變量時，會用到同名的局部變量，而不會用到全局變量。對於有些編譯器而言，在同一個函數內可以定義多個同名的局部變量，比如在兩個循環體內都定義一個同名的局部變量，而那個局部變量的作用域就在那個循環體內
描述內存分配方式以及它們的區別?
1．從靜態存儲區域分配。內存在程序編譯的時候就已經分配好，這塊內存在程序的整個運行期間都存在。例如全局變量，static 變量。
2． 在棧上創建。在執行函數時，函數內局部變量的存儲單元都可以在棧上創建，函數執行結束時這些存儲單元自動被釋放。棧內存分配運算內置於處理器的指令集。
3． 從堆上分配，亦稱動態內存分配。程序在運行的時候用malloc 或new 申請任意多少的內存，程序員自己負責在何時用free 或delete 釋放內存。動態內存的生存期由程序員決定，使用非常靈活，但問題也最多。
類成員函數的重載、覆蓋和隱藏區別？
1.成員函數被重載的特征：
（1）相同的范圍（在同一個類中）；
（2）函數名字相同；
（3）參數不同；
（4）virtual 關鍵字可有可無。
2.覆蓋是指派生類函數覆蓋基類函數，特征是：
（1）不同的范圍（分別位於派生類與基類）；
（2）函數名字相同；
（3）參數相同；
（4）基類函數必須有virtual 關鍵字。
3.”隱藏”是指派生類的函數屏蔽了與其同名的基類函數，規則如下：
（1）如果派生類的函數與基類的函數同名，但是參數不同。此時，不論有無virtual關鍵字，基類的函數將被隱藏（注意別與重載混淆）。
（2）如果派生類的函數與基類的函數同名，並且參數也相同，但是基類函數沒有virtual 關鍵字。此時，基類的函數被隱藏（注意別與覆蓋混淆）
static有什么用途？（請至少說明兩種）
1.限制變量的作用域
2.設置變量的存儲域
請說出const與#define 相比，有何優點？
1．const 常量有數據類型，而宏常量沒有數據類型。編譯器可以對前者進行類型安全檢查。而對后者只進行字符替換，沒有類型安全檢查，並且在字符替換可能會產生意料不到的錯誤。
2．有些集成化的調試工具可以對const 常量進行調試，但是不能對宏常量進行調試。
堆棧溢出一般是由什么原因導致的？
沒有回收垃圾資源
簡述數組與指針的區別？
數組要么在靜態存儲區被創建（如全局數組），要么在棧上被創建。指針可以隨時指向任意類型的內存塊。
(1)修改內容上的差別
char a[] = “hello”;
a[0] = ‘X’;
char *p = “world”; // 注意p 指向常量字符串
p[0] = ‘X’; // 編譯器不能發現該錯誤，運行時錯誤
(2) 用運算符sizeof 可以計算出數組的容量（字節數）。sizeof(p),p 為指針得到的是一個指針變量的字節數，而不是p 所指的內存容量。C++/C 語言沒有辦法知道指針所指的內存容量，除非在申請內存時記住它。注意當數組作為函數的參數進行傳遞時，該數組自動退化為同類型的指針。
char a[] = “hello world”;
char *p = a;
cout<< sizeof(a) << endl; // 12 字節
cout<< sizeof(p) << endl; // 4 字節
計算數組和指針的內存容量
void Func(char a[100])
{
cout<< sizeof(a) << endl; // 4 字節而不是100 字節
}
There are two int variables: a and b, don’t use “if”, “? :”, “switch”or other judgement statements, find out the biggest one of the two numbers.
( ( a + b ) + abs( a – b ) ) / 2
冒泡排序算法的時間復雜度是什么？
O(n^2)
什么函數不能聲明為虛函數？
構造函數（Constructor）
變量在內存中存放的位置
全局變量 全局靜態區
全局靜態變量 全局靜態區
全局常量
有初始化 代碼區
無初始化 全局靜態區
局部變量 堆棧區
局部靜態變量 靜態區
局部常量 堆棧區
new和malloc分配空間 堆區
進程間通信方式
管道（有名管道，無名管道），共享內存，消息隊列，信號量，socket通信
線程同步方式
臨界區：通過對多線程的串行化來訪問公共資源或一段代碼，速度快，適合控制數據訪問
互斥量：為協調共同對一個共享資源的單獨訪問而設計
信號量（PV操作）：為控制一個具有有限數量用戶資源而設計
事件：用來通知線程有一些事件已
進程和線程的區別
資源：進程是擁有資源的一個獨立單位，線程是不擁有資源。
調度：線程作為調度和分配的基本單位，進程是作為資源的基本單位
並發性：進程之間可以有並發性進行，同一個進程中的多個線程是可以並發執行
系統開銷：進程在創建和撤銷的時候，由於系統要分配和回收資源，導致系統的開銷明顯大於線程
一個進程可以擁有多個線程。
局部變量和全局變量能否重名
能，局部屏蔽全局。在C++里使用全局，需要使用”：：”。在C語言里，extern
虛函數和純虛函數的區別
虛函數必須實現，純虛函數沒有實現
虛函數在子類里可以不重載，但是純虛函數必須在每一個子類里去實現
在動態內存分配的時候，析構函數必須是虛函數，但沒有必要是純虛函數
面向對象的三大特性（四大特性）
封裝、繼承、多態（抽象）
封裝：把客觀事物封裝成抽象的類，並且類可以把自己的數據和方法只讓可信的類或者對象操作，對不可信的進行信息隱藏
繼承：子類可以擁有父類的屬性和方法，但父類沒有子類的屬性和方法
多態：允許將子類類型的指針賦值給父類類型的指針
實現多態，有二種方式，覆蓋，重載
覆蓋，是指子類重新定義父類的虛函數的做法
重載，是指允許存在多個同名函數，而這些函數的參數表不同（或許參數個數不同，或許參數類型不同，或許兩者都不同）
vi編輯器打開時跳到指定的行
vi +5000 filename
int型在Touble C里占多少個字節
2個字節
判斷一個單鏈表是否有環
兩個指針指向鏈表頭，一個指針每次走一步，另一個指針每次走兩步，若有一個指針先指向為NULL表示這個鏈表無環。若兩個指針重合表示鏈表有環
刷新緩沖區方式?
換行刷新緩沖區
printf(“\n”);
使用函數刷新緩沖區
fflush(stdout);
程序結束刷新緩沖區
return 0;
類和對象的兩個基本概念什么？
對象就是對客觀事物在計算機中的抽象描述。
類就是對具體相似屬性和行為的一組對象的統一描述。
類的包括：類說明和類實現兩大部分：
類說明提供了對該類所有數據成員和成員函數的描述。
類實現提供了所有成員函數的實現代碼。
數據庫三范式
第一范式：沒有重復的列
第二范式：非主屬的部分依賴於主屬部分
第三范式：屬性部分不依賴於其他非主屬部分
ASSERT( )是干什么用的
是在調試程序使用的一個宏，括號里面要滿足，如果不滿足，程序將報告錯誤，並將終止執行。
如果只想讓程序有一個實例運行，不能運行兩個。像winamp一樣，只能開一個窗口，怎樣實現？
用內存映射或全局原子（互斥變量）、查找窗口句柄
FindWindow，互斥，寫標志到文件或注冊表,共享內存
如何截取鍵盤的響應，讓所有的’a’變成’b’？
鍵盤鈎子SetWindowsHookEx
網絡編程中設計並發服務器，使用多進程 與 多線程 ，請問有什么區別？
1．進程：子進程是父進程的復制品。子進程獲得父進程數據空間、堆和棧的復制品。
2．線程：相對與進程而言，線程是一個更加接近與執行體的概念，它可以與同進程的其他線程共享數據，但擁有自己的棧空間，擁有獨立的執行序列。
兩者都可以提高程序的並發度，提高程序運行效率和響應時間。
線程和進程在使用上各有優缺點：線程執行開銷小，但不利於資源管理和保護；而進程正相反。同時，線程適合於在SMP機器上運行，而進程則可以跨機器遷移。
編程
字符串實現
strcat
char *strcat(char *strDes, const char *strSrc)
{
assert((strDes != NULL) && (strSrc != NULL));
char *address = strDes;
while (*strDes != ‘\0′)
++ strDes;
while ((*strDes ++ = *strSrc ++) != ‘\0′)
NULL;
return address;
}
strncat
char *strncat(char *strDes, const char *strSrc, int count)
{
assert((strDes != NULL) && (strSrc != NULL));
char *address = strDes;
while (*strDes != ‘\0′)
++ strDes;
while (count — && *strSrc != ‘\0′ )
*strDes ++ = *strSrc ++;
*strDes = ‘\0′;
return address;
}
strcmp
int strcmp(const char *s, const char *t)
{
assert(s != NULL && t != NULL);
while (*s && *t && *s == *t)
{
++ s;
++ t;
}
return (*s – *t);
}
strncmp
int strncmp(const char *s, const char *t, int count)
{
assert((s != NULL) && (t != NULL));
while (*s && *t && *s == *t && count –)
{
++ s;
++ t;
}
return (*s – *t);
}
strcpy
char *strcpy(char *strDes, const char *strSrc)
{
assert((strDes != NULL) && (strSrc != NULL));
char *address = strDes;
while ((*strDes ++ = *strSrc ++) != ‘\0′)
NULL;
return address;
}
strncpy
char *strncpy(char *strDes, const char *strSrc, int count)
{
assert(strDes != NULL && strSrc != NULL);
char *address = strDes;
while (count — && *strSrc != ‘\0′)
*strDes ++ = *strSrc ++;
return address;
}
strlen
int strlen(const char *str)
{
assert(str != NULL);
int len = 0;
while (*str ++ != ‘\0′)
++ len;
return len;
}
strpbrk
char *strpbrk(const char *strSrc, const char *str)
{
assert((strSrc != NULL) && (str != NULL));
const char *s;
while (*strSrc != ‘\0′)
{
s = str;
while (*s != ‘\0′)
{
if (*strSrc == *s)
return (char *) strSrc;
++ s;
}
++ strSrc;
}
return NULL;
}
strstr
char *strstr(const char *strSrc, const char *str)
{
assert(strSrc != NULL && str != NULL);
const char *s = strSrc;
const char *t = str;
for (; *t != ‘\0′; ++ strSrc)
{
for (s = strSrc, t = str; *t != ‘\0′ && *s == *t; ++s, ++t)
NULL;
if (*t == ‘\0′)
return (char *) strSrc;
}
return NULL;
}
strcspn
int strcspn(const char *strSrc, const char *str)
{
assert((strSrc != NULL) && (str != NULL));
const char *s;
const char *t = strSrc;
while (*t != ‘\0′)
{
s = str;
while (*s != ‘\0′)
{
if (*t == *s)
return t – strSrc;
++ s;
}
++ t;
}
return 0;
}
strspn
int strspn(const char *strSrc, const char *str)
{
assert((strSrc != NULL) && (str != NULL));
const char *s;
const char *t = strSrc;
while (*t != ‘\0′)
{
s = str;
while (*s != ‘\0′)
{
if (*t == *s)
break;
++ s;
}
if (*s == ‘\0′)
return t – strSrc;
++ t;
}
return 0;
}
strrchr
char *strrchr(const char *str, int c)
{
assert(str != NULL);
const char *s = str;
while (*s != ‘\0′)
++ s;
for (– s; *s != (char) c; — s)
if (s == str)
return NULL;
return (char *) s;
}
strrev
char* strrev(char *str)
{
assert(str != NULL);
char *s = str, *t = str, c;
while (*t != ‘\0′)
++ t;
for (– t; s < t; ++ s, — t)
{
c = *s;
*s = *t;
*t = c;
}
return str;
}
strnset
char *strnset(char *str, int c, int count)
{
assert(str != NULL);
char *s = str;
for (; *s != ‘\0′ && s – str < count; ++ s)
*s = (char) c;
return str;
}
strset
char *strset(char *str, int c)
{
assert(str != NULL);
char *s = str;
for (; *s != ‘\0′; ++ s)
*s = (char) c;
return str;
}
strtok
char *strtok(char *strToken, const char *str)
{
assert(strToken != NULL && str != NULL);
char *s = strToken;
const char *t = str;
while (*s != ‘\0′)
{
t = str;
while (*t != ‘\0′)
{
if (*s == *t)
{
*(strToken + (s – strToken)) = ‘\0′;
return strToken;
}
++ t;
}
++ s;
}
return NULL;
}
strupr
char *strupr(char *str)
{
assert(str != NULL);
char *s = str;
while (*s != ‘\0′)
{
if (*s >= ‘a’ && *s <= ‘z’)
*s -= 0×20;
s ++;
}
return str;
}
strlwr
char *strlwr(char *str)
{
assert(str != NULL);
char *s = str;
while (*s != ‘\0′)
{
if (*s >= ‘A’ && *s <= ‘Z’)
*s += 0×20;
s ++;
}
return str;
}
memcpy
void *memcpy(void *dest, const void *src, int count)
{
assert((dest != NULL) && (src != NULL));
void *address = dest;
while (count –)
{
*(char *) dest = *(char *) src;
dest = (char *) dest + 1;
src = (char *) src + 1;
}
return address;
}
memccpy
void *memccpy(void *dest, const void *src, int c, unsigned int count)
{
assert((dest != NULL) && (src != NULL));
while (count –)
{
*(char *) dest = *(char *) src;
if (* (char *) src == (char) c)
return ((char *)dest + 1);
dest = (char *) dest + 1;
src = (char *) src + 1;
}
return NULL;
}
memchr
void *memchr(const void *buf, int c, int count)
{
assert(buf != NULL);
while (count –)
{
if (*(char *) buf == c)
return (void *) buf;
buf = (char *) buf + 1;
}
return NULL;
}
memcmp
int memcmp(const void *s, const void *t, int count)
{
assert((s != NULL) && (t != NULL));
while (*(char *) s && *(char *) t && *(char *) s == *(char *) t && count –)
{
s = (char *) s + 1;
t = (char *) t + 1;
}
return (*(char *) s – *(char *) t);
}
memmove
void *memmove(void *dest, const void *src, int count)
{
assert(dest != NULL && src != NULL);
void *address = dest;
while (count –)
{
*(char *) dest = *(char *) src;
dest = (char *) dest + 1;
src = (const char *)src + 1;
}
return address;
}
memset
void *memset(void *str, int c, int count)
{
assert(str != NULL);
void *s = str;
while (count –)
{
*(char *) s = (char) c;
s = (char *) s + 1;
}
return str;
}
strdup
char *strdup(const char *strSrc)
{
assert(strSrc != NULL);
int len = 0;
while (*strSrc ++ != ‘\0′)
++ len;
char *strDes = (char *) malloc (len + 1);
while ((*strDes ++ = *strSrc ++) != ‘\0′)
NULL;
return strDes;
}
strchr_
char *strchr_(char *str, int c)
{
assert(str != NULL);
while ((*str != (char) c) && (*str != ‘\0′))
str ++;
if (*str != ‘\0′)
return str;
return NULL;
}
strchr
char *strchr(const char *str, int c)
{
assert(str != NULL);
for (; *str != (char) c; ++ str)
if (*str == ‘\0′)
return NULL;
return (char *) str;
}
atoi
int atoi(const char* str)
{
int x=0;
const char* p=str;
if(*str==’-’||*str==’+’)
{
str++;
}
while(*str!=0)
{
if((*str>’9′)||(*str<’0′))
{
break;
}
x=x*10+(*str-’0′);
str++;
}
if(*p==’-’)
{
x=-x;
}
return x;
}
itoa
char* itoa(int val,char* buf,unsigned int radix)
{
char *bufptr;
char *firstdig;
char temp;
unsigned int digval;
assert(buf != NULL);
bufptr = buf;
if (val < 0)
{
*bufptr++ = ‘-’; val = (unsigned int)(-(int)val);
}
firstdig = bufptr;
do
{
digval =(unsigned int) val % radix; val /= radix;
if (digval > 9)
{
*bufptr++ = (char)(digval – 10 + ‘a’);
}
else
{
*bufptr++ = (char)(digval + ’0′);
}
} while(val > 0);
*bufptr– = ‘\0′;//設置字符串末尾，並將指針指向最后一個字符
do //反轉字符
{
temp = *bufptr; *bufptr = *firstdig; *firstdig = temp;
–bufptr; ++firstdig;
} while(firstdig < bufptr);
return buf;
}
String實現
已知String原型為：
class String
{
public:
//普通構造函數
String(const char *str = NULL)
//拷貝構造函數
String(const String &other)
//析構函數
~String(void);
//賦值函數
String & operator=(String &other) //oh,原題目打錯了,string可是一個關鍵字
private:
char* m_str;
unsigned m_uCount;
};
分別實現以上四個函數
//普通構造函數
String::String(const char* str)
{
if(str==NULL) //如果str為NULL，存空字符串
{
m_str = new char[1]; //分配一個字節
*m_str = ‘\0′; //賦一個’\0′
}else
{
m_str = new char[strlen(str) + 1];//分配空間容納str內容
strcpy(m_str, str); //復制str到私有成員m_str中
}
}
//析構函數
String::~String()
{
if(m_str!=NULL) //如果m_str不為NULL，釋放堆內存
{
delete [] m_str;
m_str = NULL;
}
}
//拷貝構造函數
String::String(const String &other)
{
m_str = new char[strlen(other.m_str)+1]; //分配空間容納str內容
strcpy(m_str, other.m_str); //復制other.m_str到私有成員m_str中
}
//賦值函數
String & String::operator=(String &other)
{
if(this == &other) //若對象與other是同一個對象，直接返回本身
{
return *this
}
delete [] m_str; //否則，先釋放當前對象堆內存
m_str = new char[strlen(other.m_str)+1]; //分配空間容納str內容
strcpy(m_str, other.m_str); //復制other.m_str到私有成員m_str中
return *this；
}
編寫一個二分查找的功能函數
int BSearch(elemtype a[],elemtype x,int low,int high)
/*在下屆為low，上界為high的數組a中折半查找數據元素x*/
{
int mid;
if(low>high)
return -1;
mid=(low+high)/2;
if(x==a[mid])
return mid;
if(x<a[mid])
return(BSearch(a,x,low,mid-1));
else
return(BSearch(a,x,mid+1,high));
}
2) 非遞歸方法實現：
int BSearch(elemtype a[],keytype key,int n)
{
int low,high,mid;
low=0;high=n-1;
while(low<=high)
{
mid=(low+high)/2;
if(a[mid].key==key)
return mid;
else if(a[mid].key<key)
low=mid+1;
else
high=mid-1;
}
return -1;
}
字符串逆序
方法一
#include <stdio.h>
#include <string.h>
void main()
{
char str[]=”hello,world”;
int len=strlen(str);
char t;
int i;
for(i=0; i<len/2; i++)
{
t=str[i];
str[i]=str[len-i-1];
str[len-i-1]=t;
}
printf(“%s\n”,str);
return 0;
}
方法二
#include <stdio.h>
int main(){
char* src = “hello,world”;
int len = strlen(src);
char* dest = (char*)malloc(len+1);//要為\0分配一個空間
char* d = dest;
char* s = &src[len-1];//指向最后一個字符
while( len– != 0 )
*d++=*s–;
*d = 0;//尾部要加\0
printf(“%s\n”,dest);
free(dest);// 使用完，應當釋放空間，以免造成內存匯泄露
return 0;
}
排序
冒泡排序
void bubble_sort(int a[],int n)
{
int i,j;
for(i=0;i<n-1;i++)
{
bool x=ture;
for(j=0;j<n-1-i;j++)
{
int temp;
if(a[j]>a[j+1])
{
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
x=false;
}
}
if(x) break;
}
}
時間復雜度O(N^2)
選擇排序
void select_sort(int a[],int n)
{
int i,j;
for(i=0;i<n-1;i++)
{
int min=i;
for(j=i+1;j<n;j++)
{
if(a[j]<a[min])
min=j;
if(min!=i)
{
int temp=a[j];
a[j]=a[min];
a[min]=temp;
}
}
}
}
時間復雜度O(N^2)
插入排序
void insert_sort(int a[],int n)
{
int i,j;
for(i=1;i<n;i++)
{
int x=a[i];
for(j=i;j>0&&x<a[j-1];j–)
a[j]=a[j-1];
a[j]=x;
}
}
時間復雜度O(N^2)
快速排序
void quick_sort(int a[],int ileft,int iright)
{
int iPivot=(left+right)/2;
int nPivot=a[iPivot];
for(int i=ileft,j=iright;i<j;)
{
while(!(i>=iPivot||nPivot<a[i]))
i++;
if(i<iPivot)
{
a[iPivot]=a[i];
iPivot=i;
}
while(!(j<=iPivot||nPivot>a[j]))
j–;
if(j>iPivot)
{
a[iPivot]=a[j];
iPivot=j;
}
}
a[iPivot]=nPivot;
if(iPivot-ileft>1)
quick_sort(a,ileft,iPivot-1);
if(iright-iPivot>1)
quick_sort(a,iPivot+1,iright);
}
時間復雜度O(NlogN)
鏈表
單鏈表
雙鏈表
循環鏈表
單鏈表逆置
void reverse(link *head)
{
link *p, *s, *t;
p = head;
s = p->next;
while(s->next!=NULL)
{
t = s->next;
s->next = p;
p = s;
s = t;
}
s->next = p;
head->next->next = NULL; //尾指針置為空
head->next = s; //賦值到頭指針后一位
}
鏈表合並
Node * Merge(Node *head1 , Node *head2)
{
if ( head1 == NULL)
return head2 ;
if ( head2 == NULL)
return head1 ;
Node *head = NULL ;
Node *p1 = NULL;
Node *p2 = NULL;
if ( head1->data < head2->data )
{
head = head1 ;
p1 = head1->next;
p2 = head2 ;
}else
{
head = head2 ;
p2 = head2->next ;
p1 = head1 ;
}
Node *pcurrent = head ;
while ( p1 != NULL && p2 != NULL)
{
if ( p1->data <= p2->data )
{
pcurrent->next = p1 ;
pcurrent = p1 ;
p1 = p1->next ;
}else
{
pcurrent->next = p2 ;
pcurrent = p2 ;
p2 = p2->next ;
}
}
if ( p1 != NULL )
pcurrent->next = p1 ;
if ( p2 != NULL )
pcurrent->next = p2 ;
return head ;
}
遞歸方式：
Node * MergeRecursive(Node *head1 , Node *head2)
{
if ( head1 == NULL )
return head2 ;
if ( head2 == NULL)
return head1 ;
Node *head = NULL ;
if ( head1->data < head2->data )
{
head = head1 ;
head->next = MergeRecursive(head1->next,head2);
}
else
{
head = head2 ;
head->next = MergeRecursive(head1,head2->next);
}
return head ;
}
寫一個Singleton模式
#include<iostream>
using namespace std;
class Singleton
{
private:
static Singleton* _instance;
protected:
Singleton()
{
cout<<”Singleton”<<endl;
}
public:
static Singleton* Instance()
{
if(NULL==_instance)
{
_instance=new Singleton();
}
return _instance;
}
};
static Singleton* Singleton::_instance=NULL;
int main()
{
Singleton * s =Singleton::Instance();
Singleton * s1=Singleton::Instance();
}
如何對String類型數據的某個字符進行訪問？
#include<iostream>
using namespace std;
int main()
{
string s=”abcdefg”;
const char *c=s.c_str();
while(*c!=’\0′)
{
printf(“%c”,*c++);
}
}
文件加密、解密
1.加密（encryption）：
#include<stdio.h>
void encryption(char *ch)
{
(*ch)^=0xFF; //算法可自行修改調整，使用AES加密算法
}
int main(int argc,char *argv[])
{
if(argc<2)
{
printf(“參數不足”);
return -1;
}
//文件的打開（fopen函數）
/*
r read 只讀
w write 只寫
a append 追加
t text 文本文件，可省略不寫
b banary 二進制文件
+ 讀和寫
*/
a.out a.c b.txt
argv[0] argv[1] argv[2]
FILE* fpr=NULL;
FILE* fpw=NULL;
//文件打開失敗返回一個空指針值NULL
if(NULL==(fpr=fopen(argv[1],”r”))){printf(“%m\n”);return -1;}
if(NULL==(fpw=fopen(argv[2],”w+”))){printf(“%m\n”);return -1;}
char ch;
while((ch=fgetc(fpr))!=EOF)
{
//putchar(ch);
encryption(&ch);//加密函數
printf(“%c”,ch);//加密后字符顯示
fputc(ch,fpw);//存放進文件
}
printf(“\n文件加密成功！\n”);
//文件的關閉(fclose函數)
fclose(fpr);
fclose(fpw);
}
2.解密（decryption）：
#include<stdio.h>
#include<time.h>
void show()
{
time_t start=time(NULL);
while(start==time(NULL));
}
void decryption(char ch)
{
(*ch)^=0xFF;//算法可自行修改調整
}
int main(int argc,char *argv[])
{
if(argc<2)
{
printf(“參數不足”);
return -1;
}
//文件的打開（fopen函數）
/*
r read 只讀
w write 只寫
a append 追加
t text 文本文件，可省略不寫
b banary 二進制文件
+ 讀和寫
*/
FILE* fpr=NULL;
FILE* fpw=NULL;
//文件打開失敗返回一個空指針值NULL
if(NULL==(fpr=fopen(argv[1],”r”))){printf(“%m\n”);return -1;}
if(NULL==(fpw=fopen(argv[2],”w+”))){printf(“%m\n”);return -1;}
char ch;
printf(“開始解密！\n”);
while((ch=fgetc(fpr))!=EOF)
{
show();
ch=decryption(ch);//解密函數
printf(“%c”,ch);//解密后字符顯示
fputc(ch,fpw);//存放進文件
fflush(stdout);//刷新顯示
}
printf(“\n文件解密成功！\n”);
//文件的關閉(fclose函數)
fclose(fpr);
fclose(fpw);
}
斐波那契數列（Fibonacci sequence）
int Funct( int n )
{
if( n==0 || n==1 ) return 1;
retrurn Funct(n-1) + Funct(n-2);
}
