Initial data commit
This commit is contained in:
Ingy döt Net
parent
72d218235f
commit
f23f22d71c
199087 changed files with 3378941 additions and 0 deletions
33
Task/Priority-queue/C-sharp/priority-queue-1.cs
Normal file
33
Task/Priority-queue/C-sharp/priority-queue-1.cs
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
using System;
|
||||
using System.Collections.Generic;
|
||||
|
||||
namespace PriorityQueueExample
|
||||
{
|
||||
class Program
|
||||
{
|
||||
static void Main(string[] args)
|
||||
{
|
||||
// Starting with .NET 6.0 preview 2 (released March 11th, 2021), there's a built-in priority queue
|
||||
var p = new PriorityQueue<string, int>();
|
||||
p.Enqueue("Clear drains", 3);
|
||||
p.Enqueue("Feed cat", 4);
|
||||
p.Enqueue("Make tea", 5);
|
||||
p.Enqueue("Solve RC tasks", 1);
|
||||
p.Enqueue("Tax return", 2);
|
||||
while (p.TryDequeue(out string task, out int priority))
|
||||
{
|
||||
Console.WriteLine($"{priority}\t{task}");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Output:
|
||||
|
||||
1 Solve RC tasks
|
||||
2 Tax return
|
||||
3 Clear drains
|
||||
4 Feed cat
|
||||
5 Make tea
|
||||
|
||||
*/
|
||||
60
Task/Priority-queue/C-sharp/priority-queue-2.cs
Normal file
60
Task/Priority-queue/C-sharp/priority-queue-2.cs
Normal file
|
|
@ -0,0 +1,60 @@
|
|||
using System;
|
||||
|
||||
namespace PriorityQueue
|
||||
{
|
||||
class Program
|
||||
{
|
||||
static void Main(string[] args)
|
||||
{
|
||||
PriorityQueue PQ = new PriorityQueue();
|
||||
PQ.push(3, "Clear drains");
|
||||
PQ.push(4, "Feed cat");
|
||||
PQ.push(5, "Make tea");
|
||||
PQ.push(1, "Solve RC tasks");
|
||||
PQ.push(2, "Tax return");
|
||||
|
||||
while (!PQ.Empty)
|
||||
{
|
||||
var Val = PQ.pop();
|
||||
Console.WriteLine(Val[0] + " : " + Val[1]);
|
||||
}
|
||||
Console.ReadKey();
|
||||
}
|
||||
}
|
||||
|
||||
class PriorityQueue
|
||||
{
|
||||
private System.Collections.SortedList PseudoQueue;
|
||||
|
||||
public bool Empty
|
||||
{
|
||||
get
|
||||
{
|
||||
return PseudoQueue.Count == 0;
|
||||
}
|
||||
}
|
||||
|
||||
public PriorityQueue()
|
||||
{
|
||||
PseudoQueue = new System.Collections.SortedList();
|
||||
}
|
||||
|
||||
public void push(object Priority, object Value)
|
||||
{
|
||||
PseudoQueue.Add(Priority, Value);
|
||||
}
|
||||
|
||||
public object[] pop()
|
||||
{
|
||||
object[] ReturnValue = { null, null };
|
||||
if (PseudoQueue.Count > 0)
|
||||
{
|
||||
ReturnValue[0] = PseudoQueue.GetKey(0);
|
||||
ReturnValue[1] = PseudoQueue.GetByIndex(0);
|
||||
|
||||
PseudoQueue.RemoveAt(0);
|
||||
}
|
||||
return ReturnValue;
|
||||
}
|
||||
}
|
||||
}
|
||||
121
Task/Priority-queue/C-sharp/priority-queue-3.cs
Normal file
121
Task/Priority-queue/C-sharp/priority-queue-3.cs
Normal file
|
|
@ -0,0 +1,121 @@
|
|||
namespace PriorityQ {
|
||||
using KeyT = UInt32;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
class Tuple<K, V> { // for DotNet 3.5 without Tuple's
|
||||
public K Item1; public V Item2;
|
||||
public Tuple(K k, V v) { Item1 = k; Item2 = v; }
|
||||
public override string ToString() {
|
||||
return "(" + Item1.ToString() + ", " + Item2.ToString() + ")";
|
||||
}
|
||||
}
|
||||
class MinHeapPQ<V> {
|
||||
private struct HeapEntry {
|
||||
public KeyT k; public V v;
|
||||
public HeapEntry(KeyT k, V v) { this.k = k; this.v = v; }
|
||||
}
|
||||
private List<HeapEntry> pq;
|
||||
private MinHeapPQ() { this.pq = new List<HeapEntry>(); }
|
||||
private bool mt { get { return pq.Count == 0; } }
|
||||
private int sz {
|
||||
get {
|
||||
var cnt = pq.Count;
|
||||
return (cnt == 0) ? 0 : cnt - 1;
|
||||
}
|
||||
}
|
||||
private Tuple<KeyT, V> pkmn {
|
||||
get {
|
||||
if (pq.Count == 0) return null;
|
||||
else {
|
||||
var mn = pq[0];
|
||||
return new Tuple<KeyT, V>(mn.k, mn.v);
|
||||
}
|
||||
}
|
||||
}
|
||||
private void psh(KeyT k, V v) { // add extra very high item if none
|
||||
if (pq.Count == 0) pq.Add(new HeapEntry(UInt32.MaxValue, v));
|
||||
var i = pq.Count; pq.Add(pq[i - 1]); // copy bottom item...
|
||||
for (var ni = i >> 1; ni > 0; i >>= 1, ni >>= 1) {
|
||||
var t = pq[ni - 1];
|
||||
if (t.k > k) pq[i - 1] = t; else break;
|
||||
}
|
||||
pq[i - 1] = new HeapEntry(k, v);
|
||||
}
|
||||
private void siftdown(KeyT k, V v, int ndx) {
|
||||
var cnt = pq.Count - 1; var i = ndx;
|
||||
for (var ni = i + i + 1; ni < cnt; ni = ni + ni + 1) {
|
||||
var oi = i; var lk = pq[ni].k; var rk = pq[ni + 1].k;
|
||||
var nk = k;
|
||||
if (k > lk) { i = ni; nk = lk; }
|
||||
if (nk > rk) { ni += 1; i = ni; }
|
||||
if (i != oi) pq[oi] = pq[i]; else break;
|
||||
}
|
||||
pq[i] = new HeapEntry(k, v);
|
||||
}
|
||||
private void rplcmin(KeyT k, V v) {
|
||||
if (pq.Count > 1) siftdown(k, v, 0);
|
||||
}
|
||||
private void dltmin() {
|
||||
var lsti = pq.Count - 2;
|
||||
if (lsti <= 0) pq.Clear();
|
||||
else {
|
||||
var lkv = pq[lsti];
|
||||
pq.RemoveAt(lsti); siftdown(lkv.k, lkv.v, 0);
|
||||
}
|
||||
}
|
||||
private void reheap(int i) {
|
||||
var lfti = i + i + 1;
|
||||
if (lfti < sz) {
|
||||
var rghti = lfti + 1; reheap(lfti); reheap(rghti);
|
||||
var ckv = pq[i]; siftdown(ckv.k, ckv.v, i);
|
||||
}
|
||||
}
|
||||
private void bld(IEnumerable<Tuple<KeyT, V>> sq) {
|
||||
var sqm = from e in sq
|
||||
select new HeapEntry(e.Item1, e.Item2);
|
||||
pq = sqm.ToList<HeapEntry>();
|
||||
var sz = pq.Count;
|
||||
if (sz > 0) {
|
||||
var lkv = pq[sz - 1];
|
||||
pq.Add(new HeapEntry(KeyT.MaxValue, lkv.v));
|
||||
reheap(0);
|
||||
}
|
||||
}
|
||||
private IEnumerable<Tuple<KeyT, V>> sq() {
|
||||
return from e in pq
|
||||
where e.k != KeyT.MaxValue
|
||||
select new Tuple<KeyT, V>(e.k, e.v); }
|
||||
private void adj(Func<KeyT, V, Tuple<KeyT, V>> f) {
|
||||
var cnt = pq.Count - 1;
|
||||
for (var i = 0; i < cnt; ++i) {
|
||||
var e = pq[i];
|
||||
var r = f(e.k, e.v);
|
||||
pq[i] = new HeapEntry(r.Item1, r.Item2);
|
||||
}
|
||||
reheap(0);
|
||||
}
|
||||
public static MinHeapPQ<V> empty { get { return new MinHeapPQ<V>(); } }
|
||||
public static bool isEmpty(MinHeapPQ<V> pq) { return pq.mt; }
|
||||
public static int size(MinHeapPQ<V> pq) { return pq.sz; }
|
||||
public static Tuple<KeyT, V> peekMin(MinHeapPQ<V> pq) { return pq.pkmn; }
|
||||
public static MinHeapPQ<V> push(KeyT k, V v, MinHeapPQ<V> pq) {
|
||||
pq.psh(k, v); return pq; }
|
||||
public static MinHeapPQ<V> replaceMin(KeyT k, V v, MinHeapPQ<V> pq) {
|
||||
pq.rplcmin(k, v); return pq; }
|
||||
public static MinHeapPQ<V> deleteMin(MinHeapPQ<V> pq) { pq.dltmin(); return pq; }
|
||||
public static MinHeapPQ<V> merge(MinHeapPQ<V> pq1, MinHeapPQ<V> pq2) {
|
||||
return fromSeq(pq1.sq().Concat(pq2.sq())); }
|
||||
public static MinHeapPQ<V> adjust(Func<KeyT, V, Tuple<KeyT, V>> f, MinHeapPQ<V> pq) {
|
||||
pq.adj(f); return pq; }
|
||||
public static MinHeapPQ<V> fromSeq(IEnumerable<Tuple<KeyT, V>> sq) {
|
||||
var pq = new MinHeapPQ<V>(); pq.bld(sq); return pq; }
|
||||
public static Tuple<Tuple<KeyT, V>, MinHeapPQ<V>> popMin(MinHeapPQ<V> pq) {
|
||||
var rslt = pq.pkmn; if (rslt == null) return null;
|
||||
pq.dltmin(); return new Tuple<Tuple<KeyT, V>, MinHeapPQ<V>>(rslt, pq); }
|
||||
public static IEnumerable<Tuple<KeyT, V>> toSeq(MinHeapPQ<V> pq) {
|
||||
for (; !pq.mt; pq.dltmin()) yield return pq.pkmn; }
|
||||
public static IEnumerable<Tuple<KeyT, V>> sort(IEnumerable<Tuple<KeyT, V>> sq) {
|
||||
return toSeq(fromSeq(sq)); }
|
||||
}
|
||||
}
|
||||
23
Task/Priority-queue/C-sharp/priority-queue-4.cs
Normal file
23
Task/Priority-queue/C-sharp/priority-queue-4.cs
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
static void Main(string[] args) {
|
||||
Tuple<uint, string>[] ins = { new Tuple<uint,string>(3u, "Clear drains"),
|
||||
new Tuple<uint,string>(4u, "Feed cat"),
|
||||
new Tuple<uint,string>(5u, "Make tea"),
|
||||
new Tuple<uint,string>(1u, "Solve RC tasks"),
|
||||
new Tuple<uint,string>(2u, "Tax return") };
|
||||
|
||||
var spq = ins.Aggregate(MinHeapPQ<string>.empty, (pq, t) => MinHeapPQ<string>.push(t.Item1, t.Item2, pq));
|
||||
foreach (var e in MinHeapPQ<string>.toSeq(spq)) Console.WriteLine(e); Console.WriteLine();
|
||||
|
||||
foreach (var e in MinHeapPQ<string>.sort(ins)) Console.WriteLine(e); Console.WriteLine();
|
||||
|
||||
var npq = MinHeapPQ<string>.fromSeq(ins);
|
||||
foreach (var e in MinHeapPQ<string>.toSeq(MinHeapPQ<string>.merge(npq, npq)))
|
||||
Console.WriteLine(e); Console.WriteLine();
|
||||
|
||||
var npq = MinHeapPQ<string>.fromSeq(ins);
|
||||
foreach (var e in MinHeapPQ<string>.toSeq(MinHeapPQ<string>.merge(npq, npq)))
|
||||
Console.WriteLine(e);
|
||||
|
||||
foreach (var e in MinHeapPQ<string>.toSeq(MinHeapPQ<string>.adjust((k, v) => new Tuple<uint,string>(6u - k, v), npq)))
|
||||
Console.WriteLine(e); Console.WriteLine();
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue