常见数据结构的Java实现

单链表的Java实现

首先参考wiki上的单链表说明，单链表每个节点包含数据和指向链表中下一个节点的指针或引用。然后看代码

import java.lang.*;

public class SinglyLinkeList

{

    Node start;

    public SinnglyLinkedList()

    {

      this.start=null;

    }



    public void addFront(Object newData)

    {

        Node cache = this.start; //store a reference to the current start node

        this.start = new Node(newData,cache); //assign our start to a new node that has newData and points to our old start

    }

    public addRear(Object newData)

    {

        Node cache = start; 

        Node current = null;



        while((current = cache.next) != null) //find the last Node

            cache = cache.next;



        cache.next = new Node(newData,null); //create a new node that has newData and points to null

    }



    public Object getFront()

    {

        return this.start.data; // return the front object's data

    }



    public class Node

    {

        public Object data; //the data stored in this node

        public Node next; //store a reference to the next node in this singlylinkedlist

        public Node(Object data,Node next){

            this.data =data;

            this.next =next;

        }

    }

}

单链表翻转的Java实现

循环方式

public static LinkedList reverse(LinkedList Node) {

    LinkedList previous = null;

    while (Node != null) {

        LinkedList next = Node.next;

        Node.next = previous;

        previous = Node;

        Node = next;

    }

    return previous;

}



package linkedlists;

public static LinkedList reverse(LinkedList node) {

LinkedList headNode = new LinkedList(1);

快速排序的Java实现

public class QuickSort {

  

 public static int SIZE = 1000000;

 

 public int[] sort(int[] input) {

  quickSort(input, 0, input.length-1);

  return input;

 }

  

 public static void main(String args[]){

  int[] a = new int[SIZE];

  for(int i=0;i<SIZE;i++){

   a[i] = (int)(Math.random()*SIZE);

  }

  QuickSort mNew = new QuickSort();

  long start = System.currentTimeMillis();

  mNew.sort(a);

  long end = System.currentTimeMillis();

  System.out.println("Time taken to sort a million elements : "+(end-start)+" milliseconds");

 }

  

 public void print(int[] inputData) {

  for(int i:inputData){

   System.out.print(i+" ");

  }

  System.out.println();

 }

  

 private void quickSort(int arr[], int left, int right) {

  int index = partition(arr, left, right);

  if (left < index - 1)

   quickSort(arr, left, index - 1);

  if (index < right)

   quickSort(arr, index, right);

 }

  

 private int partition(int arr[], int left, int right) {

  int i = left, j = right;

  int tmp;

  int pivot = arr[(left + right) / 2];

  while (i <= j) {

   while (arr[i] < pivot)

    i++;

   while (arr[j] > pivot)

    j--;

   if (i <= j) {

    tmp = arr[i];

    arr[i] = arr[j];

    arr[j] = tmp;

    i++;

    j--;

   }

  }

  return i;

 }

}