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)