標籤

2013年8月30日 星期五

link list-小專題-記憶體管理-first fit allocation

// node structure for memory info
typedef struct MemInfo {
   unsigned begin, size;
   struct MemInfo *prev, *next;
}MemInfo;

// head node for occupied memory linked list
MemInfo *head_occupy = NULL;
// head node for un-used memory linked list
MemInfo *head_free = NULL;

MemInfo *tail_free = NULL;
// insert data to tail of the linked list
void Mem_info_insert_in_tail(unsigned begin, unsigned size)
{
   // create a new node for this data
   MemInfo *data = (MemInfo*) malloc(sizeof(MemInfo));
   data->begin = begin;
   data->size = size;

   // if there is no existing data
   if (head_free == NULL)
      head_free = tail_free = data;
   else {
      tail_free->next = data;
      data->prev = tail_free;
      data->next = NULL;
      tail_free = data;
   }
}

void Mem_info_show_list(void)
{
   MemInfo *rush = head_free;
   printf("The result is:\n");
   while (rush != NULL) {
      printf("(%d, %d) ", rush->begin, rush->size);
      rush = rush->next;
   }
   puts("");
}
// allocate a memory in a linked list by first fit
MemInfo *first_fit_mem_alloc(unsigned size)
{
   MemInfo *first_fit, *data = NULL;
   // assign this from head node for un-used memory
   first_fit = head_free;
   // find out first_fit node
   while (first_fit != NULL && first_fit->size < size)
      first_fit = first_fit->next;
   // if we could find out one
   if (first_fit != NULL) {
      // allocate memory for this data
      data = (MemInfo*) malloc(sizeof(MemInfo));
      data->begin = first_fit->begin;
      data->size = size;
      // if the size of this first fit is larger than
      // allocation, then calculate the new size
      if (first_fit->size > size) {
         first_fit->begin += size;
         first_fit->size -= size;
      }
      else {
         // judge if this is head
         if (first_fit == head_free)
            head_free = first_fit->next;
         else
            first_fit->prev->next = first_fit->next;
         // if this is not tail
         if (first_fit->next != NULL)
            first_fit->next->prev = first_fit->prev;
         free(first_fit);
      }
   } // if (first_fit != NULL)
   return data;
}

int main()
{
   unsigned begin, size;
   printf("Mem info linked list:\n");
   fin = fopen("mem_info_input", "r");
   while (fscanf(fin, "%d %d", &begin, &size) != EOF) {
      printf("(%d, %d) ", begin, size);
      Mem_info_insert_in_tail(begin, size);
   }
   Mem_info_show_list();
   first_fit_mem_alloc(1000);
   Mem_info_show_list();
   fclose(fin);

   return 0;

}

記憶體的管理,是我們在目前幾乎所有的os都會碰到的課題。因為都是多工的,也就是許多的job都會切成一小段一小段分別/管線/平行的去執行。而多個程式也會因此同時在記憶體之中allocate。但因為切分的關係,每支程式所需要的記憶體都不盡然相同。有的要42K,有的要32M,有的只需小小的0.1K。而正常的程式在執行結束之後,都會free掉記憶體。因此常常會出現中間部分的記憶體是已經free掉了,因此我們需要記錄那塊free掉的記憶體的位置以及資料,這樣才能夠利用。在這使用了linked list來當作實做的工具。這個list會有四筆資料在內。我們用了雙向的linked list於是有兩筆分別指向前(prev)與後(next)的node。然後我們還需要這個node的記憶體起始位置(begin)以及大小(size):
typedef struct MemInfo {
   unsigned begin, size;
   struct MemInfo *prev, *next;
}MemInfo;

而我們也使用了兩個串列,一個串列head_free是為了記錄有哪些記憶體是空的,可以使用的。那麼相反的,head_occupy就會是記錄目前使用中的記憶體的串列。而一樣linked list為了方便起見我們也記錄了尾端tail_free

為了實做allocation,一樣我們還是需要資料輸入工具,因此邏輯上相同於普通的linked list中的insert_in_tail(),在這邊我們唯一不同的就是輸入兩筆記錄begin和size,因此Mem_info_insert_in_tail()基本上就和insert_in_tail()是一樣的東西,不多加贅述。

而這邊的主軸,就是要在free的串列之中找到第一個比我們要求的size還要大的記憶體node。因此邏輯上是很簡單的,只要從head_free開始去比較大小,然後找到之後在去對這個node處理即可。

首先我們需要一個pointer去四處搜尋我們要的size,我為它取名為first_fit,也就是它的目的是為了尋找出第一個適合的大小的node,而這個function也需要回傳一個node是要標示我們為他allocation的node,取名為data:
   MemInfo *first_fit, *data;
接著我們便去找出適合的大小:
   while (first_fit != NULL &&first_fit->size < size)
      first_fit = first_fit->next;
這時候找到之後,first_fit就會是我們要的node(另一個情形就是並沒有找到我們要的大小,因此這邊的first_fit就會是NULL),因此當我們有找到的狀況下才需要做allocation和後續的處理:
   if (first_fit != NULL) {
      // allocate memory for this data
      data = (MemInfo*) malloc(sizeof(MemInfo));
      data->begin = first_fit->begin;
      data->size = size;
而所謂的後續的處理呢,有兩種狀況,第一種就是我們尋找到的node的size比我們需求的大,這時候處理方式就會是把我們找到的node的起始位置begin往下移開size大小(因為我們要在這個node的記憶體allocate size大小,所以free的起始位置就會少掉了size大小),同時這個node的大小便同時會減少了size這麼大:
      if (first_fit->size > size) {
         first_fit->begin += size;
         first_fit->size -= size;
      }
另一種狀況就是我們找到的node的大小正巧符合我們要的大小,但我們需要特別注意的就是如果我們找到的node是第一個,也就是head_free,這時候我們需要重新指定head_free為下一個node(第一種狀況不用,因為head_free比size大,並沒有把整個node移掉,不需重新指定)。接下來就是把前面那個node往下一個node接,下一個node往前接,最後在free掉即可:
      else {
         // judge if this is head
         if (first_fit == head_free)
            head_free = first_fit->next;
         else
            first_fit->prev->next = first_fit->next;
         // if this is not tail
         if (first_fit->next != NULL)
            first_fit->next->prev = first_fit->prev;
         free(first_fit);
      }
最後回傳我們已經allocated的記憶體就大功告成:
  return data

2013年8月23日 星期五

link list-double link list的刪除某值

typedef struct Dnode {
   struct Dnode *prev;
   int val;
   struct Dnode *next;
}Dnode;

Dnode *Dhead = NULL;

// show doule linked list elements
void Dshow_list(void)
{
   Dnode *rush = Dhead;
   printf("\n The result is:\n");
   while (rush != NULL) {
      printf("%d ", rush->val);
      rush = rush->next;
   }
   puts("");
}

// delete a specified value from a double linked list
void Ddelete_specified_data(int val)
{
   Dnode *rush, *prev;
   rush = Dhead;
   // find out the value
   while (rush->val != val) {
      prev = rush;
      rush = rush->next;
   }
   // if there is no found or no data in the linked list
   if (rush == NULL) {
      printf("No found!/ No existing data!\n");
      return;
   }
   // now rush is the node which has the value
   // then delete rush
   // if 1st data is rush
   if (rush == Dhead) {
      rush->next->prev = NULL;
      Dhead = rush->next;
   }
   // or if rush is the tail
   else if (rush->next == NULL) {
      rush->prev->next = NULL;
      Dtail =rush->prev;
   }
   // else
   else {
      rush->prev->next = rush->next;
      rush->next->prev = rush->prev;
   }

   free(rush);
}

Dnode *Dtail = NULL;
// insert data to tail of the linked list
void Dinsert_in_tail(int val)
{
   // allocate memory for this new node
   Dnode *data = (Dnode*) malloc(sizeof(Dnode));
   data->val = val;
   data->next = NULL;

   // if there is no existing nodes in the list
   if (Dhead == NULL) {
      // then head = tail = node
      Dhead = Dtail = data;
      data->prev = NULL;
   }
   else {
      Dtail->next = data;
      data->prev = Dtail;
      Dtail = data;
   }

}

int main()
{
   int n;
   printf("Double linked list:\n");
   FILE *fin;
   fin = fopen("input", "r");
   while (fscanf(fin, "%d", &n) != EOF) {
      printf("%d ", n);
      Dinsert_in_tail(n);
   }
   Dshow_list();
   Ddelete_specified_data(5);
   Dshow_list();

   return 0;

}

單向的(也就是基本型態)linked list有個壞處就是不能反向移動。當然使用環狀的結構是可以繼續往下走然後找到自己想要的element,但如果資料過長,而你想要找的資料剛好是目前的正上方,這時候使用環狀結構反而是浪費了一堆時間。因此我們便多使用了一個儲存空間,使用了指標去指向目前node的上一個。
typedef struct Dnode {
   struct Dnode *prev;
   int val;
   struct Dnode *next;
}Dnode;
這樣便能夠反向搜尋我們所要的東西,不過缺點就是每個node都會增加一筆資料空間。而為了示範刪除某值,也必須先建立基本配備。首先我們使用了Dinsert_in_tail()的function,當然這個東西跟我們一般單向的insert_in_tail()邏輯上是大同小異,不再多做介紹,唯一不同之處在於head之前接的會是NULL,因為我們需要一個指標是用來標示尾端。而因為這是雙向的,所以頭也必須要和尾一樣接的是NULL,類似接地的功能。而Dshow_list()也是和show_list()是同樣的function,在此就不贅述了。

雙向linked list在刪除某值的時候,要注意的是我們要處理的工夫會多雙倍。原本的單向只需要把前一個node的next指向下一個node就可以刪除了。但在這邊,我們必須要注意很多地方。

首先是如果我們要刪除的資料是第一筆的話,也就是head,那麼head的前一個node是空指標。刪除掉head的時候必須把下一個node的prev指向空指標:
   if (rush == Dhead) {
      rush->next->prev = NULL;
      Dhead = rush->next;
   }
然後再重新指定head即可。

至於tail也會是類似的處理:
   else if (rush->next == NULL) {
      rush->prev->next = NULL;
      Dtail =rush->prev;
   }
而最後是一般情形,也就是想刪除的資料不是頭也不是尾而是中間。處理方法就是:
(1) 前一個node的next指向下一個node
(2) 下一個node的prev指向前一個node
要離開之前總得要把事情交辦的清清楚楚,前後所指向的指標都得有所依據這樣才不會指向沒有定義的記憶體區塊:
      rush->prev->next = rush->next;
      rush->next->prev = rush->prev;

2013年8月21日 星期三

link list-reverse


// reverse a link list
void reverse_link_list(void)
{
   // we need 3 pointers to keep going
   node *rush, *prev, *now;

   // initialize
   rush = head;
   now = NULL;

   // loop from head to final
   while (rush != NULL) {
      // prev now rush
      prev = now;
      now = rush;
      rush = rush->next;
      // prev<-now rush
      now->next =prev;
   }
   // assign head to now
   head = now;
}

反轉一個link list我們會需要三個指標。因為如果照以前一樣只用兩個指標來做的話:
while (rush != NULL) {
   prev = rush;
   rush = rush->next;
   rush->next = prev;
}
我們會永遠沒辦法往下一個node前進,因為現有的now的next已經往前接了,而該往後的node會因此斷了音訊。所以我們需要一個pointer來保存下一個node的位置。因此rush是用來保存下一個node的位置,而now是現有的node,prev則是前一個node。由於我們要反轉一個link list,所以now的next應當接在prev上。

我們初始化指標使得: now(NULL) rush(head)

這樣在進入迴圈做這件事情的時候:
      prev = now;
      now = rush;
      rush = rush->next;
      // prev<-now rush
      now->next =prev;
就會讓前頭長成這樣 prev(NULL)<-now(head) rush(next)

這樣子我們就把目前的head接給NULL,也因為我們要反轉的關係,head將來就會成為最後一個節點,而我們知道最後一個節點的next是NULL,因此這樣做是沒問題的,這也是支所以我們把now initialize為NULL的初衷。

與使用兩個指標的方式不同的是,由於我們有保存下一個指標的位址rush,所以我們要往下一個節點邁進的時候,只需要把rush assign給now。然後rush就可以往下一個節點邁進。

接著最後再把head assign給目前的now(而不是rush!因為經過迴圈之後rush已經是NULL了):
   head = now
大功告成!

2013年8月19日 星期一

link list-清除link list

// free all nodes in the link list
void free_all_nodes(void)
{
   node *rush, *prev;
   // if there is no existing element, jump out
   if (head == NULL) {
      printf("No existing element!\n");
      exit(1);
   }
   // initialize rush as head
   rush = head;
   // free all elements
   while (rush != NULL) {
      prev = rush;
      rush = rush->next;
      free(prev);
   }
}
當我們allocate一個link list的時候,記憶體會騰出空間出來。當然C的程式的default會在程式結束之後把記憶體清空。但是如果你有程式是巨量資料,那麼這list要清空騰出記憶體是無可避免的。

因此要清空一個list的記憶體的方式就是從頭慢慢的一個一個開始清。他不像是一般array使用free就可以清除一整筆資料。由於目前的link list是單向的,所以清除順序勢必是要從head開始清除。

所以首先我們需要先判斷link list裡面究竟有沒有existing的node再來決定要不要清除。因為如果沒有的話便會清除到NULL指標。當然也許程式可能是容許的,但是如果可以養成程式能夠自我預警,那麼日後出現任何問題都能夠容易debug,也能夠有點像是封裝概念一般省去一堆debug的時間。
   if (head == NULL) {
      printf("No existing element!\n");
      exit(1);
   }
這邊就是偵測目前是否有現存資料在內,如果沒有那麼就印出訊息跳出去。當然如果你整支程式還是要繼續執行的話就把exit(1)改成return即可。

接著initialize rush為head之後開始迴圈一個一個開始free掉每個node:
   rush = head;
   // free all elements
   while (rush != NULL) {
      prev = rush;
      rush = rush->next;
      free(prev);
   }
while迴圈就偵測目前是否有到尾了,如果還沒到尾就繼續free掉現有值。直到迴圈結束這支程式也做了該做的事情了。

2013年8月18日 星期日

link list-刪除某值之資料

// delete a node of data val in a link list
void delete_specified_data(int val)
{
   node *rush, *prev;
   rush = head;
   // search for data val
   while (rush != NULL && val != rush->val) {
      prev = rush;
      rush = rush->next;
   }
   // if there is no result
   if (rush == NULL) {
      printf("Data no found!\n");
      exit(1);
   }
   // if that result is the first node,
   // then head will be the next node
   else if (rush == head)
      head = rush->next;
   // else, pull out the node
   else
      prev->next = rush->next;
   free(rush);

}
這個是只刪除某一個值,但是只刪除一個而已,因此如果一個數列23 54 54 34 65 12 在這邊如果刪除54的話,只會刪除第一個54。 所以概念上就是從link list之中從頭開始找,找到符合值為val的就把它刪除,刪除方式就是把他前面的node的next接它後面。接著再free掉它。
   rush = head;
   // search for data val
   while (rush != NULL && val != rush->val) {
      prev = rush;
      rush = rush->next;
   }
首先把探索用的指標rush initialize為head,接著迴圈內就開始找第一個符合我們要找的值的node為止。這時候rush有幾種情形
1. 第一個node就找到了
2. 沒有找到
3. 找到了,但不是1.的情形

while內的條件最好是該有正確的boundary判斷,因此rush != NULL,因為筆者的參考書沒有這一段,所以特別標明這一點。如果這個link list沒有找到我們要找的資料的話,那麼最後rush會跑到NULL上,接著會讀取不存在的記憶體rush = rush->next,這樣是有問題的。

所以當我們找到的是第1.的情形的時候,他會和第三個有所不同。因為第三個情形的處理方式就是該把(我們找到的node)前面那個的next給接到(我們找到的node)的後一個。但如果是第一個情形不會有前面那個node,這時候prev是沒有Initialize的所以一樣會讀取到沒有allocate的記憶體上。
   else if (rush == head)
      head = rush->next;
   // else, pull out the node
   else
      prev->next = rush->next;
所以第一個else if就是判斷第一個情形,這時候因為我們要移掉的是第一個node,處理方式就是重新指定head為後一個node就行了。而第三種情形的處理方式就是把前面那個node往後接給後面那一個node。

至於第二個情形
   if (rush == NULL) {
      printf("Data no found!\n");
      exit(1);
   }
就該把沒找到的訊息印出來並且直接跳出去。筆者的參考書一樣沒這一段,雖然本身無關緊要。因為如果沒有找到的話,那麼我們最後要free()的時候便會free掉什麼都沒有的NULL,這本身是沒什麼問題的。但寫程式概念還是要清楚,畢竟free是用在有memory allocate的情形的。萬一某個部分沒有寫好,比如我們的while如果沒有判斷rush != NULL,這時候會發生什麼事情也不曉得。即使free掉NULL沒什麼要緊的,但寫給自己看也讓自己提醒自己該注意的地方是什麼才是重要的。

2013年8月16日 星期五

link-list 資料插尾插頭

// insert val in head of a link list
void insert_in_head(int val)
{
   // create a node for val
   node *data = (node *) malloc(sizeof(node));
   data->val = val;
   // link head next to data
   data->next = head;
   // new head = data
   head = data;
}
node *tail = NULL;
// insert val in tail of a link list
void insert_in_tail(int val)
{
   // create a node for val
   node *data = (node *) malloc(sizeof(node));
   data->val = val;
   // link NULL to data
   data->next = NULL;

   // if there is no existing node
   if (head == NULL)
      // then this node is head and also tail
      head = tail = data;
   else {
      // otherwise, this node is new tail
      tail->next = data;
      tail = data;
   }
}
資料的插頭,就是把一筆資料直接放入到link list的頭端,如果沒有資料那麼這筆資料就會是新的頭。如果有資料的話那麼目前的頭就會被接在這筆新資料之後。
   data->next = head;
   // new head = data
   head = data;
在create一個node之後我們便把目前的頭接在這筆新資料之後,然後新的頭就會是這筆新資料。在此,即使是沒有任何資料的狀態也不會有問題,因為沒有任何資料的狀況之下,我們早在一開始便把head initialize成為NULL了,因此這時候這筆新資料往後接的,便會是NULL,這也是正常該有的狀況。

而資料的插尾,就是把這筆資料直接放到最尾端。我們可以直接一個一個從頭去search next指標直到尾端去找尾端然後把這筆資料往後接上,但這太耗費工夫,尤其如果是巨量資料之下的話會更明顯。因此我們直接create一個指標tail,指向這個list的最後一個node,我們一開始initialize為NULL:
node *tail = NULL;
接著這個程式create memory並放入資料給這筆新資料之後,首先就將這筆新資料的尾端接為NULL:
   data->next = NULL;
然後我們先判定目前是不是現有資料,原因在於如果不管三七二十一不判定有沒有資料而直接把tail往後接給這筆資料的話,會有問題,因為我們並沒有配給tail一個記憶體空間,所以它的next是不存在的,因為即使是指標,還是需要記憶體空間的。所以如果沒有任何資料在list之內,我們直接把tail和head assign給這筆新資料:
   if (head == NULL)
      // then this node is head and also tail
      head = tail = data;
當然我們也可以用tail == NULL來判斷也是一樣的結果。邏輯上來講,如果沒有任何資料存在,那麼這筆新資料就會是這個link list的頭兼尾,這邊程式的邏輯就會把這段話給烙印上去。

接著如果現有資料的話,我們就把tail往後接這筆資料,接著才把tail assign給這筆資料,這邊順序要對,如果我們先把tail assign給這筆新資料在把tail往後接給這筆資料的話,結果會是這筆資料是孤立的,沒有任何資料接它,並且它的next會是接它自己。
      tail->next = data;
      tail = data;
於是接頭接尾便能夠很簡單的用幾行就可以完成。

2013年8月14日 星期三

link list-資料的依值插入

typedef struct node {
   int val;
   struct node *next;
}node;

node *head = NULL;
// insert value "val" into link list
void insert_value(int val)
{
   node *prev, *rush;
   // create node for that insertor
   node *data = (node*) malloc(sizeof(node));
   // put the value in that node
   data->val = val;

   prev = rush = head;
   // find out the correct position for val
   while (rush != NULL && val > rush->val) {
      prev = rush;
      rush = rush->next;
   }

   // link it next to the bigger value
   data->next = rush;
   // if there is no element in link list
   // or val is the smallest
   if (rush == head)
      head = data;
   else
      prev->next = data;

}

// show link list elements
void show_list(void)
{
   node *rush = head;
   printf("\nThe result is:\n");
   while (rush != NULL) {
      printf("%d ", rush->val);
      rush = rush->next;
   }
   puts("");


}
int main()
{
   int n;
   printf("Enter values:\n");
   while(scanf("%d", &n) != EOF) {
      printf("%d ", n);
      insert_value(n);
   }
   show_list();
   return 0;

}

關於include的部分請依自己的compiler把該include的東西放進去。

依值插入顧名思義就是依據值的大小而插入適當的位置,因此不管目前插入的值是什麼,整個list都會是由小排到大(又或是由大排到小)。

所以這個function邏輯是
1. 找到相等又或是比插入值還大的node
2. 把插入值的node next 接在1.前面
3. 把比插入值還小的node接在插入值前面,如果是NULL node又或是插入值是最小的,那麼插入值它就會是head

因此指標prev和rush就是在step 1中為了找出比插入值還小的prev的node,以及該接在插入值後面的rush


   while (rush != NULL && val > rush->val) {
      prev = rush;
      rush = rush->next;
   }
在這個while迴圈中,不斷的比較插入值和現有在list中node的大小。當現有的node還不到尾端的時候,且目前還沒找到該插入的位置的時候,在list中的node就會往後移,直到rush這個指標比插入值還大或相等,那麼理所當然的prev就是比插入值還小。

從while迴圈跳出來會有兩種情形 a.list是空的 b.list非空的且有找到插入值該有的位置,因此以b.來說,我們依循以上function的邏輯2. 我們就會把插入值的next往後接rush:

   // link it next to the bigger value
   data->next = rush;
但如果是情形a呢?這也沒問題,因為即使是空的,我們一開始initialize head是NULL的,而link list的尾端總是NULL的,所以目前的rush也會是NULL的。所以把插入值的尾端這樣接是不會有問題的。

所以邏輯3.:
   if (rush == head)
      head = data;
   else
      prev->next = data;

就會和描述一模一樣,如果插入值該放第一個又或是這個list是空的,那麼沒有一個node該接他前面,所以head就會assign給他。如果不是的話,那麼前面那個prev就會是比她還小的值,應當接在插入值的前方。

2013年8月12日 星期一

陣列-sparse matrix的轉置

void trans_spm(spm *orig, spm *trans)
{
   // sofar is the index for trans
   int col, i, sofar = 1;
   // initialize matrix info
   int TotalCol = trans[0].row = orig[0].col;
   trans[0].col = orig[0].row;
   int TotalElements = trans[0].val = orig[0].val;

   // loop with column index
   for (col = 0; col < TotalCol; col++)
      // search all over the elements
      // for the same column
      for (i = 1; i <= TotalElements; ++i)
         if (orig[i].col == col) {
            // add the same column elements to trans
            trans[sofar].row = col;
            trans[sofar].col = orig[i].row;
            trans[sofar].val = orig[i].val;
            sofar++;
         }
}

sparse matrix的轉置矩陣,其做法的原理很簡單,首先的資料部分row 和column數目對調就是轉置的結果,總element數目不變。接著再以column為主,從原先的矩陣依照(column, row)的順序把每一個element抽出來放到轉置矩陣去。

因此首先有dummy index:
   int col, i, sofar = 1;
col是給column用的index,為了loop in column。而i則是跑全部的element。sofar則是記錄目前在轉置矩陣上的index。
接著把矩陣資料排好給轉置矩陣後,就開始依據(column, row)的順序把element從原矩陣中抽出。
  for (col = 0; col < TotalCol; col++)
因為我們要排的是轉置的矩陣,因此原先的矩陣排列方式是(row, column),那麼現在的轉置矩陣就會是原矩陣的相反(column, row)。首先的迴圈就run over all column的index去依據column大小的順序去排列轉置矩陣。
      for (i = 1; i <= TotalElements; ++i)
         if (orig[i].col == col) {
            // add the same column elements to trans
            trans[sofar].row = col;
            trans[sofar].col = orig[i].row;
            trans[sofar].val = orig[i].val;
            sofar++;
         }
我們便每次都從第一個element開始排列順序,我們每一次一個column都會從頭從原矩陣的每個element找起,找的目標就是當下的column,比如我們開始排列第0個column,那麼我們便從原矩陣找column為0的。而原矩陣的row和column早就已經排列過了,因此我們就按照element的順序去找起即可,而不需要考慮row的順序。當我們找到當下的column的時候,便把這個element assign給轉置矩陣,當然row和column是要對調的,而值是相同的。因此按照這樣的邏輯下去這個轉置矩陣變這樣完成。

2013年8月5日 星期一

陣列-sparse matrix的加法

// add sparse matrix c = a + b
void add_spm(spm *c, spm *a, spm *b)
{
   int ia = 1; // index for a
   int ib = 1; // index for b
   int ic = 1; // index for c

   // while both index are not yet reach the end
   while (ia <= a[0].val && ib <= b[0].val)
      // if a position > b position, then assign b to c
      if (a[ia].row > b[ib].row ||
          a[ia].row == b[ib].row && a[ia].col > b[ib].col)
         c[ic++] = b[ib++];
      // if a position < b position, then assign a to c
      else if (a[ia].row < b[ib].row ||
               a[ia].row == b[ib].row && a[ia].col < b[ib].col)
         c[ic++] = a[ia++];
      // if a position = b position, c = a+c
      else {
         // we only save non-zero elements
         int sum = a[ia].val + b[ib].val;
         if (sum != 0) {
            c[ic].row = a[ia].row;
            c[ic].col = a[ia].col;
            c[ic].val = sum;
            ic++;
         }
         ia++;
         ib++;
      }
   /* end while */

   // assign the rest elements a OR b to c
   while (ia <= a[0].val)
      c[ic++] = a[ia++];
   while (ib <= b[0].val)
      c[ic++] = b[ib++];
   // assgin the matrix info to c
   c[0].row = a[0].row;
   c[0].col = a[0].col;
   c[0].val = ic - 1;
}
加法其實很簡單,有overlap的elements就是直接加,沒有overlap的部分就是看row和column的位置,先判斷row在判斷column,row/column數字少的就直接遞給c。接著如果其中一方a或b已經把它自己的element都遞給c的時候,那麼另外一方就直接把剩餘的element都遞給c,因為已經不會有overlap的部分了。
  while (ia <= a[0].val && ib <= b[0].val)
首先這個迴圈,當a以及b皆有element要加的時候就會持續的做以下的加法。

      if (a[ia].row > b[ib].row ||
          a[ia].row == b[ib].row && a[ia].col > b[ib].col)
         c[ic++] = b[ib++];
在while迴圈仍有效的前提之下,開始判斷有沒有overlap的element。這邊就判定不是overlap,並且a的目前index的位置是在b之後的,所以我們就直接把b的element assign給c,並且各自的index往下一個element前進,而接著的else if則是相同的邏輯,只是是判定b的index在a之後。
      else {
         // we only save non-zero elements
         int sum = a[ia].val + b[ib].val;
         if (sum != 0) {
            c[ic].row = a[ia].row;
            c[ic].col = a[ia].col;
            c[ic].val = sum;
            ic++;
         }
接著最後則是a和b是overlap的element,把他們的值加上去之後assign給c,把c的index往後移之後
         ia++;
         ib++;
馬上把a和b的index都往後移,最後最外面的while迴圈跑完之後,有三種情形:1.(a沒有剩下了,b還有) 2.(b沒有剩下了,a還有) 3.(都沒有剩下了) 但不論是怎樣的情形,我們都會跑:
   while (ia <= a[0].val)
      c[ic++] = a[ia++];
   while (ib <= b[0].val)
      c[ic++] = b[ib++];
因為即使是情形1. a沒有剩下的element,我們跑while(ia <= a[0].val)它不會有element要執行,因此這邊是不會跑迴圈的,只會跑下面那個b,而情形2和情形3亦然是如此。最後我們再把這矩陣的資料assign給c就完成了。