JAVA数据结构与算法笔记(基础一)

一、概述

数据结构概述

  1. 数据结构的定义:数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。
  2. 数据存储结构:
    顺序存储
    链式存储
  3. 数据的逻辑结构:
    集合结构:其中的元素属于一个集合,它们是并列关系,没其它关系
    线性结构:元素之间一对一的关系
    树形结构:元素之间一对多的关系,比如文件跟文件夹的关系
    图形结构:元素多对多的关系,呈网状

算法概述

  1. 算法的定义:是指解题方案的准确而完整的描述,是一系列解决问题的清晰指令,算法代表着用系统的方法描述结局问题的策略机制。
  2. 算法的特性:输入,输出,有穷性,无穷性,确定性,可行性
  3. 算法的基本要求:正确性,可读性,健壮性,时间复杂度,空间复杂度

二、线性结构

数组

数组的基本使用:

  1. 创建数组,赋值,取值:
//一维数组
int arr1[] = new int[]{1,2,3,4,5};
int arr2[] = {1,2,3,4};
//二维数组
int myarr[][] = {{1,2,3},{3,4,5,6}};   //为每一维分配内存的数组
  1. 处理数组:
public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // 打印所有数组元素
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList[i];
      }
      System.out.println("Total is " + total);
      // 查找最大元素
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);
   }
}
  1. 解决向数组添加元素,但因为数组的长度不可变,不能直接添加的问题
package domo;
import java.util.Arrays;
public class TestArray1{
  //创建数组并初始化
  int[] arr = new int[] {4,5,6};
  //快速查看数组中的元素
  System.out.println(Arrays.toString(arr));
  //要加入数组的目标元素
  int dst = 6;

  //创建一个新数组,长度是原数组+1
  int[] newArr = new int[arr.length+1];
  //把原数组中的数据全部复制到新的数组中
  for(int i=0;i<arr.length;i++>){
    newArr[i] = arr[i]
  }
  //把目标元素放入新数组的最后
  newArr[arr.length] = dst;
  //新数组替换原数组
  arr = newArr;
  System.out.println(Arrays.toString(arr));
}
  1. 解决删除数组中的某个元素的问题
package domo;
import java.util.Arrays;
public class TestArray2{
  //创建数组并初始化
  int[] arr = new int[] {4,5,6,7,8,9};
  //快速查看数组中的元素
  System.out.println(Arrays.toString(arr));
  //要删除的元素的下标
  int dst = 3;

  //创建一个新数组,长度是原数组-1
  int[] newArr = new int[arr.length-1];
  //复制原数组中除了要删除的那个元素以外的其它元素
  for(int i=0;i<newArr.length;i++>){
    //要删除的元素之前的元素
    if(i<dst>){
      newArr[i] = arr[i];
    }else{
      newArr[i] = arr[i+1];
    }
  }

  //新数组替换原数组
  arr = newArr;
  System.out.println(Arrays.toString(arr));
}

面向对象的数组

数组对象类
1.数组的元素插入
2.数组的元素的删除
3.数组元素的修改
4.数组元素的查看
5.数组元素的遍历
6.数组元素的长度

package array;

public class ArrayUtil {

	//用于存储整形数据的数组
	private int[] elements;

	//重写构造方法
	public ArrayUtil(){
		//初始化数组
		elements=new int[0];
	}

/********         数组插入元素       **************/

	/**
	 * 向数组任意位置插入元素
	 * @param number
	 * @param element
	 * @return
	 */
	public int[] add(int number,int element){
		//判断插入位置的合理性
		if(number < 0  || number >elements.length){
			throw new RuntimeException("下标越界");
		}
		//创建一个新的数组,数组长度是原数组的长度+1
				int [] arr=new int[elements.length+1];
				//遍历原数组
				for(int i=0;i<elements.length;i++){
					//判断插入位置,留出插入位置
					if(i<number){
						arr[i]=elements[i];
					}else {
						arr[i+1]=elements[i];
					}
				}
				//插入位置添加元素
				arr[number]=element;
				//新数组赋值给原数组
				elements=arr;
				//返回原数组,数组插入元素完成
				return elements;
	}

	/**
	 * 向数组头部添加一个元素
	 * @param element
	 * @return
	 */
	public int[] addHead(int element){
				//创建一个新的数组,数组长度是原数组的长度+1
				int [] arr=new int[elements.length+1];
				//遍历原数组,将元素组的值通过下标一一赋值给新数组,新数组下标总是大于原数组下标1
				for(int i=0;i<elements.length;i++){
					arr[i+1]=elements[i];
				}
				//为新数组的第一个索引赋值需要添加的元素
				arr[0]=element;
				//新数组赋值给原数组
				elements=arr;
				//返回原数组,数组头部添加元素完成
				return elements;
	}




	/**
	 * 向数组末尾添加一个元素
	 * @param element
	 * @return
	 */
	public int[] addEnd(int element){
		//创建一个新的数组,数组长度是原数组的长度+1
		int [] arr=new int[elements.length+1];
		//遍历原数组,将元素组的值通过下标一一赋值给新数组
		for(int i=0;i<elements.length;i++){
			arr[i]=elements[i];
		}
		//为新数组的最后一个索引赋值需要添加的元素
		arr[elements.length]=element;
		//新数组赋值给原数组
		elements=arr;
		//返回原数组,数组末尾添加元素完成
		return elements;
	}



	/********         数组插入元素END       **************/







	/********         数组删除元素       **************/

	/**
	 * 删除任意位置的一个元素
	 * @param number
	 * @return
	 */

	public int[] delete(int number){
				//判断删除的元素是否为空数组
				if(elements.length<=0){
					throw new RuntimeException("这是一个空数组");
				}
				//判断删除下标位置的合理性
				if(number <0 || number >=elements.length){
					throw new RuntimeException("下标越界");
				}
				//创建一个新的数组,数组长度是原数组的长度+1
				int [] arr=new int[elements.length-1];
				if(elements.length == 1){
					//新数组赋值给原数组
					elements=arr;
				//返回原数组,数组末尾添加元素完成
				}else{
					//遍历数组
					for(int i=0;i<arr.length;i++){
						if(i<number){
							arr[i]=elements[i];
						}else{
							arr[i]=elements[i+1];
						}
					}
				}
			//新数组赋值给原数组
			elements=arr;
			//返回原数组,数组末尾添加元素完成
			return elements;
	}



	/**
	 * 删除头部第一个元素
	 * @return
	 */
	public int[] deleteHead(){
		//判断删除的元素是否为空数组
		if(elements.length<=0){
			throw new RuntimeException("这是一个空数组");
		}
		//创建一个新的数组,数组长度是原数组的长度+1
		int [] arr=new int[elements.length-1];

		if(elements.length == 1){
			//新数组赋值给原数组
			elements=arr;
		//返回原数组,数组末尾添加元素完成
		return elements;
		}else{
			//遍历新数组,将原数组的值通过下标一一赋值给新数组,
		for(int i=0;i<arr.length;i++){
			arr[i]=elements[i+1];
		}
		//新数组赋值给原数组
			elements=arr;
		//返回原数组,数组末尾添加元素完成
		return elements;
		}
	}




	/**
	 * 删除末尾的一个元素
	 * @return
	 */
	public int[] deleteEnd(){
		//判断删除的元素是否为空数组
		if(elements.length<=0){
			throw new RuntimeException("这是一个空数组");
		}
		//创建一个新的数组,数组长度是原数组的长度+1
		int [] arr=new int[elements.length-1];
		if(elements.length == 1){
			//新数组赋值给原数组
			elements=arr;
		//返回原数组,数组末尾添加元素完成
		return elements;}else{
		//遍历新数组,将原数组的值通过下标一一赋值给新数组,
		for(int i=0;i<arr.length;i++){
			arr[i]=elements[i];
		}
		//新数组赋值给原数组
			elements=arr;
		//返回原数组,数组末尾添加元素完成
		return elements;
	}
	}

	/********         数组删除元素END       **************/





	/********         数组修改元素       **************/

	/**
	 * 修改数组任意位置元素
	 * @param element
	 * @return
	 */
	public int[] alter(int number,int element){
		//判断删除的元素是否为空数组
		if(elements.length<=0){
					throw new RuntimeException("这是一个空数组");
		}
		if(number <0 || number >=elements.length){
			throw new RuntimeException("下标越界");
		}

		elements[number]=element;
		//返回原数组,数组末尾添加元素完成
		return elements;
	}



	/**
	 * 修改头部第一个元素
	 * @param element
	 * @return
	 */
	public int[] alterHead(int element){
		//判断删除的元素是否为空数组
		if(elements.length<=0){
					throw new RuntimeException("这是一个空数组");
		}
		elements[0]=element;
		//返回原数组,数组末尾添加元素完成
		return elements;
	}


	/**
	 * 修改尾部最后一个元素
	 * @param element
	 * @return
	 */
	public int[] alterEnd(int element){
		//判断删除的元素是否为空数组
		if(elements.length<=0){
					throw new RuntimeException("这是一个空数组");
		}
		elements[elements.length-1]=element;
		//返回原数组,数组末尾添加元素完成
		return elements;
	}

/********         数组修改元素END       **************/




	/********         数组查询元素     **************/
	/**
	 * 查询数组头部第一个元素
	 * @return
	 */
	public int  inquireHead(){
		//判断删除的元素是否为空数组
		if(elements.length<=0){
					throw new RuntimeException("这是一个空数组");
		}
		return elements[0];
	}


	/**
	 * 查询数组尾部最后一个元素
	 * @return
	 */
	public int  inquireEnd(){
		//判断删除的元素是否为空数组
		if(elements.length<=0){
					throw new RuntimeException("这是一个空数组");
		}
		return elements[elements.length-1];
	}



	/**
	 * 查询数组任意位置元素
	 * @param number
	 * @return
	 */
	public int  inquire(int number){
		//判断删除的元素是否为空数组
		if(elements.length<=0){
					throw new RuntimeException("这是一个空数组");
		}

		if(number <0 || number >=elements.length){
			throw new RuntimeException("下标越界");
		}

		return elements[number];
	}

/********         数组查询元素END       **************/




	/********         查寻数组    **************/

	public String arrayFor(){
		String str="[";
		if(elements.length ==0){
			str+="]";
			return str;
		}
		for(int i=0;i<elements.length;i++){
			str+=elements[i];
			if(i!=elements.length-1){
				str+=",";
			}
		}

		str+="]";
		return str;
	}

	/********         查询数组END       **************/

	/********         查询数组长度       **************/

	public int arrayLength(){
		int l=0;
		if(elements.length ==0){
			return l;
		}

		for(int i=0;i<elements.length;i++){
			l=i;
		}
		return l+1;
	}

	/********         查询数组长度       **************/
}

数组对象类之测试类

package array;

public class ArrayTest {
	public static void main(String[] args) {
		ArrayUtil au=new ArrayUtil();

	/************添加元素测试*****************/
		//任意位置添加数据(空数组,位置只能是0了)
		au.add(0, 1);
		//数组头部添加一个元素
		au.addHead(0);
		//数组尾部添加一个元素
		au.addEnd(2);

				//任意位置添加数据
				au.add(3, 3);
				//数组头部添加一个元素
				au.addHead(-1);
				//数组尾部添加一个元素
				au.addEnd(4);

		//查看添加元素后的数组
		System.out.println("查看添加元素后的数组"+au.arrayFor());
		//查看数组长度
		System.out.println("查看添加元素后的数组的长度"+au.arrayLength());

		System.out.println("----------------------------");

		/***********添加元素测试END***************/


		/***********删除元素测试***************/
		//删除任意位置的一个元素
			au.delete(3);
			System.out.println("查看删除任意位置元素后的数组"+au.arrayFor());
		//删除头部元素
			au.deleteHead();
			System.out.println("查看删除头部位置元素后的数组"+au.arrayFor());
		//删除尾部元素
			au.deleteEnd();
			System.out.println("查看删除尾部位置元素后的数组"+au.arrayFor());
			//查看数组长度
			System.out.println("查看添加元素后的数组的长度"+au.arrayLength());
			System.out.println("----------------------------");


		/***********删除元素测试END***************/



			/***********修改元素测试***************/
			//修改任意位置的一个元素
				au.alter(1, 200);
				System.out.println("查看修改任意位置元素后的数组"+au.arrayFor());
			//修改头部元素
				au.alterHead(100);
				System.out.println("查看修改头部位置元素后的数组"+au.arrayFor());
			//修改尾部元素
				au.alterEnd(300);
				System.out.println("查看修改尾部位置元素后的数组"+au.arrayFor());
				//查看数组长度
				System.out.println("查看修改元素后的数组的长度"+au.arrayLength());
				System.out.println("----------------------------");


			/***********修改元素测试END***************/


				/***********查询元素测试***************/

				//查询任意位置的一个元素
					System.out.println("查看任意位置1的元素"+au.inquire(1));
				//查询头部元素
					System.out.println("查看头部位置元素"+au.inquireHead());
				//查询尾部元素
					System.out.println("查看尾部位置元素"+au.inquireEnd());
					//查看数组长度
					System.out.println("查看数组的长度"+au.arrayLength());
					System.out.println("----------------------------");


				/***********查询元素测试END***************/
	}
}

已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 游动-白 设计师:白松林 返回首页