java--数据结构--8种排序算法

1.直接插入排序

直接插入排序：
public class SortArray {
  public static void main(String[] args) {
    int a[] = {2,4,6,1,3,8,9,7,5};
    insertionSort(a);
    for(int i = 0;i < a.length;i++)
      System.out.print(a[i] + " ");
  }
// insertionSort必须为static方法，因为不能再静态上下文中引用非静态的方法
  public static int[] insertionSort(int a[]) {
    for(int i = 1;i < a.length;i++) {
      for(int j = i;j > 0;j--) {
        if(a[j] < a[j-1]) {
          int temp = a[j];
          a[j] = a[j-1];
          a[j-1] = temp;
        }
      }
    }
    return a;
  }
}

2.折半插入排序

折半插入排序：
public class SortArray {
  public static void main(String[] args) {
    int a[] = {2,4,6,1,3,8,9,7,5};
    binaryInsertSort(a);
    for(int i = 0;i< a.length;i++){
      System.out.println(a[i] + "");
    }
  }

  public static int[] binaryInsertSort(int a[]) {
    for(int i = 1;i < a.length;i++) {
      int temp = a[i];
      int low = 0;
      int high = i-1;

      while(low <= high) {
        int mid = (low + high)/2;
       if(temp < a[mid]) {
         high = mid - 1;
       }else{
         low = mid + 1;
       }
      }

      for(int j = i; j >=low + 1;j--){
        a[j] = a[j-1];
      }
      a[low] = temp;
    }
    return a;
  }
}

3.希尔排序

希尔排序
public class SortArray {
  public static void main(String[] args) {
    int a[] = {2,4,6,1,3,8,9,7,5};
    shellInsertSort(a);
    for(int i = 0;i< a.length;i++){
      System.out.println(a[i] + "");
    }
  }

  public static int[] shellInsertSort(int a[]) {
    int d = a.length;
    while(true)
    {
      d = d/2;
      for(int x = 0;x < d;x++){
        for(int i = x + d;i < a.length;i = i + d) {
          int temp = a[i];
          int j;
          // 注意判断条件j >= 0要在a[j] > temp前边，否则若j为负，a[j] > temp中数组不合法会运行报错
          for(j = i - d; j >= 0 && a[j] > temp;j = j-d) {
            a[j+d] = a[j];
          }
          a[j+d] = temp;
        }
      }
      if(d == 1){
        break;
      }
    }
    return a;
  }
}

4.简单选择排序

简单选择排序
public class SortArray {
  public static void main(String[] args) {
    int a[] = {2,4,6,1,3,8,9,7,5};
    selectSort(a);
    for(int i = 0;i< a.length;i++){
      System.out.println(a[i] + "");
    }
  }

  public static int[] selectSort(int a[]) {
    int i,j,minIndex;
    for(i = 0;i < a.length;i++){
      minIndex = i;
      for(j = i + 1;j < a.length;j++){
        if(a[minIndex] > a[j]){
          minIndex = j;
        }
      }
      int temp = a[i];
      a[i] = a[minIndex];
      a[minIndex] = temp;
    }
    return a;
  }
}

5.堆排序

堆排序：（答案还有问题）
public class SortArray {
  public static void main(String[] args) {
    int a[] = {2,4,6,1,3,8,9,7,5};
    heapSort(a);
    for(int i = 0;i< a.length;i++){
      System.out.print(a[i] + " ");
    }
  }

  public static int[] heapSort(int a[]) {

    for(int i = a.length/2 - 1;i >= 0;--i){
      heapAdjust(a,i);
    }

    for(int i = a.length - 1;i > 0;--i) {
      int temp = a[i];
      a[i] = a[0];
      a[0] = temp;
      heapAdjust(a,i);
    }
    return a;
  }

  public static int[] heapAdjust(int a[],int i) {
    int temp = a[i];
    int child = 2*i + 1;
    while(child < a.length){

      if(child + 1 < a.length && a[child] < a[child+1]) {
        ++child;
      }
      if(a[i] < a[child]) {
        a[i] = a[child];
        i = child;
        child = 2 * i + 1;
      }else {
        break;
      }
    }
    a[i] = temp;
    return a;
  }
}



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();
    }

}

6.冒泡排序

冒泡排序：
public class SortArray {
  public static void main(String[] args) {
    int a[] = {2,4,6,1,3,8,9,7,5};
    bubbleSort(a);
    for(int i = 0;i< a.length;i++){
      System.out.print(a[i] + " ");
    }
  }

  public static int[] bubbleSort(int a[]) {
    int i = a.length;
    int temp,j;
    while(i > 0) {
      for(j = 0;j < i-1;j++) {
        if(a[j] > a[j+1]) {
          temp = a[j];
          a[j] = a[j+1];
          a[j+1] = temp;
        }
      }
      i--;
    }
    return a;
  }
}

7.快速排序

快速排序：
public class SortArray {
  public static void main(String[] args) {
    int a[] = {2,4,6,1,3,8,9,7,5};
    quickSort(a,0,a.length-1);
    for(int i = 0;i< a.length;i++){
      System.out.print(a[i] + " ");
    }
  }

  public static int[] quickSort(int a[],int left,int right) {
    int dp;
    if(left < right) {
      dp = partition(a,left,right);
      quickSort(a,left,dp - 1);
      quickSort(a,dp + 1,right);
    }
    return a;
  }

  public static int partition(int a[], int left,int right) {

    int temp;
    int pivot = a[left];
    while(left < right) {
      while(left < right && a[right] > pivot) {
        right--;
      }
      if(left < right) {
        temp = a[left];
        a[left] = a[right];
        a[right] = temp;
      }
      while(left < right && a[left] < pivot) {
        left++;
      }
      if(left < right) {
        temp = a[left];
        a[left] = a[right];
        a[right] = temp;
      }
      a[left] = pivot;

    }
    return left;
  }
}

8.归并排序

归并排序：
public class SortArray {
  public static void main(String[] args) {
    int a[] = {2,4,6,1,3,8,9,7,5};
    mergeSort(a,0,a.length-1);
    for(int i = 0;i < a.length;i++){
      System.out.print(a[i] + " ");
    }
  }

  public static int[] mergeSort(int a[],int low,int high) {
    int mid = (low + high)/2;
    if(low < high) {
      mergeSort(a,low,mid);
      mergeSort(a,mid+1,high);
      merge(a,low,mid,high);
    }
    return a;
  }

  public static void merge(int a[],int low,int mid,int high) {
    int array[] = new int[high - low +1];
    //左指针
    int i = low;
    // 右指针
    int j = mid + 1;
    int k = 0;
    // 把较小的数先移到新数组中
    while(i <= mid && j <= high) {
      if(a[i] < a[j]) {
        array[k++] = a[i++];
      }else {
        array[k++] = a[j++];
      }
    }
    // 把左边剩余的数移到数组
    while(i <= mid) {
      array[k++] = a[i++];
    }
    // 把右边剩余的数移到数组
    while(j <= high) {
      array[k++] = a[j++];
    }
    // 把新数组中的数覆盖a数组
    for(int k2 = 0;k2 <array.length;k2++) {
      a[k2 + low] = array[k2];
    }
  }
}