线性表之顺序表增强操作

一,线性表的一些增强操作

1,合并有序顺序表

两个索引,分别指向两个顺序表的0索引,然后进行相互比较大小,索引前移.

需要注意的是,两个顺序表可能会有一个先遍历完,所以最后判断是否要有剩余未遍历的

 

2,删除某个范围内的元素

和删除某个元素思路一致

 

3,将顺序表元素进行重组, 小于等于某个value的放在左端,大于这个value的放在右边

类似快速排序的一趟排序过程. 使用两个索引, 一个头,一个尾,相向移动

 

4,删除顺序表中所有重复的元素

初试条件可以把[0]做不重复区间,然后1索引出与[0]区域比较,如果没有重复的,放入区域[0 1]

然后2索引与[0 1]进行比较,如果不重复,放入区域[0,1,2]

....

直至完毕

 

5,删除有顺序表中所有重复的元素

因为有序,所以一趟遍历就可以解决,每次i索引处的值和i-1处的索引值比较即可

 

二,对应代码如下:

 

package com.zl.ds;

public class SequenceListAlgorithm {
	/**
	 * 有序顺序表的归并
	 * 
	 * @param first
	 *            有序顺序表
	 * @param second
	 *            有序顺序
	 * @return first和second有序顺序表合并后的结果
	 */
	// 利用两个下标分别表示first和second, 向前比较.注意,其中一个可能先访问完毕,另外一个有剩余元素没有访问
	public SequenceList<Integer> mergeOrderedSeqList(SequenceList<Integer> first, SequenceList<Integer> second) {

		if (first == null) {
			return second;
		}

		if (second == null) {
			return first;
		}

		int i = 0, j = 0;
		int firstLen = first.size(), secondLen = second.size();
		SequenceList<Integer> mergedList = new SequenceList<Integer>(firstLen + secondLen);
		int index = 0;
		// first和second循环比较,直到其中一个访问完毕
		while (i < firstLen && j < secondLen) {
			if (first.get(i) < second.get(j)) {
				mergedList.insert(index++, first.get(i));
				i++;
			} else {
				mergedList.insert(index++, second.get(j));
				j++;
			}
		}

		// first和second长短不一,未访问完毕的继续进行merge
		while (i < firstLen) {
			mergedList.insert(index++, first.get(i));
			i++;
		}

		while (j < secondLen) {
			mergedList.insert(index++, second.get(j));
			j++;
		}

		return mergedList;
	}

	/**
	 * 从给定的顺序表中删除值在x到y之间的所有元素
	 * 
	 * @param list
	 *            顺序表
	 * @param x
	 * @param y
	 */
	public void deleteRange(SequenceList<Integer> list, int x, int y) {
		if (list == null) {
			return;
		}

		int index = 0;
		for (int i = 0, len = list.size(); i < len; i++) {
			if (list.get(i) >= x && list.get(i) <= y) {
				continue;
			} else {
				list.set(index++, list.get(i));
			}
		}

		for (int i = index; i < list.size(); i++) {
			list.set(index, null);
		}

		list.setSize(index);
	}

	/**
	 * 小于等于value的值放在左边,大于value的值放在右边
	 * 
	 * @param list
	 * @param value
	 */
	// 利用两个指针前后查找,直到两者相遇
	public void moveElemByValue(SequenceList<Integer> list, int value) {
		if (list == null || list.size() <= 0) {
			return;
		}

		int front = 0, rear = list.size() - 1;

		while (front < rear) {
			while (front < rear && list.get(front) <= value) {
				front++;
			}

			while (front < rear && list.get(rear) > value) {
				rear--;
			}

			int temp = list.get(front);
			list.set(front++, list.get(rear));
			list.set(rear--, temp);
		}
	}

	/**
	 * 删除顺序表中所有重复的元素
	 * 
	 * @param list
	 */
	public void deleteAllDul(SequenceList<Integer> list) {
		if (list == null || list.size() <= 1) {
			return;
		}

		int index = 1;
		for (int i = 1, len = list.size(); i < len; i++) {
			//标识是否有重复
			boolean flag = true;
			for (int j = 0; j < index; j++) {
				if (list.get(i) == list.get(j)) {
					flag = false;
					continue;
				}
			}

			if (flag) {
				list.set(index++, list.get(i));
			}
		}

		list.setSize(index);
	}

	/**
	 * 从有序顺序表中删除重复的元素,并使剩下的元素相对位置不变
	 * 
	 * @param list
	 */
	public void deleleOrderedListAllDul(SequenceList<Integer> list) {
		if (list == null || list.size() <= 1) {
			return;
		}

		int index = 0;
		for (int i = 1, len = list.size(); i < len; i++) {
			if (list.get(i) != list.get(index)) {
				list.set(++index, list.get(i));
			}
		}

		list.setSize(++index);
	}
	
}

 

代码下载