一个数组变换的算法问题-关于前端的分页功能排序(点击/热门)功能

港控/mmm° 2022-08-21 06:48 20阅读 0赞

由于最近使用算法，所以算法用java来写的。(其实嘛，C写也是一样的)、

我们所需要的算法原则 如下所示

我们现在有一个数组 例如

1  2  3     4

5  6  7     8

9 10 11 12

现在的目的是将其转换为

1 2 7 8

3 4 9 10

5 6 11 12

现在也就是这样的原则

将数组中的数字以6个位一组抽取出来 然后放到另外的一个二维数组之中。

测试用例

Case 1

输入 1 2 3 4 5 6 7 8 9 10 11 12 m=3 n=4 p=2

输出 1 2 7 8 3 4 9 10 5 6 11 12

Case 2

输入 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 m=4 n = 4 p=2

输出 1 2 9 10 3 4 11 12  5 6  13 14 7 8 15 16

其中m n 分别为原来数组的行和列 p 表示将原先的列分成的几份

PS 其实这样还是有点奇怪的 毕竟万一要切行怎么办 所以算法有一定的局限性

对于原来的数字来说 他们在数组中的位置为 (原来的行为RowNum 列为ColumnNum )

行 number/ColumnNum 列为(number-1)%ColumnNum 包含数组中的第0行和第0列

转换后的数组坐标为

在说数组坐标之前 我们将数组分成很多的页 每页的列为n/P 每页的数字个数为m\*n/p

对于一个数字 我们首先确定他 在变换后矩阵中的位置

在矩阵2中 我们可以三维坐标定位 一个数组：

tab\_column     tab\_row      tab\_num\_index

首先数字位于变化后的第几张tab页 也就是 (number-1)/(m\*n/p)

这里为什么需要-1 是因为 比如一页6个元素 1/6=0 6/6=1 但是6仍然位于第0页上 而不是第1页

然后是元素的index 也就是这个元素属于这一页的第几个元素 tab\_index=number-tab\_num\_index\*(m\*n/p)

这里为了简要处理 可以将m\*n/p 用tabNum 来表示

这样只之后 就可以确定数字在新的页内的横纵坐标 tab\_row\_index=(tab\_index-1)/tab\_cloumn  tab\_column\_index=(tab\_index-1)%tab\_column

这样一个三维坐标 就可以确定一个数字了tab-index 位于第几页上面  tab\_row\_index  页内行坐标 tab\_column\_index 页内纵坐标

然后我们将关于页的三维坐标 转换为我们经常用的二维坐标

如果是横向的排序 real\_row=tab\_row\_index     real\_column=tab\_index\*tab\_column+tab\_column\_index

如果是纵向的排序real\_row=tab\_row\_index+tab\_index\*tab\_row     real\_column=tab\_column\_index

最后我们需要输出的是一个一维数组的形式 用一个以为数组对于原来的数组进行扫描就好了。

PS 到最后我都不明白为什么前端将一个分页功能的排序做的如此之复杂 但是 我也只能这样照做了。223

下面的代码

package test;
    
    public class test {
    	public static void sortTab(int m,int n,int p)
    	{
    
    		//int p=2;//原始列个数
    		//int m=4;
    		//int n=4;
    		//int p=2;
    		int tabRowNum=((m*n)/(n/p))/p;//变化后行个数 m行  n列
    		int tabColumnNum=p;//变化后列个数 P
    		int formerNum=m*n;//n
    		int tabNum=tabRowNum*tabColumnNum;
    		int row_index=0;
    		int column_index=0;
    		int tab_num_index=0;
    		int tab_current_index=0;
    		int row_tab_index=0;
    		int column_tab_index=0;
    		int arry_end[]=new int[formerNum];
    		int arry_sort[][]=new int[(formerNum/tabNum)*tabRowNum][(formerNum/tabNum)*tabColumnNum];
    		for(int i=1;i<=(formerNum);i++)
    		{
    			//i表示原来在数组中是第几个数字
    			//row_index=i/columnNum;
    			//column_index=(i-1)%columnNum;
    			//row column表示在 原二维数组中的位置 包含0行 0列
    			tab_num_index=(i-1)/tabNum;
    			tab_current_index=(i-1)%tabNum+1;
    			row_tab_index=(tab_current_index-1)/tabColumnNum;
    			column_tab_index=(tab_current_index-1)%tabColumnNum;
    			int temp_column=tab_num_index*tabColumnNum+column_tab_index;
    			int temp_row=row_tab_index;
    			arry_sort[temp_row][temp_column]=i;
    			//arry_sort[temp_row][temp_column]=tab_num_index*tabNum+tab_current_index;
    		}
    		int index_end=0;
    		for(int tab_i=0;tab_i<tabRowNum;tab_i++)
    		{
    			for(int tab_j=0;tab_j<((formerNum/tabNum)*tabColumnNum);tab_j++)
    			{ 
    				arry_end[index_end++]=arry_sort[tab_i][tab_j];
    			}
    		}
    		System.out.println("Sort Result:");
    		for(int j=0;j<formerNum;j++)
    		{
    			System.out.print(" "+arry_end[j]+" ");
    		}
    
    	}
    	public static void main(String args[])
    	{
    		/*
    
    		//int p=2;//原始列个数
    		int m=4;
    		int n=4;
    		int p=2;
    		int tabRowNum=((m*n)/(n/p))/p;//变化后行个数 m行  n列
    		int tabColumnNum=p;//变化后列个数 P
    		int formerNum=m*n;//n
    		int tabNum=tabRowNum*tabColumnNum;
    		int row_index=0;
    		int column_index=0;
    		int tab_num_index=0;
    		int tab_current_index=0;
    		int row_tab_index=0;
    		int column_tab_index=0;
    		int arry_end[]=new int[formerNum];
    		int arry_sort[][]=new int[(formerNum/tabNum)*tabRowNum][(formerNum/tabNum)*tabColumnNum];
    		for(int i=1;i<=(formerNum);i++)
    		{
    			//i表示原来在数组中是第几个数字
    			//row_index=i/columnNum;
    			//column_index=(i-1)%columnNum;
    			//row column表示在 原二维数组中的位置 包含0行 0列
    			tab_num_index=(i-1)/tabNum;
    			tab_current_index=(i-1)%tabNum+1;
    			row_tab_index=(tab_current_index-1)/tabColumnNum;
    			column_tab_index=(tab_current_index-1)%tabColumnNum;
    			int temp_column=tab_num_index*tabColumnNum+column_tab_index;
    			int temp_row=row_tab_index;
    			arry_sort[temp_row][temp_column]=i;
    			//arry_sort[temp_row][temp_column]=tab_num_index*tabNum+tab_current_index;
    		}
    		int index_end=0;
    		for(int tab_i=0;tab_i<tabRowNum;tab_i++)
    		{
    			for(int tab_j=0;tab_j<((formerNum/tabNum)*tabColumnNum);tab_j++)
    			{ 
    				arry_end[index_end++]=arry_sort[tab_i][tab_j];
    			}
    		}
    		System.out.println("Sort Result:");
    		for(int j=0;j<formerNum;j++)
    		{
    			System.out.print(" "+arry_end[j]+" ");
    		}
    */
    		sortTab(4,4,2);
    
    	    
    	}
    
    }

大神写的