手写算法

 

  1. package com.wxl.array;
  2.  
     
  3.  
    public class Sort {
  4.  
     
  5.  
    private static void show(int[] a) {
  6.  
    int i;
  7.  
    for(i=0;i<a.length;i++)
  8.  
    System.out.print(a[i]+"\t");
  9.  
    }
  10.  
     
  11.  
    public static void bubbleSort(int[] a) {
  12.  
    int i,j,temp,flag;
  13.  
    for(i=0;i<9;i++)
  14.  
    {
  15.  
    flag=1;//若本身有序,则只进行一次循环
  16.  
    for(j=0;j<9-i;j++)
  17.  
    if(a[j]>a[j+1])
  18.  
    {
  19.  
    temp=a[j];
  20.  
    a[j]=a[j+1];
  21.  
    a[j+1]=temp;
  22.  
    flag=0;
  23.  
    }
  24.  
    if(flag==1) break;
  25.  
    }
  26.  
    show(a);
  27.  
     
  28.  
    }
  29.  
     
  30.  
    public static void insertSort(int[] a) {
  31.  
    int i,j;
  32.  
     
  33.  
    int []b=new int[a.length+1];
  34.  
     
  35.  
    for(i=0;i<a.length;i++)
  36.  
    b[i+1]=a[i];
  37.  
     
  38.  
    for(i=2;i<=10;i++)
  39.  
    {
  40.  
    b[0]=b[i];
  41.  
    for(j=i-1;j>0;j--)//此处条件判断可直接换为b[0]<b[j]
  42.  
    if(b[0]<b[j])
  43.  
    b[j+1]=b[j];
  44.  
    b[j+1]=b[0];
  45.  
    }
  46.  
    for(i=0;i<a.length;i++)
  47.  
    a[i]=b[i+1];
  48.  
    show(a);
  49.  
    }
  50.  
     
  51.  
    public static void selectSort(int[] a) {
  52.  
    int i,flag,p,j,temp;
  53.  
    for (i = 0; i < 9; i++) {
  54.  
    flag = a[0];
  55.  
    p = 0;
  56.  
    for (j = 1; j < 9 - i; j++)
  57.  
    if (a[j] > flag) {
  58.  
    flag = a[j];
  59.  
    p = j;
  60.  
    }
  61.  
    if (a[p] > a[j]) {
  62.  
    temp = a[j];
  63.  
    a[j] = a[p];
  64.  
    a[p] = temp;
  65.  
    }
  66.  
     
  67.  
    }
  68.  
    show(a);
  69.  
    }
  70.  
     
  71.  
     
  72.  
     
  73.  
    public static void main(String args[]) {
  74.  
    int a[]= {9,8,7,6,5,4,3,2,1,0};
  75.  
    show(a);
  76.  
    System.out.println();
  77.  
    //bubbleSort(a);
  78.  
    //insertSort(a);
  79.  
    selectSort(a);
  80.  
    }
  81.  
    }

 

 

 

 

ackage cn.csuft.poorguy.struct;

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

	public static void quickSort(int[] arr, int left, int right) {
		
		//数组最左边小于最右边不合法,直接退出
		if (left > right) {
			return;
		}
		
		//定义变量i指向最左边
		int i = left;
		
		//定义变量j指向最右边
		int j = right;
		
		//定义左边为基准元素base
		int base = arr[left];

		//只要i和j没有指向同一个元素,就继续交换
		while (i != j) {

			//从右向左寻找第一个小于基准元素的数
			while (arr[j] >= base && i < j) {
				j--;
			}

			//从左向右寻找第一个大于基准元素的数
			while (arr[i] <= base && i < j) {
				i++;
			}

			//执行到这里证明找到了i和j指向的元素
			//交换i和j指向的元素
			int temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}

		//将i和j共同指向的元素与基准元素交换
		arr[left] = arr[i];
		arr[i] = base;

		//对左边进行快速排序
		quickSort(arr, left, i - 1);
		
		//对右边进行快速排序
		quickSort(arr, i + 1, right);
	}

 

 

 

 

手写快速排序(java实现)

时间复杂度:

  O(nlogn)

快速排序原理:

  1. 定义一个基准元素base(我这里定义的是最左面的元素定位基准元素)
  2. 定义两个变量i和j
  3. j先从右向左遍历,找到第一个比base小的数就停止
  4. i再从左向右便利找到第一个比base大的数停止
  5. 交换i和j指向的元素
  6. 直到i和j指向同一个元素,将这个元素与基准元素交换
  7. 递归求解即可

图解:(排序过程)

 

注意:

  上图为第一次快速排序的过程,递归过程和上图一致(没有给出)

 

每一次的排序结果:

  现在在火车上没有给出具体每次排序结果,回学校补上.

 

Java代码实现:

 
 
 
 
 
 

手写快速排序(java实现)

时间复杂度:

  O(nlogn)

快速排序原理:

  1. 定义一个基准元素base(我这里定义的是最左面的元素定位基准元素)
  2. 定义两个变量i和j
  3. j先从右向左遍历,找到第一个比base小的数就停止
  4. i再从左向右便利找到第一个比base大的数停止
  5. 交换i和j指向的元素
  6. 直到i和j指向同一个元素,将这个元素与基准元素交换
  7. 递归求解即可

图解:(排序过程)

 

注意:

  上图为第一次快速排序的过程,递归过程和上图一致(没有给出)

 

每一次的排序结果:

  现在在火车上没有给出具体每次排序结果,回学校补上.

 

Java代码实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
package cn.csuft.poorguy.struct;
 
public class quickSortText {
    public static void main(String[] args) {
        int[] arr = { 341269857 };
        quickSort(arr, 0, arr.length - 1);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
 
    public static void quickSort(int[] arr, int left, int right) {
         
        //数组最左边小于最右边不合法,直接退出
        if (left > right) {
            return;
        }
         
        //定义变量i指向最左边
        int i = left;
         
        //定义变量j指向最右边
        int j = right;
         
        //定义左边为基准元素base
        int base = arr[left];
 
        //只要i和j没有指向同一个元素,就继续交换
        while (i != j) {
 
            //从右向左寻找第一个小于基准元素的数
            while (arr[j] >= base && i < j) {
                j--;
            }
 
            //从左向右寻找第一个大于基准元素的数
            while (arr[i] <= base && i < j) {
                i++;
            }
 
            //执行到这里证明找到了i和j指向的元素
            //交换i和j指向的元素
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
 
        //将i和j共同指向的元素与基准元素交换
        arr[left] = arr[i];
        arr[i] = base;
 
        //对左边进行快速排序
        quickSort(arr, left, i - 1);
         
        //对右边进行快速排序
        quickSort(arr, i + 1, right);
    }
}
   
posted @   十一vs十一  阅读(153)  评论(0编辑  收藏  举报
努力加载评论中...
点击右上角即可分享
微信分享提示