1.各种排序
import java.util.Random;
/**
*
* 排序测试类
*
*
*
* 排序算法的分类如下:
*
* 1.插入排序(直接插入排序、折半插入排序、希尔排序);
*
* 2.交换排序(冒泡泡排序、快速排序);
*
* 3.选择排序(直接选择排序、堆排序);
*
* 4.归并排序;
*
* 5.基数排序。
*
*
*
* 关于排序方法的选择:
*
* (1)若n较小(如n≤50),可采用直接插入或直接选择排序。
*
* 当记录规模较小时,直接插入排序较好;否则因为直接选择移动的记录数少于直接插人,应选直接选择排序为宜。
*
* (2)若文件初始状态基本有序(指正序),则应选用直接插人、冒泡或随机的快速排序为宜;
*
* (3)若n较大,则应采用时间复杂度为O(nlgn)的排序方法:快速排序、堆排序或归并排序。
*
*
*
*/
public class SortTest {
/**
*
* 初始化测试数组的方法
*
* @return 一个初始化好的数组
*
*/
public int[] createArray() {
Random random = new Random();
int[] array = new int[10];
for (int i = 0; i < 10; i++) {
array[i] = random.nextInt(100) - random.nextInt(100);// 生成两个随机数相减,保证生成的数中有负数
}
System.out.println("==========原始序列==========");
printArray(array);
return array;
}
/**
*
* 打印数组中的元素到控制台
*
* @param source
*
*/
public void printArray(int[] data) {
for (int i : data) {
System.out.print(i + " ");
}
System.out.println();
}
/**
*
* 交换数组中指定的两元素的位置
*
* @param data
*
* @param x
*
* @param y
*
*/
private void swap(int[] data, int x, int y) {
int temp = data[x];
data[x] = data[y];
data[y] = temp;
}
/**
*
* 冒泡排序----交换排序的一种
*
* 方法:相邻两元素进行比较,如有需要则进行交换,每完成一次循环就将最大元素排在最后(如从小到大排序),下一次循环是将其他的数进行类似操作。
*
* 性能:比较次数O(n^2),n^2/2;交换次数O(n^2),n^2/4
*
*
*
* @param data
* 要排序的数组
*
* @param sortType
* 排序类型
*
* @return
*
*/
public void bubbleSort(int[] data, String sortType) {
if (sortType.equals("asc")) { // 正排序,从小排到大
// 比较的轮数
for (int i = 1; i < data.length; i++) {
// 将相邻两个数进行比较,较大的数往后冒泡
for (int j = 0; j < data.length - i; j++) {
if (data[j] > data[j + 1]) {
// 交换相邻两个数
swap(data, j, j + 1);
}
}
}
} else if (sortType.equals("desc")) { // 倒排序,从大排到小
// 比较的轮数
for (int i = 1; i < data.length; i++) {
// 将相邻两个数进行比较,较大的数往后冒泡
for (int j = 0; j < data.length - i; j++) {
if (data[j] < data[j + 1]) {
// 交换相邻两个数
swap(data, j, j + 1);
}
}
}
} else {
System.out.println("您输入的排序类型错误!");
}
printArray(data);// 输出冒泡排序后的数组值
}
/**
*
* 直接选择排序法----选择排序的一种
*
* 方法:每一趟从待排序的数据元素中选出最小(或最大)的一个元素, 顺序放在已排好序的数列的最后,直到全部待排序的数据元素排完。
*
* 性能:比较次数O(n^2),n^2/2
*
* 交换次数O(n),n
*
* 交换次数比冒泡排序少多了,由于交换所需CPU时间比比较所需的CUP时间多,所以选择排序比冒泡排序快。
*
* 但是N比较大时,比较所需的CPU时间占主要地位,所以这时的性能和冒泡排序差不太多,但毫无疑问肯定要快些。
*
*
*
* @param data
* 要排序的数组
*
* @param sortType
* 排序类型
*
* @return
*
*/
public void selectSort(int[] data, String sortType) {
if (sortType.equals("asc")) { // 正排序,从小排到大
int index;
for (int i = 1; i < data.length; i++) {
index = 0;
for (int j = 1; j <= data.length - i; j++) {
if (data[j] > data[index]) {
index = j;
}
}
// 交换在位置data.length-i和index(最大值)两个数
swap(data, data.length - i, index);
}
} else if (sortType.equals("desc")) { // 倒排序,从大排到小
int index;
for (int i = 1; i < data.length; i++) {
index = 0;
for (int j = 1; j <= data.length - i; j++) {
if (data[j] < data[index]) {
index = j;
}
}
// 交换在位置data.length-i和index(最大值)两个数
swap(data, data.length - i, index);
}
} else {
System.out.println("您输入的排序类型错误!");
}
printArray(data);// 输出直接选择排序后的数组值
}
/**
*
* 插入排序
*
* 方法:将一个记录插入到已排好序的有序表(有可能是空表)中,从而得到一个新的记录数增1的有序表。
*
* 性能:比较次数O(n^2),n^2/4
*
* 复制次数O(n),n^2/4
*
* 比较次数是前两者的一般,而复制所需的CPU时间较交换少,所以性能上比冒泡排序提高一倍多,而比选择排序也要快。
*
*
*
* @param data
* 要排序的数组
*
* @param sortType
* 排序类型
*
*/
public void insertSort(int[] data, String sortType) {
if (sortType.equals("asc")) { // 正排序,从小排到大
// 比较的轮数
for (int i = 1; i < data.length; i++) {
// 保证前i+1个数排好序
int temp = data[i];
int j;
for (j = i; j > 0 && data[j - 1] < temp; j--) {
data[j] = data[j - 1];
}
data[j] = temp;
}
} else if (sortType.equals("desc")) { // 倒排序,从大排到小
// 比较的轮数
for (int i = 1; i < data.length; i++) {
// 保证前i+1个数排好序
int temp = data[i];
int j;
for (j = i; j > 0 && data[j - 1] < temp; j--) {
data[j] = data[j - 1];
}
data[j] = temp;
}
} else {
System.out.println("您输入的排序类型错误!");
}
printArray(data);// 输出插入排序后的数组值
}
/**
*
* 反转数组的方法
*
* @param data
* 源数组
*
*/
public void reverse(int[] data) {
int length = data.length;
int temp = 0;// 临时变量
for (int i = 0; i < length / 2; i++) {
temp = data[i];
data[i] = data[length - 1 - i];
data[length - 1 - i] = temp;
}
printArray(data);// 输出到转后数组的值
}
/**
*
* 快速排序
*
* 快速排序使用分治法(Divide and conquer)策略来把一个序列(list)分为两个子序列(sub-lists)。
*
* 步骤为:
*
* 1. 从数列中挑出一个元素,称为 "基准"(pivot),
*
* 2.
* 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分割之后,该基准是它的最后位置。这个称为分割(partition)操作。
*
* 3. 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。
*
* 递回的最底部情形,是数列的大小是零或一,也就是永远都已经被排序好了。虽然一直递回下去,但是这个算法总会结束,因为在每次的迭代(iteration)中,它至少会把一个元素摆到它最后的位置去。
*
* @param data
* 待排序的数组
*
* @param low
*
* @param high
*
* @see SortTest#qsort(int[], int, int)
*
* @see SortTest#qsort_desc(int[], int, int)
*
*/
public void quickSort(int[] data, String sortType) {
if (sortType.equals("asc")) { // 正排序,从小排到大
qsort_asc(data, 0, data.length - 1);
} else if (sortType.equals("desc")) { // 倒排序,从大排到小
qsort_desc(data, 0, data.length - 1);
} else {
System.out.println("您输入的排序类型错误!");
}
}
/**
*
* 快速排序的具体实现,排正序
*
* @param data
*
* @param low
*
* @param high
*
*/
private void qsort_asc(int data[], int low, int high) {
int i, j, x;
if (low < high) { // 这个条件用来结束递归
i = low;
j = high;
x = data[i];
while (i < j) {
while (i < j && data[j] > x) {
j--; // 从右向左找第一个小于x的数
}
if (i < j) {
data[i] = data[j];
i++;
}
while (i < j && data[i] < x) {
i++; // 从左向右找第一个大于x的数
}
if (i < j) {
data[j] = data[i];
j--;
}
}
data[i] = x;
qsort_asc(data, low, i - 1);
qsort_asc(data, i + 1, high);
}
}
/**
*
* 快速排序的具体实现,排倒序
*
* @param data
*
* @param low
*
* @param high
*
*/
private void qsort_desc(int data[], int low, int high) {
int i, j, x;
if (low < high) { // 这个条件用来结束递归
i = low;
j = high;
x = data[i];
while (i < j) {
while (i < j && data[j] < x) {
j--; // 从右向左找第一个小于x的数
}
if (i < j) {
data[i] = data[j];
i++;
}
while (i < j && data[i] > x) {
i++; // 从左向右找第一个大于x的数
}
if (i < j) {
data[j] = data[i];
j--;
}
}
data[i] = x;
qsort_desc(data, low, i - 1);
qsort_desc(data, i + 1, high);
}
}
/**
*
* 二分查找特定整数在整型数组中的位置(递归)
*
* 查找线性表必须是有序列表
*
* @paramdataset
*
* @paramdata
*
* @parambeginIndex
*
* @paramendIndex
*
* @returnindex
*
*/
public int binarySearch(int[] dataset, int data, int beginIndex,
int endIndex) {
int midIndex = (beginIndex + endIndex) >>> 1; // 相当于mid = (low + high)
// / 2,但是效率会高些
if (data < dataset[beginIndex] || data > dataset[endIndex]
|| beginIndex > endIndex)
return -1;
if (data < dataset[midIndex]) {
return binarySearch(dataset, data, beginIndex, midIndex - 1);
} else if (data > dataset[midIndex]) {
return binarySearch(dataset, data, midIndex + 1, endIndex);
} else {
return midIndex;
}
}
/**
*
* 二分查找特定整数在整型数组中的位置(非递归)
*
* 查找线性表必须是有序列表
*
* @paramdataset
*
* @paramdata
*
* @returnindex
*
*/
public int binarySearch(int[] dataset, int data) {
int beginIndex = 0;
int endIndex = dataset.length - 1;
int midIndex = -1;
if (data < dataset[beginIndex] || data > dataset[endIndex]
|| beginIndex > endIndex)
return -1;
while (beginIndex <= endIndex) {
midIndex = (beginIndex + endIndex) >>> 1; // 相当于midIndex =
// (beginIndex +
// endIndex) / 2,但是效率会高些
if (data < dataset[midIndex]) {
endIndex = midIndex - 1;
} else if (data > dataset[midIndex]) {
beginIndex = midIndex + 1;
} else {
return midIndex;
}
}
return -1;
}
public static void main(String[] args) {
SortTest sortTest = new SortTest();
int[] array = sortTest.createArray();
System.out.println("==========冒泡排序后(正序)==========");
sortTest.bubbleSort(array, "asc");
System.out.println("==========冒泡排序后(倒序)==========");
sortTest.bubbleSort(array, "desc");
array = sortTest.createArray();
System.out.println("==========倒转数组后==========");
sortTest.reverse(array);
array = sortTest.createArray();
System.out.println("==========选择排序后(正序)==========");
sortTest.selectSort(array, "asc");
System.out.println("==========选择排序后(倒序)==========");
sortTest.selectSort(array, "desc");
array = sortTest.createArray();
System.out.println("==========插入排序后(正序)==========");
sortTest.insertSort(array, "asc");
System.out.println("==========插入排序后(倒序)==========");
sortTest.insertSort(array, "desc");
array = sortTest.createArray();
System.out.println("==========快速排序后(正序)==========");
sortTest.quickSort(array, "asc");
sortTest.printArray(array);
System.out.println("==========快速排序后(倒序)==========");
sortTest.quickSort(array, "desc");
sortTest.printArray(array);
System.out.println("==========数组二分查找==========");
System.out.println("您要找的数在第" + sortTest.binarySearch(array, 74)
+ "个位子。(下标从0计算)");
}
}
2、查找
// 查找
typedef int eletype;// 默认设置元素类型为int
int n;// 默认元素个数为n
// 简单顺序查找
// 平均查找长度(n+1)/2
int seq_search(eletype A[n+1],eletype x)
{
int i = n;
A[0] = x;// 充当监视哨
while( A[i]!=x )
i--;
return i;
}
// 有序表的二分查找
// 等概率下,平均查找长度为(n+1)/n*log(n+1)-1
int bin_search(eletype A[n],eletype x)
{
int mid,low = 0,high = n-1;
while (low <= high)
{
mid = (low+high)/2;
if (x == A[mid])
return mid;
else
if(x < A[mid])
high = mid -1;
else
low = mid + 1;
}
return -1;
}
int bin_search(eletype A[n],int low, int high, eletype x)// 递归形式
{
if(low>high)
return -1;
else
{
int mid = (low+high)/2;
if (x == A[mid])
return mid;
else
if(x < A[mid])
return bin_search(A,low,mid-1,x);
else
return bin_search(A,mid+1,high,x);
}
}
// 分治法(divide and conquer)
// 对于一个规模为n的问题,若该问题可以容易地解决,则直接解决,否则将其分解为k个规模较小
// 的子问题,这些子问题互相独立且与原问题形式相同,递归地解这些子问题,然后将各子问题的
// 解合并,得到原问题的解。
// 分治法在每一层递归上由三个步骤组成:
// 划分:将原问题分解为若干规模较小、互相独立、与原问题形式相同的子问题
// 解决:若子问题规模较小,则直接求解;否则递归求解各子问题
// 合并:将各子问题的解合并为原问题的解
// 二叉排序树的查找
// 二叉排序树的中序序列是递增序列,二叉排序树中某节点的查找长度等于该节点的层次数
struct Bnode
{
eletype data;
Bnode *lchild;
Bnode *rchild;
};
Bnode *bst_serch(Bnode*T,eletypex)
{
Bnode *p = T;
while (p != NULL)
{
if(x == p->data)
return p;
else
if(x < p->data)
p = p->lchild;
else
p = p->rchild;
}
return p;
}
Bnode *bst_serch(Bnode*T,eletypex)// 递归形式
{
if(T == NULL || x == T->data)
return T;
else
if(x < T->data)
return bst_serch(T->lchild,x);
else
return bst_serch(T->rchild,x);
}
void insert(Bnode *&T, Bnode *s)
{
if(T == NULL)
T = s;
else
if(s->data < T->data)
insert(T->lchild,s);
else
insert(T->rchild,s);
}
// 排序定义:将数据表调整为按关键字从小到大或从大到小的次序排列的过程
// 分类:增排序、减排序;内部排序、外部排序;稳定排序、不稳定排序
// 大多数的排序算法都有两个基本的操作:比较两个关键字的大小;改变指向记录的指针或移动记录本身。
// 评价标准:执行时间和所需的辅助空间;算法本身的复杂度。
// 存储方式:
// 顺序表:通过关键字之间的比较判定,将记录移动到合适的位置
// 链表:无需移动记录,仅需修改指针
// 顺序表+辅助表:只需对辅助表的表目进行物理重排。适用于难于在链表上实现,且仍需避免排序过程中移动记录的排序方法
typedef int eletype;// 默认设置元素类型为int
int n;// 默认元素个数为n
// 插入排序
// 基本思想:将待排序表看做是左右两部分,其中左边为有序区,右边为无序区,整个排序过程就是将右边无序区中的元素逐个插入到左边的
// 有序区中,以构成新的有序区。
// 分类:直接插入排序和希尔排序
// 直接插入排序
// 稳定排序
// 一般是o(n*n);当序列为正序或基本有序时,时间复杂度为o(n);
void insert_sort(eletype A[n+1])
{
eletype temp;
int j;
for (int i=2;i<n+1;i++)
{
temp = A[i];
j = i-1;
while (A[j]>temp)
{
A[j+1] = A[j];
j = j-1;
}
A[j+1] = temp;
}
}
void insert_sort(eletype A[n+1])// 采用监视哨
{
int j;
for (int i=2;i<n+1;i++)
{
A[0] = A[i];
j = i-1;
while (A[j]>A[0])
{
A[j+1] = A[j];
j = j-1;
}
}
}
// 希尔排序
// 将待排序列划分为若干组,在每组内进行直接插入排序,以使整个序列基本有序,然后再对整个序列进行直接插入排序。
// 步长的选择很关键
// 不稳定排序,o(nlogn)
void shell_sort(eletype A[n])
{
int j,d = n/2;
eletype x;
while (d>=1)
{
for (int i=d;i<n;i++)
{
x = A[i];
j = i-d;
while (j>=0&& A[j]>x)
{
A[j+d] = A[j];
j = j-d;
}
A[j+d] = x;
}
d = d/2;
}
}
// 交换排序
// 基本思想:两两比较待排列的元素,发现倒序即交换
// 分类:冒泡排序和快速排序
// 冒泡排序
// 基本思想:从一端开始,逐个比较相邻的两个元素,发现倒序即交换
// 稳定排序,时间复杂度为o(n*n)
void bubble_sort(eletype A[n+1])
{
for (int i=1;i<n;i++)
{
for (int j=n;j>=i+1;j--)
{
if (A[j]<A[j-1])
A[j] <-->A[j-1];
}
}
}
void bubble_sort(eletype A[n+1])// 改进的冒泡排序
{
int i=1;
bool exchanged;
do
{
exchanged = false;
for (int j=n;j>=i+1;j--)
{
if (A[j]<A[j-1])
{
A[j] <-->A[j-1];
}
exchanged = true;
}
i++;
} while (i<n && exchanged==true);
}
// 快速排序
// 基本思想:首先,选定一个元素作为中间元素,然后将表中所有元素与该中间元素做比
// 较,将表中比中间元素小的元素调到表的前面,将比中间元素大的元素调到后面,再将
// 中间元素放在这两个部分之间以作为分界点,这样便得到一个划分。然后再对左右两部
// 分分别进行快速排序(即对所得到的两个子表再采用相同的方式来划分和排序,直到每
// 个子表仅有 一个元素或为空表为止。此时便得到一个有序表)
// 不稳定排序,时间复杂度o(k*n*logn)
// 从平均时间性能来说,快速排序是目前被认为最好的一种内部排序算法
void partition(eletype A[n],int s,int t,int *cutpoint)
{
eletype x = A[s];
int i=s,j=t;
while (i != j)
{
while(i<j && A[j]>x) j--;
if(i<j)
{
A[i] = A[j];
i = i+1;
}
while(i<j && A[i]<x) i++;
if(i<j)
{
A[j] = A[i];
j = j-1;
}
}
A[i] = x;
*cutpoint = i;
}
void quick_sort(eletype A[n],int s,int t)
{
int *i = NULL;
if (s<t)
{
partition(A,s,t,*i);
quick_sort(A,s,*i-1);
quick_sort(A,*i+1,t);
}
}
// 选择排序
// 基本思想:在每一趟排序中,在待排序子表中选出关键字最小或最大的元素放在其最终 // 位置上。
// 分类:直接选择排序和堆排序
// 直接选择排序
// 基本思想:在待排序子表中完整地比较一遍以确定最大(小)元素,并将该元素放在子表的最前(后)面。
// 不稳定排序,时间复杂度是o(n*n)
void select_sort(eletype A[n])
{
int min;
for (int i=0;i<n-1;i++)
{
min = i;
for (int j=i+1;j<n;j++)
{
if(A[j] < A[min])
min = j;
}
if(min != i)
A[min]<--> A[i];
}
}
// 堆排序
// 不稳定排序,时间复杂度是o(nlogn)
void sift(eletype A[n+1],int k,int m)
// 调整数组中下标为-n的元素中的序号不大于m的以k为根的子序列
// 假设以k和k+1为根的左右子树均是堆
{
eletype x = A[k];
bool finished = false;// 临时保存当前根值,空出位置,并设未结束标志
int i,j;
i = k;
j = 2*i;// i指示空位,j先指向左孩子节点
while (j<=m && !finished)// 确定i节点不是叶子且搜索未结束
{
if(j<m && A[j]<A[j+1])// 让j指向左右孩子中的最大者
j = j+1;
if( x>=A[j] )// 原根为最大,置结束筛选标志
finished = true;
else
{
A[i] = A[j];// 值大的孩子节点上移
i = j;
j = 2*j;// 继续往下筛选:i指向新的空位,j相应改变
}
}
A[i] = x;// 将原根值填充到所搜索到的当前的空位置中
}
void heap_sort(eletype A[],int n)
// 对数组中下标为-n的元素用堆排序算法实现排序
{
int i;
for (i=n/2;i>=1;i--)
sift(A,i,n);// 建初始堆
for(i=n;i>=2;i--)// 控制排序过程
{
A[i]<-->A[1];// 输出根
sift(A,1,i-1);// 调整子序列A[1]-A[i-1]为堆
}
}
// 归并排序
// 基本思想:是一种基于归并的排序,所谓归并是指将两个或两个以上的有序表合并成一个新的有序表。
// 归并
void merge(eletype A[],eletype B[],eletype C[],int la,int lb,int lc)
{
int ia=1,ib=1,ic=1;
while(ia<=la &&ib<=lb)
if (A[ia]<=B[ib])
C[ic++] = A[ia++];
else
C[ic++] = B[ib++];
while(ia<=la)
C[ic++] = A[ia++];
while(ib<=lb)
C[ic++] = B[ib++];
}
// 归并排序
// 需要原表等量的辅助存储空间,时间复杂度为o(nlogn)
// 实现:首先将整个表看成是n个有序子表,每个子表的长度为。然后两两归并,得到n/2个长度为的有序子表。然后再两两归并,
// 得到n/4个长度为的有序子表。以此类推,直至得到一个长度为n的有序表为止。