Java常用十类快速排序算法总结

1、概述：

选择排序（直接选择排序，堆排序）

交换排序（冒泡排序，快速排序）

插入排序（直接插入排序，折半插入排序，Shell排序）

归并排序

桶式排序

基数排序

其中冒泡，插入，归并，基数属于稳定排序。

2、选择排序

2.1直接选择排序
/***

 * 选择排序实例代码，其核心思想：

 * 直接选择排序的基本操作就是每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，

 * 直到全部待排序的数据元素排完，它需要经过n-1趟比较。算法不稳定，O(1)的额外的空间，比较的时间复杂度为O(n^2)，

 * 交换的时间复杂度为O(n)，并不是自适应的。在大多数情况下都不推荐使用。只有在希望减少交换次数的情况下可以用。

 * 算法步骤：

 * n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果：

 * ①初始状态：无序区为R[1..n]，有序区为空。

 * ②第1趟排序

 * 在无序区R[1..n]中选出关键字最小的记录R[k]，将它与无序区的第1个记录R[1]交换，使R[1..1]和R[2..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

 * ③第i趟排序

 * 第i趟排序开始时，当前有序区和无序区分别为R[1..i-1]和R(1≤i≤n-1)。该趟排序从当前无序区中选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

 * 这样，n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果。

 * 参考链接：http://developer.51cto.com/art/201406/443115.htm 

 * http://blog.csdn.net/apei830/article/details/6584394
 * */

public class SelectSortTest {
public static void main(String[] args) {  

        int[] data = new int[] { 5, 3, 6, 2, 1, 9, 4, 8, 7 };  

        print(data);  

        selectSort(data);  

        print(data);  

    }  

  

    public static void swap(int[] data, int i, int j) {  

        if (i == j) {  

            return;  

        }  

        data[i] = data[i] + data[j];  

        data[j] = data[i] - data[j];  

        data[i] = data[i] - data[j];  

    }  

  

    public static void selectSort(int[] data) {  

        for (int i = 0; i < data.length - 1; i++) {  

            int minIndex = i; // 记录最小值的索引  

            for (int j = i + 1; j < data.length; j++) {  

                if (data[j] < data[minIndex]) {  

                    minIndex = j; // 若后面的元素值小于最小值,将j赋值给minIndex  

                }  

            }  

            if (minIndex != i) {  

                swap(data, i, minIndex);  

                print(data);  

            }  

        }  

    }  

  

    public static void print(int[] data) {  

        for (int i = 0; i < data.length; i++) {  

            System.out.print(data[i] + "\t");  

        }  

        System.out.println();  

    }  

}

2.2堆排序：

/***

 * 堆排序实例代码，其核心思想：

 * 是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：

 * 即子结点的键值或索引总是小于（或者大于）它的父节点。

 * 算法步骤：

 * 1、创建一个堆H[0..n-1]

 * 2、把堆首（最大值）和堆尾互换

 * 3、把堆的尺寸缩小1，并调用shift_down(0),目的是把新的数组顶端数据调整到相应位置

 * 4、重复步骤2，直到堆的尺寸为1

 * 参考链接：http://developer.51cto.com/art/201406/443115.htm 

 * http://blog.csdn.net/apei830/article/details/6584394
 * */

public class HeapSortTest {
public static void main(String[] args) {  
   int[] data5 = new int[] { 5, 3, 6, 2, 1, 9, 4, 8, 7 };  
   print(data5);  
   heapSort(data5);  
   System.out.println("排序后的数组：");  
   print(data5);
}
 

    public static void swap(int[] data, int i, int j) {  

        if (i == j) {  

            return;  

        }  

        data[i] = data[i] + data[j];  

        data[j] = data[i] - data[j];  

        data[i] = data[i] - data[j];  

    }  
 
   public static void heapSort(int[] data) {  
       for (int i = 0; i < data.length; i++) {  
           createMaxdHeap(data, data.length - 1 - i);  
           swap(data, 0, data.length - 1 - i);  
           print(data);  
       }  
   }  
 
   public static void createMaxdHeap(int[] data, int lastIndex) {  
       for (int i = (lastIndex - 1) / 2; i >= 0; i--) {  
           // 保存当前正在判断的节点  
           int k = i;  
           // 若当前节点的子节点存在  
           while (2 * k + 1 <= lastIndex) {  
               // biggerIndex总是记录较大节点的值,先赋值为当前判断节点的左子节点  
               int biggerIndex = 2 * k + 1;  
               if (biggerIndex < lastIndex) {  
                   // 若右子节点存在，否则此时biggerIndex应该等于 lastIndex  
                   if (data[biggerIndex] < data[biggerIndex + 1]) {  
                       // 若右子节点值比左子节点值大，则biggerIndex记录的是右子节点的值  
                       biggerIndex++;  
                   }  
               }  
               if (data[k] < data[biggerIndex]) {  
                   // 若当前节点值比子节点最大值小，则交换2者得值，交换后将biggerIndex值赋值给k  
                   swap(data, k, biggerIndex);  
                   k = biggerIndex;  
               } else {  
                   break;  
               }  
           }  
       }  
   }  
 
   public static void print(int[] data) {  
       for (int i = 0; i < data.length; i++) {  
           System.out.print(data[i] + "\t");  
       }  
       System.out.println();  
   }

}

3.交换排序：

3.1冒泡排序

/***

 * 冒泡排序实例代码，其核心思想：

 * 设想被排序的数组R［1..N］垂直竖立，将每个数据元素看作有重量的气泡，

 * 根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R，凡扫描到违反本原则的轻气泡，

 * 就使其向上"漂浮"，如此反复进行，直至最后任何两个气泡都是轻者在上，重者在下为止。

 * 参考链接：http://developer.51cto.com/art/201406/443115.htm 

 * http://blog.csdn.net/apei830/article/details/6584394
 * */

public class BubbleSortTest {
public static void main(String[] args) {  

        int[] data5 = new int[] { 5, 3, 6, 2, 1, 9, 4, 8, 7};  

        print(data5);  

        bubbleSort(data5);  

        System.out.println("排序后的数组：");  

        print(data5);  

    }  

  

    public static void swap(int[] data, int i, int j) {  

        if (i == j) {  

            return;  

        }  

        data[i] = data[i] + data[j];  

        data[j] = data[i] - data[j];  

        data[i] = data[i] - data[j];  

    }  

  

    public static void bubbleSort(int[] data) {  

        for (int i = 0; i < data.length - 1; i++) {  

            // 记录某趟是否发生交换，若为false表示数组已处于有序状态  

            boolean isSorted = false;  

            for (int j = 0; j < data.length - i - 1; j++) {  

                if (data[j] > data[j + 1]) {  

                    swap(data, j, j + 1);  

                    isSorted = true;  

                    print(data);  

                }  

            }  

            if (!isSorted) {  

                // 若数组已处于有序状态，结束循环  

                break;  

            }  

        }  

    }  

  

    public static void print(int[] data) {  

        for (int i = 0; i < data.length; i++) {  

            System.out.print(data[i] + "\t");  

        }  

        System.out.println();  

    }  

}

3.2快速排序：

/***

 * 快速排序实例代码，其核心思想：

 * 快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）

 * 算法步骤：

 * 1、 从数列中挑出一个元素，称为 “基准”（pivot）

 * 2、重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。

 * 3、递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

 * 参考链接：http://developer.51cto.com/art/201406/443115.htm 

 * http://blog.csdn.net/apei830/article/details/6584394
 * */

public class QuickSortTest {
public static void main(String[] args) {  

        int[] data = new int[] { 5, 3, 6, 2, 1, 9, 4, 8, 7 };  

        print(data);  

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

        System.out.println("排序后的数组：");  

        print(data);  

    }  

  

    public static void swap(int[] data, int i, int j) {  

        if (i == j) {  

            return;  

        }  

        data[i] = data[i] + data[j];  

        data[j] = data[i] - data[j];  

        data[i] = data[i] - data[j];  

    }  

  

    public static void quickSort(int[] data, int start, int end) {  

        if (start >= end)  

            return;  

        //以起始索引为分界点  

        int pivot = data[start];  

        int i = start + 1;  

        int j = end;  

        while (true) {  

            while (i <= end && data[i] < pivot) {  

                i++;  

            }  

            while (j > start && data[j] > pivot) {  

                j--;  

            }  

            if (i < j) {  

                swap(data, i, j);  

            } else {  

                break;  

            }  

        }  

        //交换 j和分界点的值  

        swap(data, start, j);  

        print(data);  

        //递归左子序列  

        quickSort(data, start, j - 1);  

        //递归右子序列  

        quickSort(data, j + 1, end);  

    }  

  

    public static void print(int[] data) {  

        for (int i = 0; i < data.length; i++) {  

            System.out.print(data[i] + "\t");  

        }  

        System.out.println();  

    }  

}

4.插入排序：

4.1直接插入排序：

/***

 * 直接插入排序实例代码，其核心思想：

 * 直接插入排序的基本操作就是将待排序的数据元素按其关键字值的大小插入到前面的有序序列中。

 * 直接插入的时间效率并不高，如果在最坏的情况下，所有元素的比较次数总和为（0+1+...+n-1）=O(n^2)。

 * 其他情况下也要考虑移动元素的次数，故时间复杂度为O(n^2)

 * 直接插入空间效率很好，只需要1个缓存数据单元，也就是说空间复杂度为O(1).

 * 直接插入排序是稳定的。

 * 直接插入排序在数据已有一定顺序的情况下，效率较好。但如果数据无规则，则需要移动大量的数据，其效率就与冒泡排序法和选择排序法一样差了。

 * 算法描述

 * 对一个有n个元素的数据序列，排序需要进行n-1趟插入操作：

 * 第1趟插入，将第2个元素插入前面的有序子序列--此时前面只有一个元素，当然是有序的。

 * 第2趟插入，将第3个元素插入前面的有序子序列，前面2个元素是有序的。

 * 第n-1趟插入，将第n个元素插入前面的有序子序列，前面n-1个元素是有序的。

 * 参考链接：http://developer.51cto.com/art/201406/443115.htm 

 * http://blog.csdn.net/apei830/article/details/6584394
 * */

public class InsertSortTest {
public static int count = 0;  
 

    public static void main(String[] args) {  

  

        int[] data = new int[] { 5, 3, 6, 2, 1, 9, 4, 8, 7 };  

        print(data);  

        insertSort(data);  

        print(data);  

  

    }  

  

    public static void insertSort(int[] data) {  

        for (int i = 1; i < data.length; i++) {  

            // 缓存i处的元素值  

            int tmp = data[i];  

            if (data[i] < data[i - 1]) {  

                int j = i - 1;  

                // 整体后移一格  

                while (j >= 0 && data[j] > tmp) {  

                    data[j + 1] = data[j];  

                    j--;  

                }  

                // 最后将tmp插入合适的位置  

                data[j + 1] = tmp;  

                print(data);  

            }  

        }  

    }  

  

    public static void print(int[] data) {  

        for (int i = 0; i < data.length; i++) {  

            System.out.print(data[i] + "\t");  

        }  

        System.out.println();  

    }  

}

4.2折半插入排序：

/***

 * 折半插入排序，其核心思想：

 * 折半插入排序法，又称二分插入排序法，是直接插入排序法的改良版，也需要执行i-1趟插入，

 * 不同之处在于，第i趟插入，先找出第i+1个元素应该插入的的位置，假定前i个数据是已经处于有序状态。

 * 参考链接：http://developer.51cto.com/art/201406/443115.htm 

 * http://blog.csdn.net/apei830/article/details/6584394
 * */

public class BinaryInsertSortTest {
public static int count = 0;  
 

    public static void main(String[] args) {  

  

        int[] data = new int[] { 5, 3, 6, 2, 1, 9, 4, 8, 7 };  

        print(data);  

        binaryInsertSort(data);  

        print(data);  

  

    }  

  

    public static void binaryInsertSort(int[] data) {  

        for (int i = 1; i < data.length; i++) {  

            if (data[i] < data[i - 1]) {  

                // 缓存i处的元素值  

                int tmp = data[i];  

                // 记录搜索范围的左边界  

                int low = 0;  

                // 记录搜索范围的右边界  

                int high = i - 1;  

                while (low <= high) {  

                    // 记录中间位置  

                    int mid = (low + high) / 2;  

                    // 比较中间位置数据和i处数据大小，以缩小搜索范围  

                    if (data[mid] < tmp) {  

                        low = mid + 1;  

                    } else {  

                        high = mid - 1;  

                    }  

                }  

                //将low~i处数据整体向后移动1位  

                for (int j = i; j > low; j--) {  

                    data[j] = data[j - 1];  

                }  

                data[low] = tmp;  

                print(data);  

            }  

        }  

    }  

  

    public static void print(int[] data) {  

        for (int i = 0; i < data.length; i++) {  

            System.out.print(data[i] + "\t");  

        }  

        System.out.println();  

    }  

}

4.3shell排序:

/***

 * 希尔排序，其核心思想：

 * 希尔排序(缩小增量法) 属于插入类排序,由Shell提出，希尔排序对直接插入排序进行了简单的改进：它通过加大插入排序中元素之间的间隔，

 * 并在这些有间隔的元素中进行插入排序，从而使数据项大跨度地移动，当这些数据项排过一趟序之后，希尔排序算法减小数据项的间隔再进行排序，

 * 依次进行下去，进行这些排序时的数据项之间的间隔被称为增量，习惯上用字母h来表示这个增量。

 * 常用的h序列由Knuth提出，该序列从1开始，通过如下公式产生：

 * h = 3 * h +1

 * 反过来程序需要反向计算h序列，应该使用

 * h=(h-1)/3

 * 参考链接：http://developer.51cto.com/art/201406/443115.htm 

 * http://blog.csdn.net/apei830/article/details/6584394
 * */

public class ShellSortTest {
public static int count = 0;  
 

    public static void main(String[] args) {  

  

        int[] data = new int[] { 5, 3, 6, 2, 1, 9, 4, 8, 7 };  

        print(data);  

        shellSort(data);  

        print(data);  

  

    }  

  

    public static void shellSort(int[] data) {  

        // 计算出最大的h值  

        int h = 1;  

        while (h <= data.length / 3) {  

            h = h * 3 + 1;  

        }  

        while (h > 0) {  

            for (int i = h; i < data.length; i += h) {  

                if (data[i] < data[i - h]) {  

                    int tmp = data[i];  

                    int j = i - h;  

                    while (j >= 0 && data[j] > tmp) {  

                        data[j + h] = data[j];  

                        j -= h;  

                    }  

                    data[j + h] = tmp;  

                    print(data);  

                }  

            }  

            // 计算出下一个h值  

            h = (h - 1) / 3;  

        }  

    }  

  

    public static void print(int[] data) {  

        for (int i = 0; i < data.length; i++) {  

            System.out.print(data[i] + "\t");  

        }  

        System.out.println();  

    }  

}

5.归并排序：

/***

 * 归并排序（Merge）是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

 * 归并排序（Merge sort，台湾译作：合并排序）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

 * 将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

 * 工作原理：

 * 1、申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列

 * 2、设定两个指针，最初位置分别为两个已经排序序列的起始位置

 * 3、比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置

 * 4、重复步骤3直到某一指针达到序列尾

 * 5、将另一序列剩下的所有元素直接复制到合并序列尾

 * 参考链接：http://developer.51cto.com/art/201406/443115.htm 

 * http://blog.csdn.net/apei830/article/details/6584394
 * */

public class MergeSortTest {
public static void main(String[] args) {  

        int[] data = new int[] { 5, 3, 6, 2, 1, 9, 4, 8, 7 };  

        print(data);  

        mergeSort(data);  

        System.out.println("排序后的数组：");  

        print(data);  

    }  

  

    public static void mergeSort(int[] data) {  

        sort(data, 0, data.length - 1);  

    }  

  

    public static void sort(int[] data, int left, int right) {  

        if (left >= right)  

            return;  

        // 找出中间索引  

        int center = (left + right) / 2;  

        // 对左边数组进行递归  

        sort(data, left, center);  

        // 对右边数组进行递归  

        sort(data, center + 1, right);  

        // 合并  

        merge(data, left, center, right);  

        print(data);  

    }  

  

    /** 

     * 将两个数组进行归并，归并前面2个数组已有序，归并后依然有序 

     *  

     * @param data 

     *            数组对象 

     * @param left 

     *            左数组的第一个元素的索引 

     * @param center 

     *            左数组的最后一个元素的索引，center+1是右数组第一个元素的索引 

     * @param right 

     *            右数组最后一个元素的索引 

     */  

    public static void merge(int[] data, int left, int center, int right) {  

        // 临时数组  

        int[] tmpArr = new int[data.length];  

        // 右数组第一个元素索引  

        int mid = center + 1;  

        // third 记录临时数组的索引  

        int third = left;  

        // 缓存左数组第一个元素的索引  

        int tmp = left;  

        while (left <= center && mid <= right) {  

            // 从两个数组中取出最小的放入临时数组  

            if (data[left] <= data[mid]) {  

                tmpArr[third++] = data[left++];  

            } else {  

                tmpArr[third++] = data[mid++];  

            }  

        }  

        // 剩余部分依次放入临时数组（实际上两个while只会执行其中一个）  

        while (mid <= right) {  

            tmpArr[third++] = data[mid++];  

        }  

        while (left <= center) {  

            tmpArr[third++] = data[left++];  

        }  

        // 将临时数组中的内容拷贝回原数组中  

        // （原left-right范围的内容被复制回原数组）  

        while (tmp <= right) {  

            data[tmp] = tmpArr[tmp++];  

        }  

    }  

  

    public static void print(int[] data) {  

        for (int i = 0; i < data.length; i++) {  

            System.out.print(data[i] + "\t");  

        }  

        System.out.println();  

    }  

}

6.桶式排序：

/***

 * 桶式排序不再是一种基于比较的排序方法，它是一种比较巧妙的排序方式，但这种排序方式需要待排序的序列满足以下两个特征：

 * 待排序列所有的值处于一个可枚举的范围之类；

 * 待排序列所在的这个可枚举的范围不应该太大，否则排序开销太大。

 * 排序的具体步骤如下：

 * （1）对于这个可枚举范围构建一个buckets数组，用于记录“落入”每个桶中元素的个数；

 * （2）将（1）中得到的buckets数组重新进行计算，按如下公式重新计算：

 * buckets[i] = buckets[i] +buckets[i-1] (其中1<=i<buckets.length); 

 * 参考链接：http://developer.51cto.com/art/201406/443115.htm 

 * http://blog.csdn.net/apei830/article/details/6584394
 * */

public class BucketSortTest {
public static int count = 0;  
 

    public static void main(String[] args) {  

  

        int[] data = new int[] { 5, 3, 6, 2, 1, 9, 4, 8, 7 };  

        print(data);  

        bucketSort(data, 0, 10);  

        print(data);  

  

    }  

  

    public static void bucketSort(int[] data, int min, int max) {  

        // 缓存数组  

        int[] tmp = new int[data.length];  

        // buckets用于记录待排序元素的信息  

        // buckets数组定义了max-min个桶  

        int[] buckets = new int[max - min];  

        // 计算每个元素在序列出现的次数  

        for (int i = 0; i < data.length; i++) {  

            buckets[data[i] - min]++;  

        }  

        // 计算“落入”各桶内的元素在有序序列中的位置  

        for (int i = 1; i < max - min; i++) {  

            buckets[i] = buckets[i] + buckets[i - 1];  

        }  

        // 将data中的元素完全复制到tmp数组中  

        System.arraycopy(data, 0, tmp, 0, data.length);  

        // 根据buckets数组中的信息将待排序列的各元素放入相应位置  

        for (int k = data.length - 1; k >= 0; k--) {  

            data[--buckets[tmp[k] - min]] = tmp[k];  

        }  

    }  

  

    public static void print(int[] data) {  

        for (int i = 0; i < data.length; i++) {  

            System.out.print(data[i] + "\t");  

        }  

        System.out.println();  

    }

}

7.基数排序：

import java.util.Arrays;

/***

 * 基数排序已经不再是一种常规的排序方式，它更多地像一种排序方法的应用，基数排序必须依赖于另外的排序方法。

 * 基数排序的总体思路就是将待排序数据拆分成多个关键字进行排序，也就是说，基数排序的实质是多关键字排序。

 * 多关键字排序的思路是将待排数据里德排序关键字拆分成多个排序关键字；第1个排序关键字，第2个排序关键字，第3个排序关键字......然后，

 * 根据子关键字对待排序数据进行排序。

 * 多关键字排序时有两种解决方案：

 * 最高位优先法（MSD）(Most Significant Digit first)

 * 最低位优先法（LSD）(Least Significant Digit first)

 * 例如，对如下数据序列进行排序。
192,221,12,23
可以观察到它的每个数据至多只有3位，因此可以将每个数据拆分成3个关键字：百位（高位）、十位、个位（低位）。
如果按照习惯思维，会先比较百位，百位大的数据大，百位相同的再比较十位，十位大的数据大；最后再比较个位。人得习惯思维是最高位优先方式。
如果按照人得思维方式，计算机实现起来有一定的困难，当开始比较十位时，程序还需要判断它们的百位是否相同--这就认为地增加了难度，计算机通常会选择最低位优先法。
基数排序方法对任一子关键字排序时必须借助于另一种排序方法，而且这种排序方法必须是稳定的。
对于多关键字拆分出来的子关键字，它们一定位于0-9这个可枚举的范围内，这个范围不大，因此用桶式排序效率非常好。
对于多关键字排序来说，程序将待排数据拆分成多个子关键字后，对子关键字排序既可以使用桶式排序，也可以使用任何一种稳定的排序方法。

 * 参考链接：http://developer.51cto.com/art/201406/443115.htm 

 * http://blog.csdn.net/apei830/article/details/6584394
 * */

public class MultiKeyRadixSortTest {
public static void main(String[] args) {  

        int[] data = new int[] { 1100, 192, 221, 12, 23 };  

        print(data);  

        radixSort(data, 10, 4);  

        System.out.println("排序后的数组：");  

        print(data);  

    }  

  

    public static void radixSort(int[] data, int radix, int d) {  

        // 缓存数组  

        int[] tmp = new int[data.length];  

        // buckets用于记录待排序元素的信息  

        // buckets数组定义了max-min个桶  

        int[] buckets = new int[radix];  

  

        for (int i = 0, rate = 1; i < d; i++) {  

  

            // 重置count数组，开始统计下一个关键字  

            Arrays.fill(buckets, 0);  

            // 将data中的元素完全复制到tmp数组中  

            System.arraycopy(data, 0, tmp, 0, data.length);  

  

            // 计算每个待排序数据的子关键字  

            for (int j = 0; j < data.length; j++) {  

                int subKey = (tmp[j] / rate) % radix;  

                buckets[subKey]++;  

            }  

  

            for (int j = 1; j < radix; j++) {  

                buckets[j] = buckets[j] + buckets[j - 1];  

            }  

  

            // 按子关键字对指定的数据进行排序  

            for (int m = data.length - 1; m >= 0; m--) {  

                int subKey = (tmp[m] / rate) % radix;  

                data[--buckets[subKey]] = tmp[m];  

            }  

            rate *= radix;  

        }  

  

    }  

  

    public static void print(int[] data) {  

        for (int i = 0; i < data.length; i++) {  

            System.out.print(data[i] + "\t");  

        }  

        System.out.println();  

    }  

}