数据结构算法

最新推荐文章于 2022-04-15 21:36:17 发布
最新推荐文章于 2022-04-15 21:36:17 发布
阅读量280 收藏 1
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46025729/article/details/119747740
版权

顺序表

1.顺序表的插入
①

public int insert(int i, T x) {
		if (x == null)
			throw new NullPointerException("x==null"); // 抛出空对象异常
		if (i < 0)
			i = 0; // 插入位置i容错，插入在最前
		if (i > this.n)
			i = this.n; // 插入在最后
		Object[] source = this.element; // 数组变量引用赋值，source也引用element数组

		if (this.n == element.length) { // 若数组满，则扩充顺序表的数组容量
			this.element = new Object[source.length * 2]; // 重新申请一个容量更大的数组
			for (int j = 0; j < i; j++) // 复制当前数组前i-1个元素
				this.element[j] = source[j];
		}
		for (int j = this.n - 1; j >= i; j--) // 从i开始至表尾的元素向后移动，次序从后向前 this.element[j + 1] = source[j];

			this.element[i] = x;
		this.n++;
		return i; // 返回x序号
	}

	// 顺序表尾插入x元素，返回x序号。成员方法重载
	public int insert(T x) {
		return this.insert(this.n, x); // 插入操作中，this.n加1
	}

②练习题：
已知顺序表递减有序，将元素x插入到顺序表中，保持其有序性

public void insert1(T x){
		if(x= =null) throw new NullPointerException(“x==null”);
		int t=0;
		for(int i=0;i<=n-1;i++)   // n:顺序表的长度 element[0]~element[n-1]
		  if(x>element[i]){  
		     t=i;
		     break;
		}
		if(i= =n)  t=n;
		insert(t,x);
		}

2.顺序表的删除

public T remove(int i) {// 删除第i个元素，0<=i<n，返回被删除元素。若i越界，则返回null
		if (this.n > 0 && i >= 0 && i < this.n) {
			T old = (T) this.element[i]; // old中存储被删除元素
			for (int j = i; j < this.n - 1; j++)
				this.element[j] = this.element[j + 1]; // 元素前移一个位置 this.element[this.n - 1] = null; //
														// 设置数组元素对象为空，释放原引用实例 this.n--;
			return old; // 返回old局部变量引用的对象，传递对象引用
		}
		return null;
	}

②练习题：
从顺序表中第i个元素开始连续删除k个元素的算法

	public void remove_k(int i,int k){
		if(i>0&&i+k<this.n&&this.n>0){
		for(int j=i+k；j<this.n-1;j++)
		this.element[j-k]=this.element[j];
		  }
		if(i+k>n) n=i;
		else this.n=this.n-k;
		}

单链表

1.单链表的插入

	public Node<T> insert(int i, T x) {
		if (x == null)
			throw new NullPointerException("x==null"); // 抛出空对象异常
		Node<T> front = this.head; // front指向头结点
		for (int j = 0; front.next != null && j < i; j++) // 寻找第i-1个或最后一个结点（front指向）
			front = front.next;
		front.next = new Node<T>(x, front.next);
		// 在front之后插入值为x结点，包括头插入、中间/尾插入
		return front.next; // 返回插入结点
	}

2.单链表的删除

public T remove(int i) {
		Node<T> front = this.head; // front指向头结点
		for (int j = 0; front.next != null && j < i; j++) // 遍历寻找第i-1结点（front指向）
			front = front.next;
		if (i >= 0 && front.next != null) {// 若front的后继结点存在，则删除之 T old = front.next.data; // 获得待删除结点引用的对象 front.next =
											// front.next.next; // 删除front的后继结点，包括头删除、中间/尾删除
			// 由Java虚拟机稍后释放结点占用存储单元
			return old;
		}
		return null; // 若i<0或i>表长
	}

3.单链表的遍历

Node<T>p=head;while(p!=null)
	{
		System.out.print(p.data.toString() + "");
		p = p.next;
	}

二叉树

1.二叉树的先序遍历(递归)

public void preorder() {// 输出先根次序遍历序列
		System.out.print("先根次序遍历二叉树：  ");
		preorder(this.root); // 调用先根次序遍历二叉树的递归方法 System.out.println();
	}

	private void preorder(BinaryNode<T> p) {// 先根次序遍历以p结点为根的子树，递归方法
		if (p != null) { // 若二叉树不空
			System.out.print(p.data.toString() + " ");
			// 先访问当前结点元素 preorder(p.left); //
			// 按先根次序遍历p的左子树，递归调用，参数为左孩子preorder(p.right); //
			// 按先根次序遍历p的右子树，递归调用，参数为右孩子
		}
	}

2.二叉树的中序遍历(递归)

public void inorder() {// 输出中根次序遍历序列
		System.out.print("中根次序遍历二叉树：  ");
		inorder(this.root);
		System.out.println();
	}

	private void inorder(BinaryNode<T> p) // 中根次序遍历以p结点为根的子树，递归方法	{		
		if (p != null) {			
		inorder(p.left); // 中根次序遍历p的左子树，递归调用			System.out.print(p.data.toString() + " ");			
		inorder(p.right); // 中根次序遍历p的右子树，递归调用		
		  }	
		}

3.二叉树的后序遍历(递归)

public void postorder() { // 输出后根次序遍历序
		System.out.print("后根次序遍历二叉树：  ");
		postorder(this.root);
		System.out.println();
	}

	private void postorder(BinaryNode<T> p) { // 后根次序遍历以p结点为根的子树，递归方法
		if (p != null) {
			postorder(p.left);
			postorder(p.right);
			System.out.print(p.data.toString() + " "); // 后访问当前结点元素
		}
	}

4.二叉树的先序遍历(非递归)

public void preorderTraverse(){
		System.out.print("先根次序遍历(非递归)");
		LinkedStack<BinaryNode<T>>stack=new LinkedStack<BinaryNode<T>>();
		BinaryNode<T>p=this.root;
		while(p!=null‖!stack.isEmpty())//p非空或栈非空
		if(p!=null){
		System.out.print(p.data+" ");//访问结点
		stack.push(p);//p结点入栈
		p=p.left;
		}
		else{  //p为空且且栈非空时
		System.out.print("# ");
		p=stack.pop();
		p=p.right;
		  }
		System.out.println();
		}

5.二叉树的中序遍历(非递归)

public void inorderTraverse(){ // 中根次序遍历二叉树的非递归算法		System.out.print("中根次序遍历（非递归）：  ");		SeqStack<BinaryNode<T>> stack = new SeqStack<BinaryNode<T>>(64); // 创建一个空栈		
		BinaryNode<T> p = this.root;		
		while (p != null || !stack.isEmpty()) // p非空或栈非空时			
		if (p != null) {				
		stack.push(p); // p结点入栈				
		p = p.left; // 进入左子树			
		} 
		else {// p为空且栈非空时					
		p = stack.pop(); // p指向出栈结点				
		System.out.print(p.data + " "); // 访问结点				
		p = p.right; // 进入右子树			
		}		
		System.out.println();
			}
		}

6.×二叉树的后序遍历(非递归)

7.构造一颗二叉树的算法

	public BinaryTree(T[] prelist){ // 以标明空子树的先根遍历序列构造二叉树		this.root = create(prelist);	
	}

	// 以从i开始的标明空子树的先根序列，创建一棵以prelist[i]为根的子树，返回根结点，递归方法
	private int i = 0;

	private BinaryNode<T> create(T[] prelist) {
		BinaryNode<T> p = null;
		if (i < prelist.length) {
			T elem = prelist[i];
			i++;
			if (elem != null) { // 不能elem!="∧"，因为T不一定是String p = new BinaryNode<T>(elem); // 创建叶子结点
				p.left = create(prelist); // 创建p的左子树，递归调用，实际参数与形式参数相同
				p.right = create(prelist); // 创建p的右子树，递归调用，实际参数与形式参数相同
			}
		}
		return p;
	}

8.×二叉树层次遍历

查找

1.顺序查找

public int search(T key) {
		for (int i = 0; i < this.n; i++) {
			System.out.print("查找次数：" + i + " ");
			if (key.equals(this.element[i])) {
				return i;
			}
		}
		return -1;
	}

2.二分法查找

public class SortedArray {
		public static int count = 0;
		// 统计比较次数，计算ASL成功 //
		// 已知value数组元素按升序排序，在begin～end范围内，二分法查找关键字为key元素，若查找成功返回下标，否则返回-1；
		// 若begin、end越界，返回-1。若key==null，Java抛出空对象异常。

		public static <T extends Comparable<? super T>> int binarySearch(T[] value, int begin, int end, T key) {		
		count = 0; // 统计比较次数，计算ASL成功		
		while (begin <= end) // 边界有效		{			
		int mid = (begin + end) / 2; 
		// 取中间位置，当前比较元素位置			
		System.out.print("[" + mid + "]=" + value[mid] + "？"); 
		// 显示比较中间结果，可省略			
		count++;			
		if (key.compareTo(value[mid]) == 0) // 两对象相等				
		return mid; // 查找成功			
		if (key.compareTo(value[mid]) < 0) // key对象较小				
		end = mid - 1; // 查找范围缩小到前半段			
		else				
		begin = mid + 1; // 查找范围缩小到后半段		
		}return-1; // 查找不成功
	} 
	// 已知value数组元素按升序排序，二分法查找关键字为key元素，若查找成功返回下标，否则返回-1

	public static <T extends Comparable<? super T>> int binarySearch(T[] value, T key) {
		return binarySearch(value, 0, value.length - 1, key);
	}
}

3.×分块查找

4.×在一颗二叉排序树中查找

排序

1.直接插入排序

public void insertSort() {
		for (int i = 1; i < element.length; i++) {
			int temp = (int) element[i];
			int j;
			for (j = i - 1; j >= 0 && temp < (int) element[j]; j--) {
				element[j + 1] = element[j];
			}
			element[j + 1] = temp;
			System.out.print("第" + i + "趟 temp=" + temp + "\t");
			print();
			System.out.println();
		}
	}

2.希尔排序


	public static void shellSort(int []keys){//希尔排序(升序)
		for(int delta=keys.length/2;delta>0;delta/=2){//若干趟，控制增量每趟减半

		for(int i=delta;i<keys.length;i++){//一趟分若干组，每组直接插入排序
		int temp=keys[i]，j;

		for(j=i-delta；j>=0&&temp<keys[j]；j-=delta)
		keys[j+delta]=keys[j];//组内直接插入排序，寻找插入位置

		keys[j+delta]=temp;
		}
		System.out.print("delta="+delta+" ");
		print(keys);
		 }
	}

3.冒泡排序

    private static void swap(int[] keys, int i, int j) {// 交换keys[i]和keys[j]的值
		int temp = keys[j];
		keys[j] = keys[i];
		keys[i] = temp;
	}

	public static void bubbleSort(int[] keys) {// 升序
		bubbleSort(keys, true);
	}

	public static void ubbleSort(int[]keys,boolean asc){
		System.out.println("冒泡排序("+(asc?"升":"降")+"序)");
		boolean=true;//是否交换的标记

		for(int i=1;i<keys.length&&exchange;i++){//有交换时再进行下一趟，最多n-1趟
		exchange=false;//假定元素未交换

		for(int j=0;j<keys.length;j++)//一趟比较，交换
		if(asc?keys[j]>keys[j+1]:keys[j]<keys[j+1]){
		swap(keys,j,j+1);
		exchange=true;//有交换
		}

		System.out.print("第"+i+"趟 ")；print(keys)；
		  }

	}

4.快速排序

public static void quickSort(int[] keys){ // 快速排序（升序）
		System.out.println("快速排序（升序）");		
		quickSort(keys, 0, keys.length - 1);
    }
    // 对存于keys数组begin～end之间的子序列进行一趟快速排序，递归算法	
	private static void quickSort(int[] keys, int begin, int end) {		
	if(begin>=0&&begin<keys.length&&end>=0&&end<keys.length&&begin<end){// 序列有效
		int i = begin, j = end; // i、j下标分别从子序列的前后两端开始
		int vot = keys[i]; // 子序列第一个值作为基准值
		while (i != j) {
			while (i < j && keys[j] >= vot) // （升序）从后向前寻找较小值，不移动与基准值相等元素
				j--;
			if (i < j)
				keys[i++] = keys[j]; // 子序列后端较小元素向前移动
			while (i < j && keys[i] <= vot) // （升序）从前向后寻找较大值，不移动与基准值相等元素
				i++;
			if (i < j)
				keys[j--] = keys[i]; // 子序列前端较大元素向后移动
		}
		keys[i] = vot; // 基准值到达最终位置
		System.out.print("下标" + begin + "～" + end + "， vot=" + vot + "，  ");
		print(keys);
		quickSort(keys, begin, j - 1);
		// 前端子序列再排序，递归调用 quickSort(keys, i + 1, end); // 后端子序列再排序，递归调用
	    System.out.println();
	}
}

5.×堆排序

6.简单(直接)选择排序

public static void selectSort(int[] keys) { // 直接选择排序（升序）
		System.out.println("直接选择排序（升序）");
		for (int i = 0; i < keys.length - 1; i++) { // n-1趟排序
			int min = i;
			for (int j = i + 1; j < keys.length; j++) // 每趟在从keys[i]开始的子序列中寻找最小元素
				if (keys[j] < keys[min]) // （升序// if (keys[j]>keys[min]) //（降序） min = j; // min记住本趟最小元素下标
					System.out.print("第" + (i + 1) + "趟，下标" + i + "～" + (keys.length - 1) + "，min=" + min + "，");
			if (min != i) // 将本趟最小元素交换到前边
				swap(keys, i, min);
			print(keys);
			System.out.println();
		}

	}

	private static void swap(int[] keys, int i, int j) { // 交换keys[i]与keys[j]元素，i、j范围由调用者控制
		int temp = keys[j];
		keys[j] = keys[i];
		keys[i] = temp;
	}

7.×归并排序

做个开心的小朋友
关注
专栏目录
C++ 数据结构算法集合.zip
12-28
C++ 数据结构算法集合 C++ 数据结构算法集合 C++ 数据结构算法集合 C++ 数据结构算法集合 C++ 数据结构算法集合 C++ 数据结构算法集合 C++ 数据结构算法集合 C++ 数据结构算法集合 C++ 数据结构算法集合 C++ 数据...
数据结构实验——二叉树的基本操作与算法设计（先根、中根、后根遍历，查找关键字）
weixin_45823684的博客
01-13 1467
① 先根次序遍历查找首个关键字为key BinaryNode<T> search(T key) ② 返回key结点所在的层次 int level(T key) 三、实验方法与步骤（需求分析、算法设计思路、流程图等） 实验一： 先根次序遍历查找首个关键字为key 分析： 首先要构造空二叉树，先根次序遍历二叉树。返回先根次序遍历二叉树所有结点的描述字符串，包含空子树标记。在以p为根的...
JAVA数据结构和算法：第六章（树）
春水上行的博客
09-02 1276
树树是n个结点的有限集。n=0时称为空树。在任意一颗非空树中：（1）有且仅有一个特定的称为根的结点；（2）当n>1时，其余结点可分为m(m>0)个互不相交的有限集T1,T2…..Tm，其中每一个集合本身又是一棵树，并且称为根的子树。如下图 结点: 树的结点包含一个数据元素及若干指向其子树的分支。 结点的度：结点拥有的子树数称为结点的度。 叶结点：度为0的结点称为叶结点或终端结点。 分支
删除以元素k为根的子树
vimpirespider的博客
04-15 393
思想： 只要能删除其左，右子树就能释放值为x的结点，后序遍历删除。 层序遍历查找值为k的父节点。 需要完整遍历整科二叉树，所以时间复杂度是O(n) 删除代码 void DeleteTree(Tree &Q){ if(Q==NULL) return; //递归终止条件 DeleteTree(Q->lchild); DeleteTree(Q->rchild); free(Q); } 查找代码 void Findxdelete(Tree &T,int.
2021-10-11 二叉树中查找值为key的结点
SuSA_的博客
10-11 911
主要提醒自己这里的return，还是遍历框架的应用 两个使用框架的题的比较 //! 二叉树的翻转：本质就是二叉树的遍历的应用 //! 以任意形式遍历二叉树的每一个结点，访问每一个结点的同时调换其左右子树 //! 中序遍历额外注意一下调换后的参数问题 Node *BinarySearchTreesZH::invertTreePreOrder(Node *node) { if (node == nullptr) { return node; } Node *tmp
SeqList——插入不重复元素和删除首次出现的与key相等的元素（思考题2-2）
qq_41958081的博客
04-07 841
一、插入不重复元素.查找不成功时尾插入 思考：注意判断是否为空对象或空表。 public int insertDifferent(T x){ if (x==null){ throw new NullPointerException("x==null"); //抛出空对象异常 } if(this.isEmpty()){ //空表时，尾插入 thi...
数据结构算法-数据结构模版
最新发布
09-15
该资源主要包含数据结构算法参考资料以及一些列数据结构算法模版，比如array\backtracking\bfs\binary_search\binary_tree\bit_manipulation\common\dfs\dict\divide_conquer\...
数据结构算法扫盲第二版
11-17
"数据结构算法扫盲第二版" 本资源为数据结构和算法扫盲第二版，主要涵盖了数据结构和算法的基础知识点。下面是本资源中的一些重要知识点： 1. 数据结构：数组、链表、栈、队列、树、图等数据结构的定义、操作和...
数据结构算法代码合集.zip
12-29
数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 数据结构、算法相关的资源 ...
数据结构算法与应用 C语言描述
06-16
现在我们将要开始一个穿越“数据结构、算法和程序”这个抽象世界的特殊旅程，以解决现实生活中的许多难题。在程序开发过程中通常需要做到如下两点：一是高效地描述数据；二是设计一个好的算法，该算法最终可用程序来...
二叉树
adityasaber的博客
10-23 3275
暂时先写了这八个方法 二叉树增加成员方法 BinaryTree二叉树类增加以下成员方法，public权限。 （1）成员方法，递归算法 6-1 BinaryTree(T prelist[], T inlist[]) //以先根和中根序列构造二叉树 6-2 BinaryTree create(T inlist[], T postlist[]) ...
java深拷贝二叉树_数据结构学习----二叉树(Java实现)
weixin_30432831的博客
02-26 622
packagecom.clarck.datastructure.binarytree;importcom.clarck.datastructure.queue.LinkedQueue;importcom.clarck.datastructure.queue.SeqQueue;importcom.clarck.datastructure.stack.LinkedStack;/*** 二叉树类，实现B...
数据结构：构造二叉树（前跟中跟，中跟后跟）
燕双嘤
12-04 4838
先从前序的第一个结点开始，其为根节点，然后在中序中找到该元素，一分为二，中序左边为左子树，右边为右子树，然后从前序中找第二个元素为根结点左子树的根，然后重复上面这个过程，发现出现NULL，跳到右子树。但是，如果在先根遍历中加入反映兄弟结点间的左右次序的信息（如以“^”标明空子树），则可以唯一确定一颗二叉树。当一个结点的左右孩子链都已建立，则以当前结点为根的一棵子树就已建立，返回上一层结点。二叉树的广义表表示语法如下图，其中元素表示结点，“^”表示空子树。，则创建一个结点，该结点的左孩子结点元素是。
由标明空子树的先序遍历序列创建二叉树
zjhzcjg的专栏
11-04 1996
由标明空子树的先序遍历序列创建二叉树 i=0 def createBiTree2(preOrder): # i为常数0 global i c = preOrder[i] # 取字符 if c != '#': root = BiTreeNode(c) i += 1 root.lchild = createBiTree2(preOrder).root i += 1 root.rc...
二叉树根序遍历
王二东的博客
09-09 1801
二叉树 树，是一种常用到的数据结构，可以用来模拟具有树状结构性质的数据集合.在树的结构中，每个节点包含一个节点的值和所有节点的列表.从图的观点来看，树也可以看作是一个由N个节点和N-1条边组成的有向无环图。 在树中，应用最广泛的是二叉树.正如名字中所描述的一样，二叉树的每个节点最多由两个节点(子树结构)，习惯上成为左子树和右子树. 二叉树的数据结构一般使用结构体来进行描述 struct TreeNode { ValueType val; // 当前节点的值 struct TreeN
数据结构删除顺序表中第i个元素
alphahero的博客
03-10 1万+
数据结构删除顺序表中第i个元素 #include <stdio.h> #define MaxSize 10 typedef struct { int data[MaxSize]; int length; }sqlist; sqlist L; bool listdelete(sqlist& l, int i, int& e) { if (i<1 || i>L.length + 1) { printf("位置无效！\n"); return false; }
Java数据结构与算法解析(五)——二叉查找树
一个码农的博客
09-15 5577
二叉查找树简介二叉查找树(Binary Search Tree)，又被称为二叉搜索树。 它是特殊的二叉树：对于二叉树，假设x为二叉树中的任意一个结点，x节点包含关键字key，节点x的key值记为key[x]。如果y是x的左子树中的一个结点，则key[y] <= key[x]；如果y是x的右子树的一个结点，则key[y] >= key[x]。那么，这棵树就是二叉查找树。如下图所示： 在二叉查找树中
数据结构_练习 第7章  查找
热门推荐
Cynical丶Gary_博客
01-09 2万+
1．选择题 （1）对n个元素的表做顺序查找时，若查找每个元素的概率相同，则平均查找长度为（   ）。 A．(n-1)/2       B． n/2        C．(n+1)/2        D．n  答案：C 解释：总查找次数N=1+2+3+…+n=n(n+1)/2，则平均查找长度为N/n=(n+1)/2。 （2）适用于折半查找的表的存储方式及元素排列要求为（   
算法导论-二叉排序树
weixin_34291004的博客
10-12 169
一、定义与性质 定义 　　二叉排序树(Binary Sort Tree)又称二叉查找(搜索)树(Binary Search Tree)。其定义为：二叉排序树或者是空树. 性质 　　（1） 二叉排序树中任一结点x，其左(右)子树中任一结点y(若存在)的关键字必小(大)于x的关键字。 　　（2） 二叉排序树中，各结点关键字是惟一的。 注意：实际应用中...
考研必会：数据结构算法核心梳理与操作
本文是针对考研计算机科学与技术专业考生准备的一篇关于数据结构算法背诵的重要参考资料。文章主要涵盖了线性表的基本操作，这些操作对于理解数据结构和算法在实际编程中的应用至关重要。以下是部分核心知识点的详细...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值