C#

class LinkedList
{
    //attributes
    private Node head, tail;
    private int size;

    //constructor
    public LinkedList()
    {
        head = null;
        size = 0;
    }

    //properties
    public Node Tail
    {
        get { return tail; }
    }

    public Node Head
    {
        get { return head; }
    }

    public int Size
    {
        get { return size; }
    }

    //methods
    public void AddFront(object data)//Part A (1)
    {
        //create a new node that set the link to point to the head of linkedList
        Node newNode = new Node(data, head);
        if (head == null)
            tail = newNode;

        //set this new node to be the head of the linked list
            head = newNode;

        //increase the size of the LinkedList
            size++;
    }

    public void AddRear(object data)//Part A (2)
    {
        //create new node
        Node newNode = new Node(data, null);
        if (head == null)
        {
            head = newNode;
            tail = newNode;
            size++;
        }
        else //list not empty
        {
            tail.Link = newNode;
            tail = newNode;
            size++;
        }
    }

    public bool DeleteFront()//Part A (3)
    {
        if (head == null) //empty list
            return false;
        else //list not empty
        {
            head = head.Link;
            size--;
            return true;
        }
    }

using System;

namespace GameCharacterTrackingSystem
{
    public class Node
    {
        object data;
        Node link;

        public Node(object d, Node l)
        {
            data = d;
            link = l;
        }

        public object Data
        {
            get
            {
                return data;
            }
            set
            {
                data = value;
            }
        }

        public Node Link
        {
            get
            {
                return link;
            }
            set
            {
                link = value;
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;

namespace GameCharacterTrackingSystem
{
    class Entity 
    {
        //attrubutes
        private string type;
        private string name;
        private int level;

        //constructor
        public Entity()
        {
            type = null;
            name = null;
            level = 0;
        }

        public Entity(string type, string name, int level)
        {
            this.type = type;
            this.name = name;
            this.level = level;
        }

        //properties
        public string Type
        {
            get { return type; }
            set { type = value; }
        }

        public string Name
        {
            get { return name; }
            set { name = value; }
        }

        public int Level
        {
            get { return level; }
            set { level = value; }
        }

        //method
        public override string ToString()
        {
            return "Type    : " + type + ",   Name    : " + name + ",    Level   : " + level;
        }


    }
}

int[] mergeSort (int[] data) {
   if (data.Length == 1)
      return data;
   int middle = data.Length / 2;
   int[] left = mergeSort(subArray(data, 0, middle - 1));
   int[] right = mergeSort(subArray(data, middle, data.Length - 1));
   int[] result = new int[data.Length];
   int dPtr = 0;
   int lPtr = 0;
   int rPtr = 0;
   while (dPtr < data.Length) {
      if (lPtr == left.Length) {
         result[dPtr] = right[rPtr];
         rPtr++;         
      } else if (rPtr == right.Length) {
         result[dPtr] = left[lPtr];
         lPtr++;
      } else if (left[lPtr] < right[rPtr]) {
         result[dPtr] = left[lPtr];
         lPtr++;
      } else {
         result[dPtr] = right[rPtr];
         rPtr++;         
      }
      dPtr++;
   }
   return result;
}

benjamin yap wrote:

The example takes in an integer, base on my code what should i take in? and if i wanan sort by name, how does the algorithm goes?

benjamin yap wrote:

int[] mergeSort (int[] data)

benjamin yap wrote:

public LinkList MergeSort(LinkList data)

  public static void qsort(char[] items) { 
    qs(items, 0, items.Length-1); 
  } 
 
  // A recursive version of Quicksort for characters. 
  static void qs(char[] items, int left, int right)  
  {  
    int i, j;  
    char x, y;  
  
    i = left; j = right;  
    x = items[(left+right)/2];  
  
    do {  
      while((items[i] < x) && (i < right)) i++;  
      while((x < items[j]) && (j > left)) j--;  
  
      if(i <= j) {  
        y = items[i];  
        items[i] = items[j];  
        items[j] = y;  
        i++; j--;  
      }  
    } while(i <= j);  
  
    if(left < j) qs(items, left, j);  
    if(i < right) qs(items, i, right);  
  } 
} 

public void qsort(LinkList list)
        {
            qs(list, 0, list.size - 1);
        }

        public void qs(LinkList list, int left, int right)
        {
            int i, j;
            LinkList
  
            i = left; j = right;
            x = list[(left+right)/2];

            do
            {
              while((list[i] < x) && (i < right)) i++;  
              while((x < list[j]) && (j > left)) j--;  
          
              if(i <= j) 
              {  
                y = list[i];  
                list[i] = list[j];  
                list[j] = y;  
                i++; j--;  
              }  
            } while(i <= j);  
  
            if(left < j) qs(list, left, j);  
            if(i < right) qs(list, i, right);  
  } 

benjamin yap wrote:

which is recommended?

benjamin yap wrote:

how should i store the connection string or etc etc?