#define MAX_DEGREE 101   /* azami derece + 1 */
typedef struct {
  int degree;               /* en büyük üs */
  float coef[MAX_DEGREE];   /* coef[i]: x^i katsayısı */
} polynomial;
polynomial P;

#define MAX_TERMS 101   /* azami terim sayısı */
typedef struct {
  float coef;            /* katsayı */
  int expon;             /* üs */
} polynomial;
polynomial P[MAX_TERMS]; /* tüm polinomlar burada */
int avail = 0;           /* ilk boş konum */

Terimler büyük üsten küçüğe sıralı tutulur; her polinom P içinde bir [start, finish] aralığıdır.

• A'da n, B'de m terim: her döngü turunda en az bir işaretçi ilerler → en çok n + m tur.
• Kalan kopyalama döngüleri de toplamda n + m'yi aşmaz → O(n + m).
• En iyi durum: tüm üsler ortak (n = m); her tur case 0, iki işaretçi birlikte ilerler → Ω(n).
• Sıralı olmasaydı: her terim için sonuçta arama/araya ekleme (kaydırma) → O(n²) düzeyine çıkardı.

typedef struct pol_oge *pol_gosterge;
typedef struct pol_oge {
  int katsayi;
  int us;
  pol_gosterge bag;
} pol_oge;

• Yalnız sıfır olmayan terimler, üsse göre azalan sırada.
• Terim sayısı önceden bilinmez; ortak dizi, avail ve sıkıştırma derdi yok.
• Araya ekleme/silme işaretçi değiştirerek O(1) (yeri bulunduktan sonra).

a = 3x¹⁴ + 2x⁸ + 1

pol_gosterge yerlestir(pol_gosterge r,
                       int us, int kat) {
  while (r->bag && r->bag->us > us) r = r->bag;
  if (!r->bag || r->bag->us < us)
    YeniTerimEkle(us, kat, r);         /* yeni üs */
  else if ((r->bag->katsayi += kat) == 0)
    SonrakiTerimiSil(r);               /* 0 oldu */
  return r;
}

• A'nın her terimi B'nin her terimiyle çarpılır: üsler toplanır, katsayılar çarpılır.
• Sonuç listesi sıralı kalmalı; aynı üslü terim varsa katsayı güncellenir, 0 olursa terim silinir.
• baslangic (bas): p'nin bir sonraki terimiyle çarpımlar, bir öncekinin q₁ ile çarpımının önünden başlayamaz → arama oradan başlar.
• Okunaklılık için iç döngü gövdesi yerlestir yordamına ayrıldı.

Satırları sütun olarak yazarız:

• Üçlülerde basitçe row ile col'u değiştirmek yetmez: sonuç satır sırasını bozar.
• Değiştirip sonra sıralamak ya da her öğeyi yerine kaydırarak eklemek pahalıdır.
• Çözüm: transpozun satırları = M'nin sütunları; sütun sütun taranıp sırayla üretilir.

• Dış döngü cols kez, iç döngü terms kez → O(cols · terms).
• Matris doluysa terms = rows·cols → O(cols² · rows): 2B dizide transpoz O(rows·cols) iken daha kötü!
• Yani bellekten kazanırken zamandan kaybettik — terms ≪ rows·cols olduğunda anlamlı.
• Sorun: aynı M dizisini her sütun için yeniden taramak.

Döngüler: num_cols + num_terms + num_cols + num_terms (+ sabitler):

2·terms + 2·cols + 3 = O(cols + terms)

Dolu matriste O(rows·cols): 2B dizideki transpozla aynı derece. Bedeli: iki yardımcı dizi (O(cols) bellek).

/* row_terms'ü yerinde start_pos'a çevir */
for (i = 0, pos = 1; i < nc; i++) {
  int c = cnt[i];      /* bu sütundaki terim sayısı */
  cnt[i] = pos;        /* artık başlangıç konumu */
  pos += c;
}
for (i = 1; i <= nt; i++) {
  j = cnt[M[i].col]++;
  T[j].row = M[i].col;  T[j].col = M[i].row;
  T[j].value = M[i].value;
}

Hızlı transpoz tek bir dizi kullanılarak da yazılabilir. Bu, sayarak sıralamanın (counting sort) ta kendisi: anahtar = sütun no.

d_ij = Σ_k=0ⁿ⁻¹ a_ik · b_kj

A'nın i. satırı ile B'nin j. sütunu “çarpılıp toplanır”. İki seyrek matrisin çarpımı seyrek olmak zorunda değil:

• Üçlülerde A'nın i. satırı ardışık durur, ama B'nin j. sütunu dağınıktır.
• Bu yüzden önce B'nin transpozu alınır (fast_transpose): B'nin sütunları Bᵀ'nin ardışık satırları olur.
• Sonra A'nın her satırı ile Bᵀ'nin her satırı, col alanına göre birleştirilerek (merge) çarpılır.

• Transpoz: O(cols_B + t_B).
• A'nın her satırı i için Bᵀ baştan sona gezilir: Σ_i t_B = rows_A·t_B.
• Her (i, j) çifti için A satırının terimleri de gezilir: Σ_j t_A = cols_B·t_A.
• Toplam: O(cols_B·t_A + rows_A·t_B).