將兩個有序的單鏈表合併爲一個有序的單鏈表,默認是按升序排列的。【兩路歸併排序(升序排列) (平均/最差)時間複雜度O(NlogN)】
typedef struct _Node_t
{
struct _Node_t *next;
int data;
}Node;
Node *Merge(Node *head1, Node *head2)//時間複雜度:O(nlogn)
{
Node *head = NULL;
if (NULL == head1)
{
return head2;
}
if (NULL == head2)
{
return head1;
}
while ((NULL != head1) && (NULL != head2))
{
if (head1->data < head2->data)
{
head = head1;
head->next = Merge(head1->next, head2);
}
else
{
head = head2;
head->next = Merge(head1, head2->next);
}
}
return head;
}
判斷單鏈表中是否有環,有的話找到環的入口點
定義兩個指針slow, fast。slow指針一次走1個結點,fast指針一次走2個結點。如果鏈表中有環,那麼慢指針一定會再某一個時刻追上快指針(slow == fast)。如果沒有環,則快指針會第一個走到NULL。
class Node {
public Node next;
public Object data;
public static int sequence = 0;
}
/**
* 快慢指針
* @param head
* @return
*/
public static boolean checkCircle(Node head) {
Node fast = null;
Node slow = null;
fast = head;
slow = head;
while (true) {
// 慢指針移動一步
if (null != slow.next) {
slow = slow.next;
} else {
return false;
}
// 快指針移動兩步
if (null != fast.next && null != fast.next.next) {
fast = fast.next.next;
} else {
return false;
}
// 檢查是否相遇
if (slow == fast) {
return true;
}
}
}
定義兩個指針p, q。p每走一個結點(即一步),q則從頭一直向後走,直到q走到NULL或p, q走到同一個結點但走過的步數不相同爲止。此時q的步數就是環入口在結點中的位置。如果走到NULL則說明鏈表不存在環。
/**
* 查找環的起點
* @param head
* @return 返回元素的索引,從0開始。沒有找到返回-1
*/
public static int findCircleEntry(Node head) {
Node p = head; // 總是從頭開始
Node q = head;
int pSteps = 0;
int qSteps = 0;
while (null != q.next) {
q = q.next;
++qSteps;
// p從頭開始走
while (null != p.next) {
p = p.next;
++pSteps;
// 當p與q指向同一個結點時
if (p == q) {
// 如果走的步數不同,則這就是入口
if (pSteps != qSteps) {
return pSteps - 1;
} else {
// 走的步數相同,不是入口
break;
}
}
}
p = head; // 回到頭結點
pSteps = 0;
}
// 其中有一個指針走到了頭,說明沒有環
return -1;
}
斐波拉契數列遞歸實現的方法如下:
int Funct( int n )
{
if(n==0)
return 1;
if(n==1)
return 1;
retrurn Funct(n-1) + Funct(n-2);
}
判斷一個字符串是不是迴文
int IsReverseStr(char *aStr)
{
if(aStr==NULL)
return -1;
int i,j;
j=strlen(aStr);
int found=1;
for(i=0;i<j/2;i++)
{
if(*(aStr+i)!=*(aStr+j-i-1))
{
found=0;
break;
}
}
return found;
}
6. 關鍵字 static 的作用是什麼?這個簡單的問題很少有人能回答完全。在 C 語言中,關鍵字 static 有三個明顯 的作用:
1). 在函數體,一個被聲明爲靜態的變量在這一函數被調用過程中維持其值不 變。
2). 在模塊內(但在函數體外),一個被聲明爲靜態的變量可以被模塊內所用函 數訪問,但不能被模塊外其它函數訪問。它是一個本地的全局變量。
3). 在模塊內,一個被聲明爲靜態的函數只可被這一模塊內的其它函數調用。那 就是,這個函數被限制在聲明它的模塊的本地範圍內使用。
非 C++內建型別 A 和 B,在哪幾種情況下 B 能隱式轉化爲 A?
b. class B { operator A( ); } // B 實現了隱式轉化爲 A 的轉化
c. class A { A( const B& ); } // A 實現了 non-explicit 的參數爲 B(可以有其 他帶默認值的參數)構造函數
d. A& operator= ( const A& ); // 賦值操作,雖不是正宗的隱式類型轉換, 但也可以勉強算一個
快速排序:
1.先從數列中取出一個數作爲基準數。
2.分區過程,將比這個數大的數全放到它的右邊,小於或等於它的數全放到它的左邊。
3.再對左右區間重複第二步,直到各區間只有一個數
void quickSort(int s[], int l, int r)
{
if (l< r)
{
int i = l, j = r, x = s[l];
while (i < j)
{
while(i < j && s[j]>= x) // 從右向左找第一個小於x的數
j--;
if(i < j)
s[i++] = s[j];
while(i < j && s[i]< x) // 從左向右找第一個大於等於x的數
i++;
if(i < j)
s[j--] = s[i];
}
s[i] = x;
quickSort(s, l, i - 1); // 遞歸調用
quickSort(s, i + 1, r);
}
}